drivers/usb/class/cdc-acm.c

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