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