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;
 941         struct usb_endpoint_descriptor *epread;
 942         struct usb_endpoint_descriptor *epwrite;
 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
 956         /* normal quirks */
 957         quirks = (unsigned long)id->driver_info;
 958         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 959
 960         /* handle quirks deadly to normal probing*/
 961         if (quirks == NO_UNION_NORMAL) {
 962                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 963                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 964                 goto skip_normal_probe;
 965         }
 966
 967         /* normal probing*/
 968         if (!buffer) {
 969                 dev_err(&intf->dev, "Weird descriptor references\n");
 970                 return -EINVAL;
 971         }
 972
 973         if (!buflen) {
 974                 if (intf->cur_altsetting->endpoint->extralen &&
 975                                 intf->cur_altsetting->endpoint->extra) {
 976                         dev_dbg(&intf->dev,
 977                                 "Seeking extra descriptors on endpoint\n");
 978                         buflen = intf->cur_altsetting->endpoint->extralen;
 979                         buffer = intf->cur_altsetting->endpoint->extra;
 980                 } else {
 981                         dev_err(&intf->dev,
 982                                 "Zero length descriptor references\n");
 983                         return -EINVAL;
 984                 }
 985         }
 986
 987         while (buflen > 0) {
 988                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 989                         dev_err(&intf->dev, "skipping garbage\n");
 990                         goto next_desc;
 991                 }
 992
 993                 switch (buffer[2]) {
 994                 case USB_CDC_UNION_TYPE: /* we've found it */
 995                         if (union_header) {
 996                                 dev_err(&intf->dev, "More than one "
 997                                         "union descriptor, skipping ...\n");
 998                                 goto next_desc;
 999                         }
1000                         union_header = (struct usb_cdc_union_desc *)buffer;
1001                         break;
1002                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1003                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
1004                         break;
1005                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1006                         break; /* for now we ignore it */
1007                 case USB_CDC_ACM_TYPE:
1008                         ac_management_function = buffer[3];
1009                         break;
1010                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1011                         call_management_function = buffer[3];
1012                         call_interface_num = buffer[4];
1013                         if ((call_management_function & 3) != 3)
1014                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1015                         break;
1016                 default:
1017                         /* there are LOTS more CDC descriptors that
1018                          * could legitimately be found here.
1019                          */
1020                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1021                                         "type %02x, length %d\n",
1022                                         buffer[2], buffer[0]);
1023                         break;
1024                 }
1025 next_desc:
1026                 buflen -= buffer[0];
1027                 buffer += buffer[0];
1028         }
1029
1030         if (!union_header) {
1031                 if (call_interface_num > 0) {
1032                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1033                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1034                         control_interface = intf;
1035                 } else {
1036                         dev_dbg(&intf->dev,
1037                                         "No union descriptor, giving up\n");
1038                         return -ENODEV;
1039                 }
1040         } else {
1041                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1042                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1043                 if (!control_interface || !data_interface) {
1044                         dev_dbg(&intf->dev, "no interfaces\n");
1045                         return -ENODEV;
1046                 }
1047         }
1048
1049         if (data_interface_num != call_interface_num)
1050                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1051
1052 skip_normal_probe:
1053
1054         /*workaround for switched interfaces */
1055         if (data_interface->cur_altsetting->desc.bInterfaceClass
1056                                                 != CDC_DATA_INTERFACE_TYPE) {
1057                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1058                                                 == CDC_DATA_INTERFACE_TYPE) {
1059                         struct usb_interface *t;
1060                         dev_dbg(&intf->dev,
1061                                 "Your device has switched interfaces.\n");
1062                         t = control_interface;
1063                         control_interface = data_interface;
1064                         data_interface = t;
1065                 } else {
1066                         return -EINVAL;
1067                 }
1068         }
1069
1070         /* Accept probe requests only for the control interface */
1071         if (intf != control_interface)
1072                 return -ENODEV;
1073
1074         if (usb_interface_claimed(data_interface)) { /* valid in this context */
1075                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1076                 return -EBUSY;
1077         }
1078
1079
1080         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1081                 return -EINVAL;
1082
1083         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1084         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1085         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1086
1087
1088         /* workaround for switched endpoints */
1089         if (!usb_endpoint_dir_in(epread)) {
1090                 /* descriptors are swapped */
1091                 struct usb_endpoint_descriptor *t;
1092                 dev_dbg(&intf->dev,
1093                         "The data interface has switched endpoints\n");
1094                 t = epread;
1095                 epread = epwrite;
1096                 epwrite = t;
1097         }
1098         dbg("interfaces are valid");
1099         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1100
1101         if (minor == ACM_TTY_MINORS) {
1102                 dev_err(&intf->dev, "no more free acm devices\n");
1103                 return -ENODEV;
1104         }
1105
1106         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1107         if (acm == NULL) {
1108                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1109                 goto alloc_fail;
1110         }
1111
1112         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1113         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1114                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1115         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1116         acm->control = control_interface;
1117         acm->data = data_interface;
1118         acm->minor = minor;
1119         acm->dev = usb_dev;
1120         acm->ctrl_caps = ac_management_function;
1121         acm->ctrlsize = ctrlsize;
1122         acm->readsize = readsize;
1123         acm->rx_buflimit = num_rx_buf;
1124         acm->urb_task.func = acm_rx_tasklet;
1125         acm->urb_task.data = (unsigned long) acm;
1126         INIT_WORK(&acm->work, acm_softint);
1127         INIT_WORK(&acm->waker, acm_waker);
1128         init_waitqueue_head(&acm->drain_wait);
1129         spin_lock_init(&acm->throttle_lock);
1130         spin_lock_init(&acm->write_lock);
1131         spin_lock_init(&acm->read_lock);
1132         mutex_init(&acm->mutex);
1133         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1134         tty_port_init(&acm->port);
1135         acm->port.ops = &acm_port_ops;
1136
1137         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1138         if (!buf) {
1139                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1140                 goto alloc_fail2;
1141         }
1142         acm->ctrl_buffer = buf;
1143
1144         if (acm_write_buffers_alloc(acm) < 0) {
1145                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1146                 goto alloc_fail4;
1147         }
1148
1149         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1150         if (!acm->ctrlurb) {
1151                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1152                 goto alloc_fail5;
1153         }
1154         for (i = 0; i < num_rx_buf; i++) {
1155                 struct acm_ru *rcv = &(acm->ru[i]);
1156
1157                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1158                 if (rcv->urb == NULL) {
1159                         dev_dbg(&intf->dev,
1160                                 "out of memory (read urbs usb_alloc_urb)\n");
1161                         goto alloc_fail7;
1162                 }
1163
1164                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1165                 rcv->instance = acm;
1166         }
1167         for (i = 0; i < num_rx_buf; i++) {
1168                 struct acm_rb *rb = &(acm->rb[i]);
1169
1170                 rb->base = usb_buffer_alloc(acm->dev, readsize,
1171                                 GFP_KERNEL, &rb->dma);
1172                 if (!rb->base) {
1173                         dev_dbg(&intf->dev,
1174                                 "out of memory (read bufs usb_buffer_alloc)\n");
1175                         goto alloc_fail7;
1176                 }
1177         }
1178         for (i = 0; i < ACM_NW; i++) {
1179                 struct acm_wb *snd = &(acm->wb[i]);
1180
1181                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1182                 if (snd->urb == NULL) {
1183                         dev_dbg(&intf->dev,
1184                                 "out of memory (write urbs usb_alloc_urb)");
1185                         goto alloc_fail7;
1186                 }
1187
1188                 usb_fill_bulk_urb(snd->urb, usb_dev,
1189                         usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1190                         NULL, acm->writesize, acm_write_bulk, snd);
1191                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1192                 snd->instance = acm;
1193         }
1194
1195         usb_set_intfdata(intf, acm);
1196
1197         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1198         if (i < 0)
1199                 goto alloc_fail8;
1200
1201         if (cfd) { /* export the country data */
1202                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1203                 if (!acm->country_codes)
1204                         goto skip_countries;
1205                 acm->country_code_size = cfd->bLength - 4;
1206                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1207                                                         cfd->bLength - 4);
1208                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1209
1210                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1211                 if (i < 0) {
1212                         kfree(acm->country_codes);
1213                         goto skip_countries;
1214                 }
1215
1216                 i = device_create_file(&intf->dev,
1217                                                 &dev_attr_iCountryCodeRelDate);
1218                 if (i < 0) {
1219                         kfree(acm->country_codes);
1220                         goto skip_countries;
1221                 }
1222         }
1223
1224 skip_countries:
1225         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1226                         usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1227                         acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1228                         epctrl->bInterval);
1229         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1230         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1231
1232         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1233
1234         acm_set_control(acm, acm->ctrlout);
1235
1236         acm->line.dwDTERate = cpu_to_le32(9600);
1237         acm->line.bDataBits = 8;
1238         acm_set_line(acm, &acm->line);
1239
1240         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1241         usb_set_intfdata(data_interface, acm);
1242
1243         usb_get_intf(control_interface);
1244         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1245
1246         acm_table[minor] = acm;
1247
1248         return 0;
1249 alloc_fail8:
1250         for (i = 0; i < ACM_NW; i++)
1251                 usb_free_urb(acm->wb[i].urb);
1252 alloc_fail7:
1253         acm_read_buffers_free(acm);
1254         for (i = 0; i < num_rx_buf; i++)
1255                 usb_free_urb(acm->ru[i].urb);
1256         usb_free_urb(acm->ctrlurb);
1257 alloc_fail5:
1258         acm_write_buffers_free(acm);
1259 alloc_fail4:
1260         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1261 alloc_fail2:
1262         kfree(acm);
1263 alloc_fail:
1264         return -ENOMEM;
1265 }
1266
1267 static void stop_data_traffic(struct acm *acm)
1268 {
1269         int i;
1270         dbg("Entering stop_data_traffic");
1271
1272         tasklet_disable(&acm->urb_task);
1273
1274         usb_kill_urb(acm->ctrlurb);
1275         for (i = 0; i < ACM_NW; i++)
1276                 usb_kill_urb(acm->wb[i].urb);
1277         for (i = 0; i < acm->rx_buflimit; i++)
1278                 usb_kill_urb(acm->ru[i].urb);
1279
1280         tasklet_enable(&acm->urb_task);
1281
1282         cancel_work_sync(&acm->work);
1283         cancel_work_sync(&acm->waker);
1284 }
1285
1286 static void acm_disconnect(struct usb_interface *intf)
1287 {
1288         struct acm *acm = usb_get_intfdata(intf);
1289         struct usb_device *usb_dev = interface_to_usbdev(intf);
1290         struct tty_struct *tty;
1291
1292         /* sibling interface is already cleaning up */
1293         if (!acm)
1294                 return;
1295
1296         mutex_lock(&open_mutex);
1297         if (acm->country_codes) {
1298                 device_remove_file(&acm->control->dev,
1299                                 &dev_attr_wCountryCodes);
1300                 device_remove_file(&acm->control->dev,
1301                                 &dev_attr_iCountryCodeRelDate);
1302         }
1303         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1304         acm->dev = NULL;
1305         usb_set_intfdata(acm->control, NULL);
1306         usb_set_intfdata(acm->data, NULL);
1307
1308         stop_data_traffic(acm);
1309
1310         acm_write_buffers_free(acm);
1311         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1312                                                                 acm->ctrl_dma);
1313         acm_read_buffers_free(acm);
1314
1315         usb_driver_release_interface(&acm_driver, intf == acm->control ?
1316                                         acm->data : acm->control);
1317
1318         if (acm->port.count == 0) {
1319                 acm_tty_unregister(acm);
1320                 mutex_unlock(&open_mutex);
1321                 return;
1322         }
1323
1324         mutex_unlock(&open_mutex);
1325         tty = tty_port_tty_get(&acm->port);
1326         if (tty) {
1327                 tty_hangup(tty);
1328                 tty_kref_put(tty);
1329         }
1330 }
1331
1332 #ifdef CONFIG_PM
1333 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1334 {
1335         struct acm *acm = usb_get_intfdata(intf);
1336         int cnt;
1337
1338         if (message.event & PM_EVENT_AUTO) {
1339                 int b;
1340
1341                 spin_lock_irq(&acm->read_lock);
1342                 spin_lock(&acm->write_lock);
1343                 b = acm->processing + acm->transmitting;
1344                 spin_unlock(&acm->write_lock);
1345                 spin_unlock_irq(&acm->read_lock);
1346                 if (b)
1347                         return -EBUSY;
1348         }
1349
1350         spin_lock_irq(&acm->read_lock);
1351         spin_lock(&acm->write_lock);
1352         cnt = acm->susp_count++;
1353         spin_unlock(&acm->write_lock);
1354         spin_unlock_irq(&acm->read_lock);
1355
1356         if (cnt)
1357                 return 0;
1358         /*
1359         we treat opened interfaces differently,
1360         we must guard against open
1361         */
1362         mutex_lock(&acm->mutex);
1363
1364         if (acm->port.count)
1365                 stop_data_traffic(acm);
1366
1367         mutex_unlock(&acm->mutex);
1368         return 0;
1369 }
1370
1371 static int acm_resume(struct usb_interface *intf)
1372 {
1373         struct acm *acm = usb_get_intfdata(intf);
1374         int rv = 0;
1375         int cnt;
1376
1377         spin_lock_irq(&acm->read_lock);
1378         acm->susp_count -= 1;
1379         cnt = acm->susp_count;
1380         spin_unlock_irq(&acm->read_lock);
1381
1382         if (cnt)
1383                 return 0;
1384
1385         mutex_lock(&acm->mutex);
1386         if (acm->port.count) {
1387                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1388                 if (rv < 0)
1389                         goto err_out;
1390
1391                 tasklet_schedule(&acm->urb_task);
1392         }
1393
1394 err_out:
1395         mutex_unlock(&acm->mutex);
1396         return rv;
1397 }
1398
1399 #endif /* CONFIG_PM */
1400 /*
1401  * USB driver structure.
1402  */
1403
1404 static struct usb_device_id acm_ids[] = {
1405         /* quirky and broken devices */
1406         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1407         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1408         },
1409         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1410         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1411         },
1412         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1413         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1414         },
1415         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1416         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1417         },
1418         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1419         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1420         },
1421         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1422         .driver_info = SINGLE_RX_URB,
1423         },
1424         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1425         .driver_info = SINGLE_RX_URB, /* firmware bug */
1426         },
1427         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1428         .driver_info = SINGLE_RX_URB, /* firmware bug */
1429         },
1430         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1431         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1432         },
1433         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1434         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1435         },
1436         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1437         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1438         },
1439         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1440         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1441         },
1442         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1443         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1444         },
1445         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1446         },
1447         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1448         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1449                                            data interface instead of
1450                                            communications interface.
1451                                            Maybe we should define a new
1452                                            quirk for this. */
1453         },
1454
1455         /* control interfaces with various AT-command sets */
1456         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1457                 USB_CDC_ACM_PROTO_AT_V25TER) },
1458         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1459                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1460         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1461                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1462         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1463                 USB_CDC_ACM_PROTO_AT_GSM) },
1464         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1465                 USB_CDC_ACM_PROTO_AT_3G) },
1466         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1467                 USB_CDC_ACM_PROTO_AT_CDMA) },
1468
1469         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1470         { }
1471 };
1472
1473 MODULE_DEVICE_TABLE(usb, acm_ids);
1474
1475 static struct usb_driver acm_driver = {
1476         .name =         "cdc_acm",
1477         .probe =        acm_probe,
1478         .disconnect =   acm_disconnect,
1479 #ifdef CONFIG_PM
1480         .suspend =      acm_suspend,
1481         .resume =       acm_resume,
1482 #endif
1483         .id_table =     acm_ids,
1484 #ifdef CONFIG_PM
1485         .supports_autosuspend = 1,
1486 #endif
1487 };
1488
1489 /*
1490  * TTY driver structures.
1491  */
1492
1493 static const struct tty_operations acm_ops = {
1494         .open =                 acm_tty_open,
1495         .close =                acm_tty_close,
1496         .hangup =               acm_tty_hangup,
1497         .write =                acm_tty_write,
1498         .write_room =           acm_tty_write_room,
1499         .ioctl =                acm_tty_ioctl,
1500         .throttle =             acm_tty_throttle,
1501         .unthrottle =           acm_tty_unthrottle,
1502         .chars_in_buffer =      acm_tty_chars_in_buffer,
1503         .break_ctl =            acm_tty_break_ctl,
1504         .set_termios =          acm_tty_set_termios,
1505         .tiocmget =             acm_tty_tiocmget,
1506         .tiocmset =             acm_tty_tiocmset,
1507 };
1508
1509 /*
1510  * Init / exit.
1511  */
1512
1513 static int __init acm_init(void)
1514 {
1515         int retval;
1516         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1517         if (!acm_tty_driver)
1518                 return -ENOMEM;
1519         acm_tty_driver->owner = THIS_MODULE,
1520         acm_tty_driver->driver_name = "acm",
1521         acm_tty_driver->name = "ttyACM",
1522         acm_tty_driver->major = ACM_TTY_MAJOR,
1523         acm_tty_driver->minor_start = 0,
1524         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1525         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1526         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1527         acm_tty_driver->init_termios = tty_std_termios;
1528         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1529                                                                 HUPCL | CLOCAL;
1530         tty_set_operations(acm_tty_driver, &acm_ops);
1531
1532         retval = tty_register_driver(acm_tty_driver);
1533         if (retval) {
1534                 put_tty_driver(acm_tty_driver);
1535                 return retval;
1536         }
1537
1538         retval = usb_register(&acm_driver);
1539         if (retval) {
1540                 tty_unregister_driver(acm_tty_driver);
1541                 put_tty_driver(acm_tty_driver);
1542                 return retval;
1543         }
1544
1545         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1546                DRIVER_DESC "\n");
1547
1548         return 0;
1549 }
1550
1551 static void __exit acm_exit(void)
1552 {
1553         usb_deregister(&acm_driver);
1554         tty_unregister_driver(acm_tty_driver);
1555         put_tty_driver(acm_tty_driver);
1556 }
1557
1558 module_init(acm_init);
1559 module_exit(acm_exit);
1560
1561 MODULE_AUTHOR(DRIVER_AUTHOR);
1562 MODULE_DESCRIPTION(DRIVER_DESC);
1563 MODULE_LICENSE("GPL");
1564 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);