drivers/usb/class/cdc-acm.c

   1 /*
   2  * cdc-acm.c
   3  *
   4  * Copyright (c) 1999 Armin Fuerst      <fuerst@in.tum.de>
   5  * Copyright (c) 1999 Pavel Machek      <pavel@ucw.cz>
   6  * Copyright (c) 1999 Johannes Erdfelt  <johannes@erdfelt.com>
   7  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
   8  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
   9  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
  10  * Copyright (c) 2011 Johan Hovold      <jhovold@gmail.com>
  11  *
  12  * USB Abstract Control Model driver for USB modems and ISDN adapters
  13  *
  14  * Sponsored by SuSE
  15  *
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 2 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29  */
  30
  31 #undef DEBUG
  32 #undef VERBOSE_DEBUG
  33
  34 #include <linux/kernel.h>
  35 #include <linux/errno.h>
  36 #include <linux/init.h>
  37 #include <linux/slab.h>
  38 #include <linux/tty.h>
  39 #include <linux/serial.h>
  40 #include <linux/tty_driver.h>
  41 #include <linux/tty_flip.h>
  42 #include <linux/module.h>
  43 #include <linux/mutex.h>
  44 #include <linux/uaccess.h>
  45 #include <linux/usb.h>
  46 #include <linux/usb/cdc.h>
  47 #include <asm/byteorder.h>
  48 #include <asm/unaligned.h>
  49 #include <linux/list.h>
  50
  51 #include "cdc-acm.h"
  52
  53
  54 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
  55 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  56
  57 static struct usb_driver acm_driver;
  58 static struct tty_driver *acm_tty_driver;
  59 static struct acm *acm_table[ACM_TTY_MINORS];
  60
  61 static DEFINE_MUTEX(open_mutex);
  62
  63 #define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
  64
  65 static const struct tty_port_operations acm_port_ops = {
  66 };
  67
  68 /*
  69  * Functions for ACM control messages.
  70  */
  71
  72 static int acm_ctrl_msg(struct acm *acm, int request, int value,
  73                                                         void *buf, int len)
  74 {
  75         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  76                 request, USB_RT_ACM, value,
  77                 acm->control->altsetting[0].desc.bInterfaceNumber,
  78                 buf, len, 5000);
  79         dev_dbg(&acm->control->dev,
  80                         "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
  81                         __func__, request, value, len, retval);
  82         return retval < 0 ? retval : 0;
  83 }
  84
  85 /* devices aren't required to support these requests.
  86  * the cdc acm descriptor tells whether they do...
  87  */
  88 #define acm_set_control(acm, control) \
  89         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
  90 #define acm_set_line(acm, line) \
  91         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
  92 #define acm_send_break(acm, ms) \
  93         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
  94
  95 /*
  96  * Write buffer management.
  97  * All of these assume proper locks taken by the caller.
  98  */
  99
 100 static int acm_wb_alloc(struct acm *acm)
 101 {
 102         int i, wbn;
 103         struct acm_wb *wb;
 104
 105         wbn = 0;
 106         i = 0;
 107         for (;;) {
 108                 wb = &acm->wb[wbn];
 109                 if (!wb->use) {
 110                         wb->use = 1;
 111                         return wbn;
 112                 }
 113                 wbn = (wbn + 1) % ACM_NW;
 114                 if (++i >= ACM_NW)
 115                         return -1;
 116         }
 117 }
 118
 119 static int acm_wb_is_avail(struct acm *acm)
 120 {
 121         int i, n;
 122         unsigned long flags;
 123
 124         n = ACM_NW;
 125         spin_lock_irqsave(&acm->write_lock, flags);
 126         for (i = 0; i < ACM_NW; i++)
 127                 n -= acm->wb[i].use;
 128         spin_unlock_irqrestore(&acm->write_lock, flags);
 129         return n;
 130 }
 131
 132 /*
 133  * Finish write. Caller must hold acm->write_lock
 134  */
 135 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 136 {
 137         wb->use = 0;
 138         acm->transmitting--;
 139         usb_autopm_put_interface_async(acm->control);
 140 }
 141
 142 /*
 143  * Poke write.
 144  *
 145  * the caller is responsible for locking
 146  */
 147
 148 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 149 {
 150         int rc;
 151
 152         acm->transmitting++;
 153
 154         wb->urb->transfer_buffer = wb->buf;
 155         wb->urb->transfer_dma = wb->dmah;
 156         wb->urb->transfer_buffer_length = wb->len;
 157         wb->urb->dev = acm->dev;
 158
 159         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 160         if (rc < 0) {
 161                 dev_err(&acm->data->dev,
 162                         "%s - usb_submit_urb(write bulk) failed: %d\n",
 163                         __func__, rc);
 164                 acm_write_done(acm, wb);
 165         }
 166         return rc;
 167 }
 168
 169 static int acm_write_start(struct acm *acm, int wbn)
 170 {
 171         unsigned long flags;
 172         struct acm_wb *wb = &acm->wb[wbn];
 173         int rc;
 174
 175         spin_lock_irqsave(&acm->write_lock, flags);
 176         if (!acm->dev) {
 177                 wb->use = 0;
 178                 spin_unlock_irqrestore(&acm->write_lock, flags);
 179                 return -ENODEV;
 180         }
 181
 182         dev_vdbg(&acm->data->dev, "%s - susp_count %d\n", __func__,
 183                                                         acm->susp_count);
 184         usb_autopm_get_interface_async(acm->control);
 185         if (acm->susp_count) {
 186                 if (!acm->delayed_wb)
 187                         acm->delayed_wb = wb;
 188                 else
 189                         usb_autopm_put_interface_async(acm->control);
 190                 spin_unlock_irqrestore(&acm->write_lock, flags);
 191                 return 0;       /* A white lie */
 192         }
 193         usb_mark_last_busy(acm->dev);
 194
 195         rc = acm_start_wb(acm, wb);
 196         spin_unlock_irqrestore(&acm->write_lock, flags);
 197
 198         return rc;
 199
 200 }
 201 /*
 202  * attributes exported through sysfs
 203  */
 204 static ssize_t show_caps
 205 (struct device *dev, struct device_attribute *attr, char *buf)
 206 {
 207         struct usb_interface *intf = to_usb_interface(dev);
 208         struct acm *acm = usb_get_intfdata(intf);
 209
 210         return sprintf(buf, "%d", acm->ctrl_caps);
 211 }
 212 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 213
 214 static ssize_t show_country_codes
 215 (struct device *dev, struct device_attribute *attr, char *buf)
 216 {
 217         struct usb_interface *intf = to_usb_interface(dev);
 218         struct acm *acm = usb_get_intfdata(intf);
 219
 220         memcpy(buf, acm->country_codes, acm->country_code_size);
 221         return acm->country_code_size;
 222 }
 223
 224 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 225
 226 static ssize_t show_country_rel_date
 227 (struct device *dev, struct device_attribute *attr, char *buf)
 228 {
 229         struct usb_interface *intf = to_usb_interface(dev);
 230         struct acm *acm = usb_get_intfdata(intf);
 231
 232         return sprintf(buf, "%d", acm->country_rel_date);
 233 }
 234
 235 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 236 /*
 237  * Interrupt handlers for various ACM device responses
 238  */
 239
 240 /* control interface reports status changes with "interrupt" transfers */
 241 static void acm_ctrl_irq(struct urb *urb)
 242 {
 243         struct acm *acm = urb->context;
 244         struct usb_cdc_notification *dr = urb->transfer_buffer;
 245         struct tty_struct *tty;
 246         unsigned char *data;
 247         int newctrl;
 248         int retval;
 249         int status = urb->status;
 250
 251         switch (status) {
 252         case 0:
 253                 /* success */
 254                 break;
 255         case -ECONNRESET:
 256         case -ENOENT:
 257         case -ESHUTDOWN:
 258                 /* this urb is terminated, clean up */
 259                 dev_dbg(&acm->control->dev,
 260                                 "%s - urb shutting down with status: %d\n",
 261                                 __func__, status);
 262                 return;
 263         default:
 264                 dev_dbg(&acm->control->dev,
 265                                 "%s - nonzero urb status received: %d\n",
 266                                 __func__, status);
 267                 goto exit;
 268         }
 269
 270         if (!ACM_READY(acm))
 271                 goto exit;
 272
 273         usb_mark_last_busy(acm->dev);
 274
 275         data = (unsigned char *)(dr + 1);
 276         switch (dr->bNotificationType) {
 277         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 278                 dev_dbg(&acm->control->dev, "%s - network connection: %d\n",
 279                                                         __func__, dr->wValue);
 280                 break;
 281
 282         case USB_CDC_NOTIFY_SERIAL_STATE:
 283                 tty = tty_port_tty_get(&acm->port);
 284                 newctrl = get_unaligned_le16(data);
 285
 286                 if (tty) {
 287                         if (!acm->clocal &&
 288                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 289                                 dev_dbg(&acm->control->dev,
 290                                         "%s - calling hangup\n", __func__);
 291                                 tty_hangup(tty);
 292                         }
 293                         tty_kref_put(tty);
 294                 }
 295
 296                 acm->ctrlin = newctrl;
 297
 298                 dev_dbg(&acm->control->dev,
 299                         "%s - input control lines: dcd%c dsr%c break%c "
 300                         "ring%c framing%c parity%c overrun%c\n",
 301                         __func__,
 302                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
 303                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 304                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
 305                         acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 306                         acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
 307                         acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 308                         acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 309                         break;
 310
 311         default:
 312                 dev_dbg(&acm->control->dev,
 313                         "%s - unknown notification %d received: index %d "
 314                         "len %d data0 %d data1 %d\n",
 315                         __func__,
 316                         dr->bNotificationType, dr->wIndex,
 317                         dr->wLength, data[0], data[1]);
 318                 break;
 319         }
 320 exit:
 321         retval = usb_submit_urb(urb, GFP_ATOMIC);
 322         if (retval)
 323                 dev_err(&acm->control->dev, "%s - usb_submit_urb failed: %d\n",
 324                                                         __func__, retval);
 325 }
 326
 327 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
 328 {
 329         int res;
 330
 331         if (!test_and_clear_bit(index, &acm->read_urbs_free))
 332                 return 0;
 333
 334         dev_vdbg(&acm->data->dev, "%s - urb %d\n", __func__, index);
 335
 336         res = usb_submit_urb(acm->read_urbs[index], mem_flags);
 337         if (res) {
 338                 if (res != -EPERM) {
 339                         dev_err(&acm->data->dev,
 340                                         "%s - usb_submit_urb failed: %d\n",
 341                                         __func__, res);
 342                 }
 343                 set_bit(index, &acm->read_urbs_free);
 344                 return res;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
 351 {
 352         int res;
 353         int i;
 354
 355         for (i = 0; i < acm->rx_buflimit; ++i) {
 356                 res = acm_submit_read_urb(acm, i, mem_flags);
 357                 if (res)
 358                         return res;
 359         }
 360
 361         return 0;
 362 }
 363
 364 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 365 {
 366         struct tty_struct *tty;
 367
 368         if (!urb->actual_length)
 369                 return;
 370
 371         tty = tty_port_tty_get(&acm->port);
 372         if (!tty)
 373                 return;
 374
 375         tty_insert_flip_string(tty, urb->transfer_buffer, urb->actual_length);
 376         tty_flip_buffer_push(tty);
 377
 378         tty_kref_put(tty);
 379 }
 380
 381 static void acm_read_bulk_callback(struct urb *urb)
 382 {
 383         struct acm_rb *rb = urb->context;
 384         struct acm *acm = rb->instance;
 385         unsigned long flags;
 386
 387         dev_vdbg(&acm->data->dev, "%s - urb %d, len %d\n", __func__,
 388                                         rb->index, urb->actual_length);
 389         set_bit(rb->index, &acm->read_urbs_free);
 390
 391         if (!acm->dev) {
 392                 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
 393                 return;
 394         }
 395         usb_mark_last_busy(acm->dev);
 396
 397         if (urb->status) {
 398                 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
 399                                                         __func__, urb->status);
 400                 return;
 401         }
 402         acm_process_read_urb(acm, urb);
 403
 404         /* throttle device if requested by tty */
 405         spin_lock_irqsave(&acm->read_lock, flags);
 406         acm->throttled = acm->throttle_req;
 407         if (!acm->throttled && !acm->susp_count) {
 408                 spin_unlock_irqrestore(&acm->read_lock, flags);
 409                 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
 410         } else {
 411                 spin_unlock_irqrestore(&acm->read_lock, flags);
 412         }
 413 }
 414
 415 /* data interface wrote those outgoing bytes */
 416 static void acm_write_bulk(struct urb *urb)
 417 {
 418         struct acm_wb *wb = urb->context;
 419         struct acm *acm = wb->instance;
 420         unsigned long flags;
 421
 422         if (urb->status || (urb->actual_length != urb->transfer_buffer_length))
 423                 dev_vdbg(&acm->data->dev, "%s - len %d/%d, status %d\n",
 424                         __func__,
 425                         urb->actual_length,
 426                         urb->transfer_buffer_length,
 427                         urb->status);
 428
 429         spin_lock_irqsave(&acm->write_lock, flags);
 430         acm_write_done(acm, wb);
 431         spin_unlock_irqrestore(&acm->write_lock, flags);
 432         if (ACM_READY(acm))
 433                 schedule_work(&acm->work);
 434 }
 435
 436 static void acm_softint(struct work_struct *work)
 437 {
 438         struct acm *acm = container_of(work, struct acm, work);
 439         struct tty_struct *tty;
 440
 441         dev_vdbg(&acm->data->dev, "%s\n", __func__);
 442
 443         if (!ACM_READY(acm))
 444                 return;
 445         tty = tty_port_tty_get(&acm->port);
 446         if (!tty)
 447                 return;
 448         tty_wakeup(tty);
 449         tty_kref_put(tty);
 450 }
 451
 452 /*
 453  * TTY handlers
 454  */
 455
 456 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 457 {
 458         struct acm *acm;
 459         int rv = -ENODEV;
 460
 461         mutex_lock(&open_mutex);
 462
 463         acm = acm_table[tty->index];
 464         if (!acm || !acm->dev)
 465                 goto out;
 466         else
 467                 rv = 0;
 468
 469         dev_dbg(&acm->control->dev, "%s\n", __func__);
 470
 471         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 472
 473         tty->driver_data = acm;
 474         tty_port_tty_set(&acm->port, tty);
 475
 476         if (usb_autopm_get_interface(acm->control) < 0)
 477                 goto early_bail;
 478         else
 479                 acm->control->needs_remote_wakeup = 1;
 480
 481         mutex_lock(&acm->mutex);
 482         if (acm->port.count++) {
 483                 mutex_unlock(&acm->mutex);
 484                 usb_autopm_put_interface(acm->control);
 485                 goto out;
 486         }
 487
 488         acm->ctrlurb->dev = acm->dev;
 489         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 490                 dev_err(&acm->control->dev,
 491                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
 492                 goto bail_out;
 493         }
 494
 495         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 496             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 497                 goto bail_out;
 498
 499         usb_autopm_put_interface(acm->control);
 500
 501         if (acm_submit_read_urbs(acm, GFP_KERNEL))
 502                 goto bail_out;
 503
 504         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
 505         rv = tty_port_block_til_ready(&acm->port, tty, filp);
 506
 507         mutex_unlock(&acm->mutex);
 508 out:
 509         mutex_unlock(&open_mutex);
 510         return rv;
 511
 512 bail_out:
 513         acm->port.count--;
 514         mutex_unlock(&acm->mutex);
 515         usb_autopm_put_interface(acm->control);
 516 early_bail:
 517         mutex_unlock(&open_mutex);
 518         tty_port_tty_set(&acm->port, NULL);
 519         return -EIO;
 520 }
 521
 522 static void acm_tty_unregister(struct acm *acm)
 523 {
 524         int i;
 525
 526         tty_unregister_device(acm_tty_driver, acm->minor);
 527         usb_put_intf(acm->control);
 528         acm_table[acm->minor] = NULL;
 529         usb_free_urb(acm->ctrlurb);
 530         for (i = 0; i < ACM_NW; i++)
 531                 usb_free_urb(acm->wb[i].urb);
 532         for (i = 0; i < acm->rx_buflimit; i++)
 533                 usb_free_urb(acm->read_urbs[i]);
 534         kfree(acm->country_codes);
 535         kfree(acm);
 536 }
 537
 538 static void acm_port_down(struct acm *acm)
 539 {
 540         int i;
 541
 542         mutex_lock(&open_mutex);
 543         if (acm->dev) {
 544                 usb_autopm_get_interface(acm->control);
 545                 acm_set_control(acm, acm->ctrlout = 0);
 546                 usb_kill_urb(acm->ctrlurb);
 547                 for (i = 0; i < ACM_NW; i++)
 548                         usb_kill_urb(acm->wb[i].urb);
 549                 for (i = 0; i < acm->rx_buflimit; i++)
 550                         usb_kill_urb(acm->read_urbs[i]);
 551                 acm->control->needs_remote_wakeup = 0;
 552                 usb_autopm_put_interface(acm->control);
 553         }
 554         mutex_unlock(&open_mutex);
 555 }
 556
 557 static void acm_tty_hangup(struct tty_struct *tty)
 558 {
 559         struct acm *acm = tty->driver_data;
 560         tty_port_hangup(&acm->port);
 561         acm_port_down(acm);
 562 }
 563
 564 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 565 {
 566         struct acm *acm = tty->driver_data;
 567
 568         /* Perform the closing process and see if we need to do the hardware
 569            shutdown */
 570         if (!acm)
 571                 return;
 572         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
 573                 mutex_lock(&open_mutex);
 574                 if (!acm->dev) {
 575                         tty_port_tty_set(&acm->port, NULL);
 576                         acm_tty_unregister(acm);
 577                         tty->driver_data = NULL;
 578                 }
 579                 mutex_unlock(&open_mutex);
 580                 return;
 581         }
 582         acm_port_down(acm);
 583         tty_port_close_end(&acm->port, tty);
 584         tty_port_tty_set(&acm->port, NULL);
 585 }
 586
 587 static int acm_tty_write(struct tty_struct *tty,
 588                                         const unsigned char *buf, int count)
 589 {
 590         struct acm *acm = tty->driver_data;
 591         int stat;
 592         unsigned long flags;
 593         int wbn;
 594         struct acm_wb *wb;
 595
 596         if (!ACM_READY(acm))
 597                 return -EINVAL;
 598         if (!count)
 599                 return 0;
 600
 601         dev_vdbg(&acm->data->dev, "%s - count %d\n", __func__, count);
 602
 603         spin_lock_irqsave(&acm->write_lock, flags);
 604         wbn = acm_wb_alloc(acm);
 605         if (wbn < 0) {
 606                 spin_unlock_irqrestore(&acm->write_lock, flags);
 607                 return 0;
 608         }
 609         wb = &acm->wb[wbn];
 610
 611         count = (count > acm->writesize) ? acm->writesize : count;
 612         dev_vdbg(&acm->data->dev, "%s - write %d\n", __func__, count);
 613         memcpy(wb->buf, buf, count);
 614         wb->len = count;
 615         spin_unlock_irqrestore(&acm->write_lock, flags);
 616
 617         stat = acm_write_start(acm, wbn);
 618         if (stat < 0)
 619                 return stat;
 620         return count;
 621 }
 622
 623 static int acm_tty_write_room(struct tty_struct *tty)
 624 {
 625         struct acm *acm = tty->driver_data;
 626         if (!ACM_READY(acm))
 627                 return -EINVAL;
 628         /*
 629          * Do not let the line discipline to know that we have a reserve,
 630          * or it might get too enthusiastic.
 631          */
 632         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 633 }
 634
 635 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 636 {
 637         struct acm *acm = tty->driver_data;
 638         if (!ACM_READY(acm))
 639                 return 0;
 640         /*
 641          * This is inaccurate (overcounts), but it works.
 642          */
 643         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 644 }
 645
 646 static void acm_tty_throttle(struct tty_struct *tty)
 647 {
 648         struct acm *acm = tty->driver_data;
 649
 650         if (!ACM_READY(acm))
 651                 return;
 652
 653         spin_lock_irq(&acm->read_lock);
 654         acm->throttle_req = 1;
 655         spin_unlock_irq(&acm->read_lock);
 656 }
 657
 658 static void acm_tty_unthrottle(struct tty_struct *tty)
 659 {
 660         struct acm *acm = tty->driver_data;
 661         unsigned int was_throttled;
 662
 663         if (!ACM_READY(acm))
 664                 return;
 665
 666         spin_lock_irq(&acm->read_lock);
 667         was_throttled = acm->throttled;
 668         acm->throttled = 0;
 669         acm->throttle_req = 0;
 670         spin_unlock_irq(&acm->read_lock);
 671
 672         if (was_throttled)
 673                 acm_submit_read_urbs(acm, GFP_KERNEL);
 674 }
 675
 676 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 677 {
 678         struct acm *acm = tty->driver_data;
 679         int retval;
 680         if (!ACM_READY(acm))
 681                 return -EINVAL;
 682         retval = acm_send_break(acm, state ? 0xffff : 0);
 683         if (retval < 0)
 684                 dev_dbg(&acm->control->dev, "%s - send break failed\n",
 685                                                                 __func__);
 686         return retval;
 687 }
 688
 689 static int acm_tty_tiocmget(struct tty_struct *tty)
 690 {
 691         struct acm *acm = tty->driver_data;
 692
 693         if (!ACM_READY(acm))
 694                 return -EINVAL;
 695
 696         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 697                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 698                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 699                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 700                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 701                TIOCM_CTS;
 702 }
 703
 704 static int acm_tty_tiocmset(struct tty_struct *tty,
 705                             unsigned int set, unsigned int clear)
 706 {
 707         struct acm *acm = tty->driver_data;
 708         unsigned int newctrl;
 709
 710         if (!ACM_READY(acm))
 711                 return -EINVAL;
 712
 713         newctrl = acm->ctrlout;
 714         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 715                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 716         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 717                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 718
 719         newctrl = (newctrl & ~clear) | set;
 720
 721         if (acm->ctrlout == newctrl)
 722                 return 0;
 723         return acm_set_control(acm, acm->ctrlout = newctrl);
 724 }
 725
 726 static int acm_tty_ioctl(struct tty_struct *tty,
 727                                         unsigned int cmd, unsigned long arg)
 728 {
 729         struct acm *acm = tty->driver_data;
 730
 731         if (!ACM_READY(acm))
 732                 return -EINVAL;
 733
 734         return -ENOIOCTLCMD;
 735 }
 736
 737 static const __u32 acm_tty_speed[] = {
 738         0, 50, 75, 110, 134, 150, 200, 300, 600,
 739         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 740         57600, 115200, 230400, 460800, 500000, 576000,
 741         921600, 1000000, 1152000, 1500000, 2000000,
 742         2500000, 3000000, 3500000, 4000000
 743 };
 744
 745 static const __u8 acm_tty_size[] = {
 746         5, 6, 7, 8
 747 };
 748
 749 static void acm_tty_set_termios(struct tty_struct *tty,
 750                                                 struct ktermios *termios_old)
 751 {
 752         struct acm *acm = tty->driver_data;
 753         struct ktermios *termios = tty->termios;
 754         struct usb_cdc_line_coding newline;
 755         int newctrl = acm->ctrlout;
 756
 757         if (!ACM_READY(acm))
 758                 return;
 759
 760         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 761         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 762         newline.bParityType = termios->c_cflag & PARENB ?
 763                                 (termios->c_cflag & PARODD ? 1 : 2) +
 764                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 765         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 766         /* FIXME: Needs to clear unsupported bits in the termios */
 767         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 768
 769         if (!newline.dwDTERate) {
 770                 newline.dwDTERate = acm->line.dwDTERate;
 771                 newctrl &= ~ACM_CTRL_DTR;
 772         } else
 773                 newctrl |=  ACM_CTRL_DTR;
 774
 775         if (newctrl != acm->ctrlout)
 776                 acm_set_control(acm, acm->ctrlout = newctrl);
 777
 778         if (memcmp(&acm->line, &newline, sizeof newline)) {
 779                 memcpy(&acm->line, &newline, sizeof newline);
 780                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
 781                         __func__,
 782                         le32_to_cpu(newline.dwDTERate),
 783                         newline.bCharFormat, newline.bParityType,
 784                         newline.bDataBits);
 785                 acm_set_line(acm, &acm->line);
 786         }
 787 }
 788
 789 /*
 790  * USB probe and disconnect routines.
 791  */
 792
 793 /* Little helpers: write/read buffers free */
 794 static void acm_write_buffers_free(struct acm *acm)
 795 {
 796         int i;
 797         struct acm_wb *wb;
 798         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 799
 800         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 801                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 802 }
 803
 804 static void acm_read_buffers_free(struct acm *acm)
 805 {
 806         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 807         int i;
 808
 809         for (i = 0; i < acm->rx_buflimit; i++)
 810                 usb_free_coherent(usb_dev, acm->readsize,
 811                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
 812 }
 813
 814 /* Little helper: write buffers allocate */
 815 static int acm_write_buffers_alloc(struct acm *acm)
 816 {
 817         int i;
 818         struct acm_wb *wb;
 819
 820         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 821                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 822                     &wb->dmah);
 823                 if (!wb->buf) {
 824                         while (i != 0) {
 825                                 --i;
 826                                 --wb;
 827                                 usb_free_coherent(acm->dev, acm->writesize,
 828                                     wb->buf, wb->dmah);
 829                         }
 830                         return -ENOMEM;
 831                 }
 832         }
 833         return 0;
 834 }
 835
 836 static int acm_probe(struct usb_interface *intf,
 837                      const struct usb_device_id *id)
 838 {
 839         struct usb_cdc_union_desc *union_header = NULL;
 840         struct usb_cdc_country_functional_desc *cfd = NULL;
 841         unsigned char *buffer = intf->altsetting->extra;
 842         int buflen = intf->altsetting->extralen;
 843         struct usb_interface *control_interface;
 844         struct usb_interface *data_interface;
 845         struct usb_endpoint_descriptor *epctrl = NULL;
 846         struct usb_endpoint_descriptor *epread = NULL;
 847         struct usb_endpoint_descriptor *epwrite = NULL;
 848         struct usb_device *usb_dev = interface_to_usbdev(intf);
 849         struct acm *acm;
 850         int minor;
 851         int ctrlsize, readsize;
 852         u8 *buf;
 853         u8 ac_management_function = 0;
 854         u8 call_management_function = 0;
 855         int call_interface_num = -1;
 856         int data_interface_num = -1;
 857         unsigned long quirks;
 858         int num_rx_buf;
 859         int i;
 860         int combined_interfaces = 0;
 861
 862         /* normal quirks */
 863         quirks = (unsigned long)id->driver_info;
 864         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 865
 866         /* handle quirks deadly to normal probing*/
 867         if (quirks == NO_UNION_NORMAL) {
 868                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 869                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 870                 goto skip_normal_probe;
 871         }
 872
 873         /* normal probing*/
 874         if (!buffer) {
 875                 dev_err(&intf->dev, "Weird descriptor references\n");
 876                 return -EINVAL;
 877         }
 878
 879         if (!buflen) {
 880                 if (intf->cur_altsetting->endpoint &&
 881                                 intf->cur_altsetting->endpoint->extralen &&
 882                                 intf->cur_altsetting->endpoint->extra) {
 883                         dev_dbg(&intf->dev,
 884                                 "Seeking extra descriptors on endpoint\n");
 885                         buflen = intf->cur_altsetting->endpoint->extralen;
 886                         buffer = intf->cur_altsetting->endpoint->extra;
 887                 } else {
 888                         dev_err(&intf->dev,
 889                                 "Zero length descriptor references\n");
 890                         return -EINVAL;
 891                 }
 892         }
 893
 894         while (buflen > 0) {
 895                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 896                         dev_err(&intf->dev, "skipping garbage\n");
 897                         goto next_desc;
 898                 }
 899
 900                 switch (buffer[2]) {
 901                 case USB_CDC_UNION_TYPE: /* we've found it */
 902                         if (union_header) {
 903                                 dev_err(&intf->dev, "More than one "
 904                                         "union descriptor, skipping ...\n");
 905                                 goto next_desc;
 906                         }
 907                         union_header = (struct usb_cdc_union_desc *)buffer;
 908                         break;
 909                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 910                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
 911                         break;
 912                 case USB_CDC_HEADER_TYPE: /* maybe check version */
 913                         break; /* for now we ignore it */
 914                 case USB_CDC_ACM_TYPE:
 915                         ac_management_function = buffer[3];
 916                         break;
 917                 case USB_CDC_CALL_MANAGEMENT_TYPE:
 918                         call_management_function = buffer[3];
 919                         call_interface_num = buffer[4];
 920                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
 921                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
 922                         break;
 923                 default:
 924                         /* there are LOTS more CDC descriptors that
 925                          * could legitimately be found here.
 926                          */
 927                         dev_dbg(&intf->dev, "Ignoring descriptor: "
 928                                         "type %02x, length %d\n",
 929                                         buffer[2], buffer[0]);
 930                         break;
 931                 }
 932 next_desc:
 933                 buflen -= buffer[0];
 934                 buffer += buffer[0];
 935         }
 936
 937         if (!union_header) {
 938                 if (call_interface_num > 0) {
 939                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
 940                         /* quirks for Droids MuIn LCD */
 941                         if (quirks & NO_DATA_INTERFACE)
 942                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
 943                         else
 944                                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 945                         control_interface = intf;
 946                 } else {
 947                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
 948                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 949                                 return -ENODEV;
 950                         } else {
 951                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
 952                                 combined_interfaces = 1;
 953                                 control_interface = data_interface = intf;
 954                                 goto look_for_collapsed_interface;
 955                         }
 956                 }
 957         } else {
 958                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 959                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 960                 if (!control_interface || !data_interface) {
 961                         dev_dbg(&intf->dev, "no interfaces\n");
 962                         return -ENODEV;
 963                 }
 964         }
 965
 966         if (data_interface_num != call_interface_num)
 967                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
 968
 969         if (control_interface == data_interface) {
 970                 /* some broken devices designed for windows work this way */
 971                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
 972                 combined_interfaces = 1;
 973                 /* a popular other OS doesn't use it */
 974                 quirks |= NO_CAP_LINE;
 975                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
 976                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
 977                         return -EINVAL;
 978                 }
 979 look_for_collapsed_interface:
 980                 for (i = 0; i < 3; i++) {
 981                         struct usb_endpoint_descriptor *ep;
 982                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
 983
 984                         if (usb_endpoint_is_int_in(ep))
 985                                 epctrl = ep;
 986                         else if (usb_endpoint_is_bulk_out(ep))
 987                                 epwrite = ep;
 988                         else if (usb_endpoint_is_bulk_in(ep))
 989                                 epread = ep;
 990                         else
 991                                 return -EINVAL;
 992                 }
 993                 if (!epctrl || !epread || !epwrite)
 994                         return -ENODEV;
 995                 else
 996                         goto made_compressed_probe;
 997         }
 998
 999 skip_normal_probe:
