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