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