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