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