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