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