1000
1001         /*workaround for switched interfaces */
1002         if (data_interface->cur_altsetting->desc.bInterfaceClass
1003                                                 != CDC_DATA_INTERFACE_TYPE) {
1004                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1005                                                 == CDC_DATA_INTERFACE_TYPE) {
1006                         struct usb_interface *t;
1007                         dev_dbg(&intf->dev,
1008                                 "Your device has switched interfaces.\n");
1009                         t = control_interface;
1010                         control_interface = data_interface;
1011                         data_interface = t;
1012                 } else {
1013                         return -EINVAL;
1014                 }
1015         }
1016
1017         /* Accept probe requests only for the control interface */
1018         if (!combined_interfaces && intf != control_interface)
1019                 return -ENODEV;
1020
1021         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1022                 /* valid in this context */
1023                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1024                 return -EBUSY;
1025         }
1026
1027
1028         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1029                 return -EINVAL;
1030
1031         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1032         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1033         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1034
1035
1036         /* workaround for switched endpoints */
1037         if (!usb_endpoint_dir_in(epread)) {
1038                 /* descriptors are swapped */
1039                 struct usb_endpoint_descriptor *t;
1040                 dev_dbg(&intf->dev,
1041                         "The data interface has switched endpoints\n");
1042                 t = epread;
1043                 epread = epwrite;
1044                 epwrite = t;
1045         }
1046 made_compressed_probe:
1047         dev_dbg(&intf->dev, "interfaces are valid\n");
1048         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1049
1050         if (minor == ACM_TTY_MINORS) {
1051                 dev_err(&intf->dev, "no more free acm devices\n");
1052                 return -ENODEV;
1053         }
1054
1055         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1056         if (acm == NULL) {
1057                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1058                 goto alloc_fail;
1059         }
1060
1061         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1062         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1063                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1064         acm->combined_interfaces = combined_interfaces;
1065         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1066         acm->control = control_interface;
1067         acm->data = data_interface;
1068         acm->minor = minor;
1069         acm->dev = usb_dev;
1070         acm->ctrl_caps = ac_management_function;
1071         if (quirks & NO_CAP_LINE)
1072                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1073         acm->ctrlsize = ctrlsize;
1074         acm->readsize = readsize;
1075         acm->rx_buflimit = num_rx_buf;
1076         INIT_WORK(&acm->work, acm_softint);
1077         spin_lock_init(&acm->write_lock);
1078         spin_lock_init(&acm->read_lock);
1079         mutex_init(&acm->mutex);
1080         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1081         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1082         if (acm->is_int_ep)
1083                 acm->bInterval = epread->bInterval;
1084         tty_port_init(&acm->port);
1085         acm->port.ops = &acm_port_ops;
1086
1087         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1088         if (!buf) {
1089                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1090                 goto alloc_fail2;
1091         }
1092         acm->ctrl_buffer = buf;
1093
1094         if (acm_write_buffers_alloc(acm) < 0) {
1095                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1096                 goto alloc_fail4;
1097         }
1098
1099         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1100         if (!acm->ctrlurb) {
1101                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1102                 goto alloc_fail5;
1103         }
1104         for (i = 0; i < num_rx_buf; i++) {
1105                 struct acm_rb *rb = &(acm->read_buffers[i]);
1106                 struct urb *urb;
1107
1108                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1109                                                                 &rb->dma);
1110                 if (!rb->base) {
1111                         dev_err(&intf->dev, "out of memory "
1112                                         "(read bufs usb_alloc_coherent)\n");
1113                         goto alloc_fail6;
1114                 }
1115                 rb->index = i;
1116                 rb->instance = acm;
1117
1118                 urb = usb_alloc_urb(0, GFP_KERNEL);
1119                 if (!urb) {
1120                         dev_err(&intf->dev,
1121                                 "out of memory (read urbs usb_alloc_urb)\n");
1122                         goto alloc_fail6;
1123                 }
1124                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1125                 urb->transfer_dma = rb->dma;
1126                 if (acm->is_int_ep) {
1127                         usb_fill_int_urb(urb, acm->dev,
1128                                          acm->rx_endpoint,
1129                                          rb->base,
1130                                          acm->readsize,
1131                                          acm_read_bulk_callback, rb,
1132                                          acm->bInterval);
1133                 } else {
1134                         usb_fill_bulk_urb(urb, acm->dev,
1135                                           acm->rx_endpoint,
1136                                           rb->base,
1137                                           acm->readsize,
1138                                           acm_read_bulk_callback, rb);
1139                 }
1140
1141                 acm->read_urbs[i] = urb;
1142                 __set_bit(i, &acm->read_urbs_free);
1143         }
1144         for (i = 0; i < ACM_NW; i++) {
1145                 struct acm_wb *snd = &(acm->wb[i]);
1146
1147                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1148                 if (snd->urb == NULL) {
1149                         dev_err(&intf->dev,
1150                                 "out of memory (write urbs usb_alloc_urb)\n");
1151                         goto alloc_fail7;
1152                 }
1153
1154                 if (usb_endpoint_xfer_int(epwrite))
1155                         usb_fill_int_urb(snd->urb, usb_dev,
1156                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1157                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1158                 else
1159                         usb_fill_bulk_urb(snd->urb, usb_dev,
1160                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1161                                 NULL, acm->writesize, acm_write_bulk, snd);
1162                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1163                 snd->instance = acm;
1164         }
1165
1166         usb_set_intfdata(intf, acm);
1167
1168         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1169         if (i < 0)
1170                 goto alloc_fail7;
1171
1172         if (cfd) { /* export the country data */
1173                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1174                 if (!acm->country_codes)
1175                         goto skip_countries;
1176                 acm->country_code_size = cfd->bLength - 4;
1177                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1178                                                         cfd->bLength - 4);
1179                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1180
1181                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1182                 if (i < 0) {
1183                         kfree(acm->country_codes);
1184                         goto skip_countries;
1185                 }
1186
1187                 i = device_create_file(&intf->dev,
1188                                                 &dev_attr_iCountryCodeRelDate);
1189                 if (i < 0) {
1190                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1191                         kfree(acm->country_codes);
1192                         goto skip_countries;
1193                 }
1194         }
1195
1196 skip_countries:
1197         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1198                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1199                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1200                          /* works around buggy devices */
1201                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1202         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1203         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1204
1205         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1206
1207         acm_set_control(acm, acm->ctrlout);
1208
1209         acm->line.dwDTERate = cpu_to_le32(9600);
1210         acm->line.bDataBits = 8;
1211         acm_set_line(acm, &acm->line);
1212
1213         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1214         usb_set_intfdata(data_interface, acm);
1215
1216         usb_get_intf(control_interface);
1217         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1218
1219         acm_table[minor] = acm;
1220
1221         return 0;
1222 alloc_fail7:
1223         for (i = 0; i < ACM_NW; i++)
1224                 usb_free_urb(acm->wb[i].urb);
1225 alloc_fail6:
1226         for (i = 0; i < num_rx_buf; i++)
1227                 usb_free_urb(acm->read_urbs[i]);
1228         acm_read_buffers_free(acm);
1229         usb_free_urb(acm->ctrlurb);
1230 alloc_fail5:
1231         acm_write_buffers_free(acm);
1232 alloc_fail4:
1233         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1234 alloc_fail2:
1235         kfree(acm);
1236 alloc_fail:
1237         return -ENOMEM;
1238 }
1239
1240 static void stop_data_traffic(struct acm *acm)
1241 {
1242         int i;
1243
1244         dev_dbg(&acm->control->dev, "%s\n", __func__);
1245
1246         usb_kill_urb(acm->ctrlurb);
1247         for (i = 0; i < ACM_NW; i++)
1248                 usb_kill_urb(acm->wb[i].urb);
1249         for (i = 0; i < acm->rx_buflimit; i++)
1250                 usb_kill_urb(acm->read_urbs[i]);
1251
1252         cancel_work_sync(&acm->work);
1253 }
1254
1255 static void acm_disconnect(struct usb_interface *intf)
1256 {
1257         struct acm *acm = usb_get_intfdata(intf);
1258         struct usb_device *usb_dev = interface_to_usbdev(intf);
1259         struct tty_struct *tty;
1260
1261         /* sibling interface is already cleaning up */
1262         if (!acm)
1263                 return;
1264
1265         mutex_lock(&open_mutex);
1266         if (acm->country_codes) {
1267                 device_remove_file(&acm->control->dev,
1268                                 &dev_attr_wCountryCodes);
1269                 device_remove_file(&acm->control->dev,
1270                                 &dev_attr_iCountryCodeRelDate);
1271         }
1272         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1273         acm->dev = NULL;
1274         usb_set_intfdata(acm->control, NULL);
1275         usb_set_intfdata(acm->data, NULL);
1276
1277         stop_data_traffic(acm);
1278
1279         acm_write_buffers_free(acm);
1280         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1281                           acm->ctrl_dma);
1282         acm_read_buffers_free(acm);
1283
1284         if (!acm->combined_interfaces)
1285                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1286                                         acm->data : acm->control);
1287
1288         if (acm->port.count == 0) {
1289                 acm_tty_unregister(acm);
1290                 mutex_unlock(&open_mutex);
1291                 return;
1292         }
1293
1294         mutex_unlock(&open_mutex);
1295         tty = tty_port_tty_get(&acm->port);
1296         if (tty) {
1297                 tty_hangup(tty);
1298                 tty_kref_put(tty);
1299         }
1300 }
1301
1302 #ifdef CONFIG_PM
1303 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1304 {
1305         struct acm *acm = usb_get_intfdata(intf);
1306         int cnt;
1307
1308         if (message.event & PM_EVENT_AUTO) {
1309                 int b;
1310
1311                 spin_lock_irq(&acm->write_lock);
1312                 b = acm->transmitting;
1313                 spin_unlock_irq(&acm->write_lock);
1314                 if (b)
1315                         return -EBUSY;
1316         }
1317
1318         spin_lock_irq(&acm->read_lock);
1319         spin_lock(&acm->write_lock);
1320         cnt = acm->susp_count++;
1321         spin_unlock(&acm->write_lock);
1322         spin_unlock_irq(&acm->read_lock);
1323
1324         if (cnt)
1325                 return 0;
1326         /*
1327         we treat opened interfaces differently,
1328         we must guard against open
1329         */
1330         mutex_lock(&acm->mutex);
1331
1332         if (acm->port.count)
1333                 stop_data_traffic(acm);
1334
1335         mutex_unlock(&acm->mutex);
1336         return 0;
1337 }
1338
1339 static int acm_resume(struct usb_interface *intf)
1340 {
1341         struct acm *acm = usb_get_intfdata(intf);
1342         struct acm_wb *wb;
1343         int rv = 0;
1344         int cnt;
1345
1346         spin_lock_irq(&acm->read_lock);
1347         acm->susp_count -= 1;
1348         cnt = acm->susp_count;
1349         spin_unlock_irq(&acm->read_lock);
1350
1351         if (cnt)
1352                 return 0;
1353
1354         mutex_lock(&acm->mutex);
1355         if (acm->port.count) {
1356                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1357
1358                 spin_lock_irq(&acm->write_lock);
1359                 if (acm->delayed_wb) {
1360                         wb = acm->delayed_wb;
1361                         acm->delayed_wb = NULL;
1362                         spin_unlock_irq(&acm->write_lock);
1363                         acm_start_wb(acm, wb);
1364                 } else {
1365                         spin_unlock_irq(&acm->write_lock);
1366                 }
1367
1368                 /*
1369                  * delayed error checking because we must
1370                  * do the write path at all cost
1371                  */
1372                 if (rv < 0)
1373                         goto err_out;
1374
1375                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1376         }
1377
1378 err_out:
1379         mutex_unlock(&acm->mutex);
1380         return rv;
1381 }
1382
1383 static int acm_reset_resume(struct usb_interface *intf)
1384 {
1385         struct acm *acm = usb_get_intfdata(intf);
1386         struct tty_struct *tty;
1387
1388         mutex_lock(&acm->mutex);
1389         if (acm->port.count) {
1390                 tty = tty_port_tty_get(&acm->port);
1391                 if (tty) {
1392                         tty_hangup(tty);
1393                         tty_kref_put(tty);
1394                 }
1395         }
1396         mutex_unlock(&acm->mutex);
1397         return acm_resume(intf);
1398 }
1399
1400 #endif /* CONFIG_PM */
1401
1402 #define NOKIA_PCSUITE_ACM_INFO(x) \
1403                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1404                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1405                 USB_CDC_ACM_PROTO_VENDOR)
1406
1407 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1408                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1409                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1410                 USB_CDC_ACM_PROTO_VENDOR)
1411
1412 /*
1413  * USB driver structure.
1414  */
1415
1416 static const struct usb_device_id acm_ids[] = {
1417         /* quirky and broken devices */
1418         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1419         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1420         },
1421         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1422         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1423         },
1424         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1425         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1426         },
1427         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1428         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1429         },
1430         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1431         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1432         },
1433         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1434         .driver_info = SINGLE_RX_URB,
1435         },
1436         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1437         .driver_info = SINGLE_RX_URB, /* firmware bug */
1438         },
1439         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1440         .driver_info = SINGLE_RX_URB, /* firmware bug */
1441         },
1442         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1443         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1444         },
1445         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1446         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1447         },
1448         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1449         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1450         },
1451         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1452         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1453         },
1454         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1455         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1456         },
1457         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1458         },
1459         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1460         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1461                                            data interface instead of
1462                                            communications interface.
1463                                            Maybe we should define a new
1464                                            quirk for this. */
1465         },
1466         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1467         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1468         },
1469         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1470         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1471         },
1472
1473         /* Nokia S60 phones expose two ACM channels. The first is
1474          * a modem and is picked up by the standard AT-command
1475          * information below. The second is 'vendor-specific' but
1476          * is treated as a serial device at the S60 end, so we want
1477          * to expose it on Linux too. */
1478         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1479         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1480         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1481         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1482         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1483         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1484         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1485         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1486         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1487         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1488         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1489         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1490         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1491         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1492         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1493         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1494         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1495         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1496         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1497         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1498         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1499         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1500         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1501         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1502         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1503         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1504         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1505         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1506         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1507         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1508         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1509         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1510         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1511         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1512         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1513         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1514         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1515         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1516         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1517         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1518         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1519         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1520         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1521         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1522         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1523         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1524         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1525         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1526         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1527         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1528         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1529         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1530         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1531         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1532         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1533         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1534         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1535         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1536
1537         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1538
1539         /* Support Lego NXT using pbLua firmware */
1540         { USB_DEVICE(0x0694, 0xff00),
1541         .driver_info = NOT_A_MODEM,
1542         },
1543
1544         /* Support for Droids MuIn LCD */
1545         { USB_DEVICE(0x04d8, 0x000b),
1546         .driver_info = NO_DATA_INTERFACE,
1547         },
1548
1549         /* control interfaces without any protocol set */
1550         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1551                 USB_CDC_PROTO_NONE) },
1552
1553         /* control interfaces with various AT-command sets */
1554         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1555                 USB_CDC_ACM_PROTO_AT_V25TER) },
1556         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1557                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1558         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1559                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1560         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1561                 USB_CDC_ACM_PROTO_AT_GSM) },
1562         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1563                 USB_CDC_ACM_PROTO_AT_3G) },
1564         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1565                 USB_CDC_ACM_PROTO_AT_CDMA) },
1566
1567         { }
1568 };
1569
1570 MODULE_DEVICE_TABLE(usb, acm_ids);
1571
1572 static struct usb_driver acm_driver = {
1573         .name =         "cdc_acm",
1574         .probe =        acm_probe,
1575         .disconnect =   acm_disconnect,
1576 #ifdef CONFIG_PM
1577         .suspend =      acm_suspend,
1578         .resume =       acm_resume,
1579         .reset_resume = acm_reset_resume,
1580 #endif
1581         .id_table =     acm_ids,
1582 #ifdef CONFIG_PM
1583         .supports_autosuspend = 1,
1584 #endif
1585 };
1586
1587 /*
1588  * TTY driver structures.
1589  */
1590
1591 static const struct tty_operations acm_ops = {
1592         .open =                 acm_tty_open,
1593         .close =                acm_tty_close,
1594         .hangup =               acm_tty_hangup,
1595         .write =                acm_tty_write,
1596         .write_room =           acm_tty_write_room,
1597         .ioctl =                acm_tty_ioctl,
1598         .throttle =             acm_tty_throttle,
1599         .unthrottle =           acm_tty_unthrottle,
1600         .chars_in_buffer =      acm_tty_chars_in_buffer,
1601         .break_ctl =            acm_tty_break_ctl,
1602         .set_termios =          acm_tty_set_termios,
1603         .tiocmget =             acm_tty_tiocmget,
1604         .tiocmset =             acm_tty_tiocmset,
1605 };
1606
1607 /*
1608  * Init / exit.
1609  */
1610
1611 static int __init acm_init(void)
1612 {
1613         int retval;
1614         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1615         if (!acm_tty_driver)
1616                 return -ENOMEM;
1617         acm_tty_driver->owner = THIS_MODULE,
1618         acm_tty_driver->driver_name = "acm",
1619         acm_tty_driver->name = "ttyACM",
1620         acm_tty_driver->major = ACM_TTY_MAJOR,
1621         acm_tty_driver->minor_start = 0,
1622         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1623         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1624         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1625         acm_tty_driver->init_termios = tty_std_termios;
1626         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1627                                                                 HUPCL | CLOCAL;
1628         tty_set_operations(acm_tty_driver, &acm_ops);
1629
1630         retval = tty_register_driver(acm_tty_driver);
1631         if (retval) {
1632                 put_tty_driver(acm_tty_driver);
1633                 return retval;
1634         }
1635
1636         retval = usb_register(&acm_driver);
1637         if (retval) {
1638                 tty_unregister_driver(acm_tty_driver);
1639                 put_tty_driver(acm_tty_driver);
1640                 return retval;
1641         }
1642
1643         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1644
1645         return 0;
1646 }
1647
1648 static void __exit acm_exit(void)
1649 {
1650         usb_deregister(&acm_driver);
1651         tty_unregister_driver(acm_tty_driver);
1652         put_tty_driver(acm_tty_driver);
1653 }
1654
1655 module_init(acm_init);
1656 module_exit(acm_exit);
1657
1658 MODULE_AUTHOR(DRIVER_AUTHOR);
1659 MODULE_DESCRIPTION(DRIVER_DESC);
1660 MODULE_LICENSE("GPL");
1661 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);