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