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