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@suse.cz>
   6  * Copyright (c) 1999 Johannes Erdfelt  <johannes@erdfelt.com>
   7  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
   8  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
   9  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
  10  *
  11  * USB Abstract Control Model driver for USB modems and ISDN adapters
  12  *
  13  * Sponsored by SuSE
  14  *
  15  * ChangeLog:
  16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  17  *      v0.10 - some more cleanups
  18  *      v0.11 - fixed flow control, read error doesn't stop reads
  19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
  20  *      v0.13 - added termios, added hangup
  21  *      v0.14 - sized down struct acm
  22  *      v0.15 - fixed flow control again - characters could be lost
  23  *      v0.16 - added code for modems with swapped data and control interfaces
  24  *      v0.17 - added new style probing
  25  *      v0.18 - fixed new style probing for devices with more configurations
  26  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  27  *      v0.20 - switched to probing on interface (rather than device) class
  28  *      v0.21 - revert to probing on device for devices with multiple configs
  29  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  30  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  31  *      v0.23 - use softirq for rx processing, as needed by tty layer
  32  *      v0.24 - change probe method to evaluate CDC union descriptor
  33  *      v0.25 - downstream tasks paralelized to maximize throughput
  34  */
  35
  36 /*
  37  * This program is free software; you can redistribute it and/or modify
  38  * it under the terms of the GNU General Public License as published by
  39  * the Free Software Foundation; either version 2 of the License, or
  40  * (at your option) any later version.
  41  *
  42  * This program is distributed in the hope that it will be useful,
  43  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  44  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  45  * GNU General Public License for more details.
  46  *
  47  * You should have received a copy of the GNU General Public License
  48  * along with this program; if not, write to the Free Software
  49  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  50  */
  51
  52 #undef DEBUG
  53
  54 #include <linux/kernel.h>
  55 #include <linux/errno.h>
  56 #include <linux/init.h>
  57 #include <linux/slab.h>
  58 #include <linux/tty.h>
  59 #include <linux/tty_driver.h>
  60 #include <linux/tty_flip.h>
  61 #include <linux/module.h>
  62 #include <linux/mutex.h>
  63 #include <asm/uaccess.h>
  64 #include <linux/usb.h>
  65 #include <linux/usb/cdc.h>
  66 #include <asm/byteorder.h>
  67 #include <asm/unaligned.h>
  68 #include <linux/list.h>
  69
  70 #include "cdc-acm.h"
  71
  72 /*
  73  * Version Information
  74  */
  75 #define DRIVER_VERSION "v0.25"
  76 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  77 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  78
  79 static struct usb_driver acm_driver;
  80 static struct tty_driver *acm_tty_driver;
  81 static struct acm *acm_table[ACM_TTY_MINORS];
  82
  83 static DEFINE_MUTEX(open_mutex);
  84
  85 #define ACM_READY(acm)  (acm && acm->dev && acm->used)
  86
  87 /*
  88  * Functions for ACM control messages.
  89  */
  90
  91 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
  92 {
  93         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  94                 request, USB_RT_ACM, value,
  95                 acm->control->altsetting[0].desc.bInterfaceNumber,
  96                 buf, len, 5000);
  97         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
  98         return retval < 0 ? retval : 0;
  99 }
 100
 101 /* devices aren't required to support these requests.
 102  * the cdc acm descriptor tells whether they do...
 103  */
 104 #define acm_set_control(acm, control) \
 105         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 106 #define acm_set_line(acm, line) \
 107         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 108 #define acm_send_break(acm, ms) \
 109         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 110
 111 /*
 112  * Write buffer management.
 113  * All of these assume proper locks taken by the caller.
 114  */
 115
 116 static int acm_wb_alloc(struct acm *acm)
 117 {
 118         int i, wbn;
 119         struct acm_wb *wb;
 120
 121         wbn = acm->write_current;
 122         i = 0;
 123         for (;;) {
 124                 wb = &acm->wb[wbn];
 125                 if (!wb->use) {
 126                         wb->use = 1;
 127                         return wbn;
 128                 }
 129                 wbn = (wbn + 1) % ACM_NW;
 130                 if (++i >= ACM_NW)
 131                         return -1;
 132         }
 133 }
 134
 135 static void acm_wb_free(struct acm *acm, int wbn)
 136 {
 137         acm->wb[wbn].use = 0;
 138 }
 139
 140 static int acm_wb_is_avail(struct acm *acm)
 141 {
 142         int i, n;
 143
 144         n = ACM_NW;
 145         for (i = 0; i < ACM_NW; i++) {
 146                 n -= acm->wb[i].use;
 147         }
 148         return n;
 149 }
 150
 151 static inline int acm_wb_is_used(struct acm *acm, int wbn)
 152 {
 153         return acm->wb[wbn].use;
 154 }
 155
 156 /*
 157  * Finish write.
 158  */
 159 static void acm_write_done(struct acm *acm)
 160 {
 161         unsigned long flags;
 162         int wbn;
 163
 164         spin_lock_irqsave(&acm->write_lock, flags);
 165         acm->write_ready = 1;
 166         wbn = acm->write_current;
 167         acm_wb_free(acm, wbn);
 168         acm->write_current = (wbn + 1) % ACM_NW;
 169         spin_unlock_irqrestore(&acm->write_lock, flags);
 170 }
 171
 172 /*
 173  * Poke write.
 174  */
 175 static int acm_write_start(struct acm *acm)
 176 {
 177         unsigned long flags;
 178         int wbn;
 179         struct acm_wb *wb;
 180         int rc;
 181
 182         spin_lock_irqsave(&acm->write_lock, flags);
 183         if (!acm->dev) {
 184                 spin_unlock_irqrestore(&acm->write_lock, flags);
 185                 return -ENODEV;
 186         }
 187
 188         if (!acm->write_ready) {
 189                 spin_unlock_irqrestore(&acm->write_lock, flags);
 190                 return 0;       /* A white lie */
 191         }
 192
 193         wbn = acm->write_current;
 194         if (!acm_wb_is_used(acm, wbn)) {
 195                 spin_unlock_irqrestore(&acm->write_lock, flags);
 196                 return 0;
 197         }
 198         wb = &acm->wb[wbn];
 199
 200         acm->write_ready = 0;
 201         spin_unlock_irqrestore(&acm->write_lock, flags);
 202
 203         acm->writeurb->transfer_buffer = wb->buf;
 204         acm->writeurb->transfer_dma = wb->dmah;
 205         acm->writeurb->transfer_buffer_length = wb->len;
 206         acm->writeurb->dev = acm->dev;
 207
 208         if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
 209                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
 210                 acm_write_done(acm);
 211         }
 212         return rc;
 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         unsigned char *data;
 259         int newctrl;
 260         int retval;
 261         int status = urb->status;
 262
 263         switch (status) {
 264         case 0:
 265                 /* success */
 266                 break;
 267         case -ECONNRESET:
 268         case -ENOENT:
 269         case -ESHUTDOWN:
 270                 /* this urb is terminated, clean up */
 271                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, status);
 272                 return;
 273         default:
 274                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, status);
 275                 goto exit;
 276         }
 277
 278         if (!ACM_READY(acm))
 279                 goto exit;
 280
 281         data = (unsigned char *)(dr + 1);
 282         switch (dr->bNotificationType) {
 283
 284                 case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 285
 286                         dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
 287                         break;
 288
 289                 case USB_CDC_NOTIFY_SERIAL_STATE:
 290
 291                         newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
 292
 293                         if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 294                                 dbg("calling hangup");
 295                                 tty_hangup(acm->tty);
 296                         }
 297
 298                         acm->ctrlin = newctrl;
 299
 300                         dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 301                                 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 302                                 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 303                                 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 304                                 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 305
 306                         break;
 307
 308                 default:
 309                         dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 310                                 dr->bNotificationType, dr->wIndex,
 311                                 dr->wLength, data[0], data[1]);
 312                         break;
 313         }
 314 exit:
 315         retval = usb_submit_urb (urb, GFP_ATOMIC);
 316         if (retval)
 317                 err ("%s - usb_submit_urb failed with result %d",
 318                      __FUNCTION__, retval);
 319 }
 320
 321 /* data interface returns incoming bytes, or we got unthrottled */
 322 static void acm_read_bulk(struct urb *urb)
 323 {
 324         struct acm_rb *buf;
 325         struct acm_ru *rcv = urb->context;
 326         struct acm *acm = rcv->instance;
 327         int status = urb->status;
 328
 329         dbg("Entering acm_read_bulk with status %d", status);
 330
 331         if (!ACM_READY(acm))
 332                 return;
 333
 334         if (status)
 335                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
 336
 337         buf = rcv->buffer;
 338         buf->size = urb->actual_length;
 339
 340         if (likely(status == 0)) {
 341                 spin_lock(&acm->read_lock);
 342                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 343                 list_add_tail(&buf->list, &acm->filled_read_bufs);
 344                 spin_unlock(&acm->read_lock);
 345         } else {
 346                 /* we drop the buffer due to an error */
 347                 spin_lock(&acm->read_lock);
 348                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 349                 list_add(&buf->list, &acm->spare_read_bufs);
 350                 spin_unlock(&acm->read_lock);
 351                 /* nevertheless the tasklet must be kicked unconditionally
 352                 so the queue cannot dry up */
 353         }
 354         tasklet_schedule(&acm->urb_task);
 355 }
 356
 357 static void acm_rx_tasklet(unsigned long _acm)
 358 {
 359         struct acm *acm = (void *)_acm;
 360         struct acm_rb *buf;
 361         struct tty_struct *tty = acm->tty;
 362         struct acm_ru *rcv;
 363         unsigned long flags;
 364         unsigned char throttled;
 365         dbg("Entering acm_rx_tasklet");
 366
 367         if (!ACM_READY(acm))
 368                 return;
 369
 370         spin_lock_irqsave(&acm->throttle_lock, flags);
 371         throttled = acm->throttle;
 372         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 373         if (throttled)
 374                 return;
 375
 376 next_buffer:
 377         spin_lock_irqsave(&acm->read_lock, flags);
 378         if (list_empty(&acm->filled_read_bufs)) {
 379                 spin_unlock_irqrestore(&acm->read_lock, flags);
 380                 goto urbs;
 381         }
 382         buf = list_entry(acm->filled_read_bufs.next,
 383                          struct acm_rb, list);
 384         list_del(&buf->list);
 385         spin_unlock_irqrestore(&acm->read_lock, flags);
 386
 387         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 388
 389         tty_buffer_request_room(tty, buf->size);
 390         spin_lock_irqsave(&acm->throttle_lock, flags);
 391         throttled = acm->throttle;
 392         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 393         if (!throttled)
 394                 tty_insert_flip_string(tty, buf->base, buf->size);
 395         tty_flip_buffer_push(tty);
 396
 397         if (throttled) {
 398                 dbg("Throttling noticed");
 399                 spin_lock_irqsave(&acm->read_lock, flags);
 400                 list_add(&buf->list, &acm->filled_read_bufs);
 401                 spin_unlock_irqrestore(&acm->read_lock, flags);
 402                 return;
 403         }
 404
 405         spin_lock_irqsave(&acm->read_lock, flags);
 406         list_add(&buf->list, &acm->spare_read_bufs);
 407         spin_unlock_irqrestore(&acm->read_lock, flags);
 408         goto next_buffer;
 409
 410 urbs:
 411         while (!list_empty(&acm->spare_read_bufs)) {
 412                 spin_lock_irqsave(&acm->read_lock, flags);
 413                 if (list_empty(&acm->spare_read_urbs)) {
 414                         spin_unlock_irqrestore(&acm->read_lock, flags);
 415                         return;
 416                 }
 417                 rcv = list_entry(acm->spare_read_urbs.next,
 418                                  struct acm_ru, list);
 419                 list_del(&rcv->list);
 420                 spin_unlock_irqrestore(&acm->read_lock, flags);
 421
 422                 buf = list_entry(acm->spare_read_bufs.next,
 423                                  struct acm_rb, list);
 424                 list_del(&buf->list);
 425
 426                 rcv->buffer = buf;
 427
 428                 usb_fill_bulk_urb(rcv->urb, acm->dev,
 429                                   acm->rx_endpoint,
 430                                   buf->base,
 431                                   acm->readsize,
 432                                   acm_read_bulk, rcv);
 433                 rcv->urb->transfer_dma = buf->dma;
 434                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 435
 436                 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 437
 438                 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
 439                    free-urbs-pool and resubmited ASAP */
 440                 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 441                         list_add(&buf->list, &acm->spare_read_bufs);
 442                         spin_lock_irqsave(&acm->read_lock, flags);
 443                         list_add(&rcv->list, &acm->spare_read_urbs);
 444                         spin_unlock_irqrestore(&acm->read_lock, flags);
 445                         return;
 446                 }
 447         }
 448 }
 449
 450 /* data interface wrote those outgoing bytes */
 451 static void acm_write_bulk(struct urb *urb)
 452 {
 453         struct acm *acm = (struct acm *)urb->context;
 454
 455         dbg("Entering acm_write_bulk with status %d", urb->status);
 456
 457         acm_write_done(acm);
 458         acm_write_start(acm);
 459         if (ACM_READY(acm))
 460                 schedule_work(&acm->work);
 461 }
 462
 463 static void acm_softint(struct work_struct *work)
 464 {
 465         struct acm *acm = container_of(work, struct acm, work);
 466         dbg("Entering acm_softint.");
 467
 468         if (!ACM_READY(acm))
 469                 return;
 470         tty_wakeup(acm->tty);
 471 }
 472
 473 /*
 474  * TTY handlers
 475  */
 476
 477 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 478 {
 479         struct acm *acm;
 480         int rv = -EINVAL;
 481         int i;
 482         dbg("Entering acm_tty_open.");
 483
 484         mutex_lock(&open_mutex);
 485
 486         acm = acm_table[tty->index];
 487         if (!acm || !acm->dev)
 488                 goto err_out;
 489         else
 490                 rv = 0;
 491
 492         tty->driver_data = acm;
 493         acm->tty = tty;
 494
 495         /* force low_latency on so that our tty_push actually forces the data through,
 496            otherwise it is scheduled, and with high data rates data can get lost. */
 497         tty->low_latency = 1;
 498
 499         if (usb_autopm_get_interface(acm->control)) {
 500                 mutex_unlock(&open_mutex);
 501                 return -EIO;
 502         }
 503
 504         mutex_lock(&acm->mutex);
 505         mutex_unlock(&open_mutex);
 506         if (acm->used++) {
 507                 usb_autopm_put_interface(acm->control);
 508                 goto done;
 509         }
 510
 511
 512         acm->ctrlurb->dev = acm->dev;
 513         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 514                 dbg("usb_submit_urb(ctrl irq) failed");
 515                 goto bail_out;
 516         }
 517
 518         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 519             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 520                 goto full_bailout;
 521
 522         INIT_LIST_HEAD(&acm->spare_read_urbs);
 523         INIT_LIST_HEAD(&acm->spare_read_bufs);
 524         INIT_LIST_HEAD(&acm->filled_read_bufs);
 525         for (i = 0; i < acm->rx_buflimit; i++) {
 526                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 527         }
 528         for (i = 0; i < acm->rx_buflimit; i++) {
 529                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 530         }
 531
 532         acm->throttle = 0;
 533
 534         tasklet_schedule(&acm->urb_task);
 535
 536 done:
 537 err_out:
 538         mutex_unlock(&acm->mutex);
 539         return rv;
 540
 541 full_bailout:
 542         usb_kill_urb(acm->ctrlurb);
 543 bail_out:
 544         usb_autopm_put_interface(acm->control);
 545         acm->used--;
 546         mutex_unlock(&acm->mutex);
 547         return -EIO;
 548 }
 549
 550 static void acm_tty_unregister(struct acm *acm)
 551 {
 552         int i,nr;
 553
 554         nr = acm->rx_buflimit;
 555         tty_unregister_device(acm_tty_driver, acm->minor);
 556         usb_put_intf(acm->control);
 557         acm_table[acm->minor] = NULL;
 558         usb_free_urb(acm->ctrlurb);
 559         usb_free_urb(acm->writeurb);
 560         for (i = 0; i < nr; i++)
 561                 usb_free_urb(acm->ru[i].urb);
 562         kfree(acm->country_codes);
 563         kfree(acm);
 564 }
 565
 566 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 567 {
 568         struct acm *acm = tty->driver_data;
 569         int i,nr;
 570
 571         if (!acm || !acm->used)
 572                 return;
 573
 574         nr = acm->rx_buflimit;
 575         mutex_lock(&open_mutex);
 576         if (!--acm->used) {
 577                 if (acm->dev) {
 578                         acm_set_control(acm, acm->ctrlout = 0);
 579                         usb_kill_urb(acm->ctrlurb);
 580                         usb_kill_urb(acm->writeurb);
 581                         for (i = 0; i < nr; i++)
 582                                 usb_kill_urb(acm->ru[i].urb);
 583                         usb_autopm_put_interface(acm->control);
 584                 } else
 585                         acm_tty_unregister(acm);
 586         }
 587         mutex_unlock(&open_mutex);
 588 }
 589
 590 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 591 {
 592         struct acm *acm = tty->driver_data;
 593         int stat;
 594         unsigned long flags;
 595         int wbn;
 596         struct acm_wb *wb;
 597
 598         dbg("Entering acm_tty_write to write %d bytes,", count);
 599
 600         if (!ACM_READY(acm))
 601                 return -EINVAL;
 602         if (!count)
 603                 return 0;
 604
 605         spin_lock_irqsave(&acm->write_lock, flags);
 606         if ((wbn = acm_wb_alloc(acm)) < 0) {
 607                 spin_unlock_irqrestore(&acm->write_lock, flags);
 608                 acm_write_start(acm);
 609                 return 0;
 610         }
 611         wb = &acm->wb[wbn];
 612
 613         count = (count > acm->writesize) ? acm->writesize : count;
 614         dbg("Get %d bytes...", count);
 615         memcpy(wb->buf, buf, count);
 616         wb->len = count;
 617         spin_unlock_irqrestore(&acm->write_lock, flags);
 618
 619         if ((stat = acm_write_start(acm)) < 0)
 620                 return stat;
 621         return count;
 622 }
 623
 624 static int acm_tty_write_room(struct tty_struct *tty)
 625 {
 626         struct acm *acm = tty->driver_data;
 627         if (!ACM_READY(acm))
 628                 return -EINVAL;
 629         /*
 630          * Do not let the line discipline to know that we have a reserve,
 631          * or it might get too enthusiastic.
 632          */
 633         return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
 634 }
 635
 636 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 637 {
 638         struct acm *acm = tty->driver_data;
 639         if (!ACM_READY(acm))
 640                 return -EINVAL;
 641         /*
 642          * This is inaccurate (overcounts), but it works.
 643          */
 644         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 645 }
 646
 647 static void acm_tty_throttle(struct tty_struct *tty)
 648 {
 649         struct acm *acm = tty->driver_data;
 650         if (!ACM_READY(acm))
 651                 return;
 652         spin_lock_bh(&acm->throttle_lock);
 653         acm->throttle = 1;
 654         spin_unlock_bh(&acm->throttle_lock);
 655 }
 656
 657 static void acm_tty_unthrottle(struct tty_struct *tty)
 658 {
 659         struct acm *acm = tty->driver_data;
 660         if (!ACM_READY(acm))
 661                 return;
 662         spin_lock_bh(&acm->throttle_lock);
 663         acm->throttle = 0;
 664         spin_unlock_bh(&acm->throttle_lock);
 665         tasklet_schedule(&acm->urb_task);
 666 }
 667
 668 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 669 {
 670         struct acm *acm = tty->driver_data;
 671         if (!ACM_READY(acm))
 672                 return;
 673         if (acm_send_break(acm, state ? 0xffff : 0))
 674                 dbg("send break failed");
 675 }
 676
 677 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 678 {
 679         struct acm *acm = tty->driver_data;
 680
 681         if (!ACM_READY(acm))
 682                 return -EINVAL;
 683
 684         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 685                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 686                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 687                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 688                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 689                TIOCM_CTS;
 690 }
 691
 692 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 693                             unsigned int set, unsigned int clear)
 694 {
 695         struct acm *acm = tty->driver_data;
 696         unsigned int newctrl;
 697
 698         if (!ACM_READY(acm))
 699                 return -EINVAL;
 700
 701         newctrl = acm->ctrlout;
 702         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 703         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 704
 705         newctrl = (newctrl & ~clear) | set;
 706
 707         if (acm->ctrlout == newctrl)
 708                 return 0;
 709         return acm_set_control(acm, acm->ctrlout = newctrl);
 710 }
 711
 712 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 713 {
 714         struct acm *acm = tty->driver_data;
 715
 716         if (!ACM_READY(acm))
 717                 return -EINVAL;
 718
 719         return -ENOIOCTLCMD;
 720 }
 721
 722 static const __u32 acm_tty_speed[] = {
 723         0, 50, 75, 110, 134, 150, 200, 300, 600,
 724         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 725         57600, 115200, 230400, 460800, 500000, 576000,
 726         921600, 1000000, 1152000, 1500000, 2000000,
 727         2500000, 3000000, 3500000, 4000000
 728 };
 729
 730 static const __u8 acm_tty_size[] = {
 731         5, 6, 7, 8
 732 };
 733
 734 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
 735 {
 736         struct acm *acm = tty->driver_data;
 737         struct ktermios *termios = tty->termios;
 738         struct usb_cdc_line_coding newline;
 739         int newctrl = acm->ctrlout;
 740
 741         if (!ACM_READY(acm))
 742                 return;
 743
 744         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 745                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 746         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 747         newline.bParityType = termios->c_cflag & PARENB ?
 748                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 749         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 750
 751         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 752
 753         if (!newline.dwDTERate) {
 754                 newline.dwDTERate = acm->line.dwDTERate;
 755                 newctrl &= ~ACM_CTRL_DTR;
 756         } else  newctrl |=  ACM_CTRL_DTR;
 757
 758         if (newctrl != acm->ctrlout)
 759                 acm_set_control(acm, acm->ctrlout = newctrl);
 760
 761         if (memcmp(&acm->line, &newline, sizeof newline)) {
 762                 memcpy(&acm->line, &newline, sizeof newline);
 763                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 764                         newline.bCharFormat, newline.bParityType,
 765                         newline.bDataBits);
 766                 acm_set_line(acm, &acm->line);
 767         }
 768 }
 769
 770 /*
 771  * USB probe and disconnect routines.
 772  */
 773
 774 /* Little helper: write buffers free */
 775 static void acm_write_buffers_free(struct acm *acm)
 776 {
 777         int i;
 778         struct acm_wb *wb;
 779
 780         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 781                 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 782         }
 783 }
 784
 785 /* Little helper: write buffers allocate */
 786 static int acm_write_buffers_alloc(struct acm *acm)
 787 {
 788         int i;
 789         struct acm_wb *wb;
 790
 791         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 792                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 793                     &wb->dmah);
 794                 if (!wb->buf) {
 795                         while (i != 0) {
 796                                 --i;
 797                                 --wb;
 798                                 usb_buffer_free(acm->dev, acm->writesize,
 799                                     wb->buf, wb->dmah);
 800                         }
 801                         return -ENOMEM;
 802                 }
 803         }
 804         return 0;
 805 }
 806
 807 static int acm_probe (struct usb_interface *intf,
 808                       const struct usb_device_id *id)
 809 {
 810         struct usb_cdc_union_desc *union_header = NULL;
 811         struct usb_cdc_country_functional_desc *cfd = NULL;
 812         char *buffer = intf->altsetting->extra;
 813         int buflen = intf->altsetting->extralen;
 814         struct usb_interface *control_interface;
 815         struct usb_interface *data_interface;
 816         struct usb_endpoint_descriptor *epctrl;
 817         struct usb_endpoint_descriptor *epread;
 818         struct usb_endpoint_descriptor *epwrite;
 819         struct usb_device *usb_dev = interface_to_usbdev(intf);
 820         struct acm *acm;
 821         int minor;
 822         int ctrlsize,readsize;
 823         u8 *buf;
 824         u8 ac_management_function = 0;
 825         u8 call_management_function = 0;
 826         int call_interface_num = -1;
 827         int data_interface_num;
 828         unsigned long quirks;
 829         int num_rx_buf;
 830         int i;
 831
 832         /* normal quirks */
 833         quirks = (unsigned long)id->driver_info;
 834         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 835
 836         /* handle quirks deadly to normal probing*/
 837         if (quirks == NO_UNION_NORMAL) {
 838                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 839                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 840                 goto skip_normal_probe;
 841         }
 842
 843         /* normal probing*/
 844         if (!buffer) {
 845                 err("Weird descriptor references\n");
 846                 return -EINVAL;
 847         }
 848
 849         if (!buflen) {
 850                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 851                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
 852                         buflen = intf->cur_altsetting->endpoint->extralen;
 853                         buffer = intf->cur_altsetting->endpoint->extra;
 854                 } else {
 855                         err("Zero length descriptor references\n");
 856                         return -EINVAL;
 857                 }
 858         }
 859
 860         while (buflen > 0) {
 861                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 862                         err("skipping garbage\n");
 863                         goto next_desc;
 864                 }
 865
 866                 switch (buffer [2]) {
 867                         case USB_CDC_UNION_TYPE: /* we've found it */
 868                                 if (union_header) {
 869                                         err("More than one union descriptor, skipping ...");
 870                                         goto next_desc;
 871                                 }
 872                                 union_header = (struct usb_cdc_union_desc *)
 873                                                         buffer;
 874                                 break;
 875                         case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 876                                 cfd = (struct usb_cdc_country_functional_desc *)buffer;
 877                                 break;
 878                         case USB_CDC_HEADER_TYPE: /* maybe check version */
 879                                 break; /* for now we ignore it */
 880                         case USB_CDC_ACM_TYPE:
 881                                 ac_management_function = buffer[3];
 882                                 break;
 883                         case USB_CDC_CALL_MANAGEMENT_TYPE:
 884                                 call_management_function = buffer[3];
 885                                 call_interface_num = buffer[4];
 886                                 if ((call_management_function & 3) != 3)
 887                                         err("This device cannot do calls on its own. It is no modem.");
 888                                 break;
 889
 890                         default:
 891                                 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
 892                                 break;
 893                         }
 894 next_desc:
 895                 buflen -= buffer[0];
 896                 buffer += buffer[0];
 897         }
 898
 899         if (!union_header) {
 900                 if (call_interface_num > 0) {
 901                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
 902                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 903                         control_interface = intf;
 904                 } else {
 905                         dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 906                         return -ENODEV;
 907                 }
 908         } else {
 909                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 910                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 911                 if (!control_interface || !data_interface) {
 912                         dev_dbg(&intf->dev,"no interfaces\n");
 913                         return -ENODEV;
 914                 }
 915         }
 916
 917         if (data_interface_num != call_interface_num)
 918                 dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
 919
 920 skip_normal_probe:
 921
 922         /*workaround for switched interfaces */
 923         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 924                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 925                         struct usb_interface *t;
 926                         dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
 927
 928                         t = control_interface;
 929                         control_interface = data_interface;
 930                         data_interface = t;
 931                 } else {
 932                         return -EINVAL;
 933                 }
 934         }
 935
 936         /* Accept probe requests only for the control interface */
 937         if (intf != control_interface)
 938                 return -ENODEV;
 939
 940         if (usb_interface_claimed(data_interface)) { /* valid in this context */
 941                 dev_dbg(&intf->dev,"The data interface isn't available\n");
 942                 return -EBUSY;
 943         }
 944
 945
 946         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 947                 return -EINVAL;
 948
 949         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 950         epread = &data_interface->cur_altsetting->endpoint[0].desc;
 951         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 952
 953
 954         /* workaround for switched endpoints */
 955         if (!usb_endpoint_dir_in(epread)) {
 956                 /* descriptors are swapped */
 957                 struct usb_endpoint_descriptor *t;
 958                 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
 959
 960                 t = epread;
 961                 epread = epwrite;
 962                 epwrite = t;
 963         }
 964         dbg("interfaces are valid");
 965         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 966
 967         if (minor == ACM_TTY_MINORS) {
 968                 err("no more free acm devices");
 969                 return -ENODEV;
 970         }
 971
 972         if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
 973                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
 974                 goto alloc_fail;
 975         }
 976
 977         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 978         readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
 979         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
 980         acm->control = control_interface;
 981         acm->data = data_interface;
 982         acm->minor = minor;
 983         acm->dev = usb_dev;
 984         acm->ctrl_caps = ac_management_function;
 985         acm->ctrlsize = ctrlsize;
 986         acm->readsize = readsize;
 987         acm->rx_buflimit = num_rx_buf;
 988         acm->urb_task.func = acm_rx_tasklet;
 989         acm->urb_task.data = (unsigned long) acm;
 990         INIT_WORK(&acm->work, acm_softint);
 991         spin_lock_init(&acm->throttle_lock);
 992         spin_lock_init(&acm->write_lock);
 993         spin_lock_init(&acm->read_lock);
 994         mutex_init(&acm->mutex);
 995         acm->write_ready = 1;
 996         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 997
 998         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 999         if (!buf) {
1000                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1001                 goto alloc_fail2;
1002         }
1003         acm->ctrl_buffer = buf;
1004
1005         if (acm_write_buffers_alloc(acm) < 0) {
1006                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1007                 goto alloc_fail4;
1008         }
1009
1010         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1011         if (!acm->ctrlurb) {
1012                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1013                 goto alloc_fail5;
1014         }
1015         for (i = 0; i < num_rx_buf; i++) {
1016                 struct acm_ru *rcv = &(acm->ru[i]);
1017
1018                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1019                         dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1020                         goto alloc_fail7;
1021                 }
1022
1023                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1024                 rcv->instance = acm;
1025         }
1026         for (i = 0; i < num_rx_buf; i++) {
1027                 struct acm_rb *buf = &(acm->rb[i]);
1028
1029                 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
1030                         dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1031                         goto alloc_fail7;
1032                 }
1033         }
1034         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
1035         if (!acm->writeurb) {
1036                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
1037                 goto alloc_fail7;
1038         }
1039
1040         usb_set_intfdata (intf, acm);
1041
1042         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1043         if (i < 0)
1044                 goto alloc_fail8;
1045
1046         if (cfd) { /* export the country data */
1047                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1048                 if (!acm->country_codes)
1049                         goto skip_countries;
1050                 acm->country_code_size = cfd->bLength - 4;
1051                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1052                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1053
1054                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1055                 if (i < 0) {
1056                         kfree(acm->country_codes);
1057                         goto skip_countries;
1058                 }
1059
1060                 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1061                 if (i < 0) {
1062                         kfree(acm->country_codes);
1063                         goto skip_countries;
1064                 }
1065         }
1066
1067 skip_countries:
1068         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1069                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1070         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1071         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1072
1073         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1074                           NULL, acm->writesize, acm_write_bulk, acm);
1075         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
1076
1077         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1078
1079         acm_set_control(acm, acm->ctrlout);
1080
1081         acm->line.dwDTERate = cpu_to_le32(9600);
1082         acm->line.bDataBits = 8;
1083         acm_set_line(acm, &acm->line);
1084
1085         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1086
1087         usb_get_intf(control_interface);
1088         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1089
1090         acm_table[minor] = acm;
1091
1092         return 0;
1093 alloc_fail8:
1094         usb_free_urb(acm->writeurb);
1095 alloc_fail7:
1096         for (i = 0; i < num_rx_buf; i++)
1097                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1098         for (i = 0; i < num_rx_buf; i++)
1099                 usb_free_urb(acm->ru[i].urb);
1100         usb_free_urb(acm->ctrlurb);
1101 alloc_fail5:
1102         acm_write_buffers_free(acm);
1103 alloc_fail4:
1104         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1105 alloc_fail2:
1106         kfree(acm);
1107 alloc_fail:
1108         return -ENOMEM;
1109 }
1110
1111 static void stop_data_traffic(struct acm *acm)
1112 {
1113         int i;
1114
1115         tasklet_disable(&acm->urb_task);
1116
1117         usb_kill_urb(acm->ctrlurb);
1118         usb_kill_urb(acm->writeurb);
1119         for (i = 0; i < acm->rx_buflimit; i++)
1120                 usb_kill_urb(acm->ru[i].urb);
1121
1122         INIT_LIST_HEAD(&acm->filled_read_bufs);
1123         INIT_LIST_HEAD(&acm->spare_read_bufs);
1124
1125         tasklet_enable(&acm->urb_task);
1126
1127         cancel_work_sync(&acm->work);
1128 }
1129
1130 static void acm_disconnect(struct usb_interface *intf)
1131 {
1132         struct acm *acm = usb_get_intfdata(intf);
1133         struct usb_device *usb_dev = interface_to_usbdev(intf);
1134         int i;
1135
1136         if (!acm || !acm->dev) {
1137                 dbg("disconnect on nonexisting interface");
1138                 return;
1139         }
1140
1141         mutex_lock(&open_mutex);
1142         if (!usb_get_intfdata(intf)) {
1143                 mutex_unlock(&open_mutex);
1144                 return;
1145         }
1146         if (acm->country_codes){
1147                 device_remove_file(&acm->control->dev,
1148                                 &dev_attr_wCountryCodes);
1149                 device_remove_file(&acm->control->dev,
1150                                 &dev_attr_iCountryCodeRelDate);
1151         }
1152         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1153         acm->dev = NULL;
1154         usb_set_intfdata(acm->control, NULL);
1155         usb_set_intfdata(acm->data, NULL);
1156
1157         stop_data_traffic(acm);
1158
1159         acm_write_buffers_free(acm);
1160         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1161         for (i = 0; i < acm->rx_buflimit; i++)
1162                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1163
1164         usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1165
1166         if (!acm->used) {
1167                 acm_tty_unregister(acm);
1168                 mutex_unlock(&open_mutex);
1169                 return;
1170         }
1171
1172         mutex_unlock(&open_mutex);
1173
1174         if (acm->tty)
1175                 tty_hangup(acm->tty);
1176 }
1177
1178 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1179 {
1180         struct acm *acm = usb_get_intfdata(intf);
1181
1182         if (acm->susp_count++)
1183                 return 0;
1184         /*
1185         we treat opened interfaces differently,
1186         we must guard against open
1187         */
1188         mutex_lock(&acm->mutex);
1189
1190         if (acm->used)
1191                 stop_data_traffic(acm);
1192
1193         mutex_unlock(&acm->mutex);
1194         return 0;
1195 }
1196
1197 static int acm_resume(struct usb_interface *intf)
1198 {
1199         struct acm *acm = usb_get_intfdata(intf);
1200         int rv = 0;
1201
1202         if (--acm->susp_count)
1203                 return 0;
1204
1205         mutex_lock(&acm->mutex);
1206         if (acm->used) {
1207                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1208                 if (rv < 0)
1209                 goto err_out;
1210
1211                 tasklet_schedule(&acm->urb_task);
1212         }
1213
1214 err_out:
1215         mutex_unlock(&acm->mutex);
1216         return rv;
1217 }
1218 /*
1219  * USB driver structure.
1220  */
1221
1222 static struct usb_device_id acm_ids[] = {
1223         /* quirky and broken devices */
1224         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1225         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1226         },
1227         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1228         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1229         },
1230         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1231         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1232         },
1233         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1234         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1235         },
1236         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1237         .driver_info = SINGLE_RX_URB, /* firmware bug */
1238         },
1239         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1240         .driver_info = SINGLE_RX_URB, /* firmware bug */
1241         },
1242         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1243         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1244         },
1245
1246         /* control interfaces with various AT-command sets */
1247         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1248                 USB_CDC_ACM_PROTO_AT_V25TER) },
1249         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1250                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1251         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1252                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1253         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1254                 USB_CDC_ACM_PROTO_AT_GSM) },
1255         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1256                 USB_CDC_ACM_PROTO_AT_3G ) },
1257         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1258                 USB_CDC_ACM_PROTO_AT_CDMA) },
1259
1260         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1261         { }
1262 };
1263
1264 MODULE_DEVICE_TABLE (usb, acm_ids);
1265
1266 static struct usb_driver acm_driver = {
1267         .name =         "cdc_acm",
1268         .probe =        acm_probe,
1269         .disconnect =   acm_disconnect,
1270         .suspend =      acm_suspend,
1271         .resume =       acm_resume,
1272         .id_table =     acm_ids,
1273         .supports_autosuspend = 1,
1274 };
1275
1276 /*
1277  * TTY driver structures.
1278  */
1279
1280 static const struct tty_operations acm_ops = {
1281         .open =                 acm_tty_open,
1282         .close =                acm_tty_close,
1283         .write =                acm_tty_write,
1284         .write_room =           acm_tty_write_room,
1285         .ioctl =                acm_tty_ioctl,
1286         .throttle =             acm_tty_throttle,
1287         .unthrottle =           acm_tty_unthrottle,
1288         .chars_in_buffer =      acm_tty_chars_in_buffer,
1289         .break_ctl =            acm_tty_break_ctl,
1290         .set_termios =          acm_tty_set_termios,
1291         .tiocmget =             acm_tty_tiocmget,
1292         .tiocmset =             acm_tty_tiocmset,
1293 };
1294
1295 /*
1296  * Init / exit.
1297  */
1298
1299 static int __init acm_init(void)
1300 {
1301         int retval;
1302         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1303         if (!acm_tty_driver)
1304                 return -ENOMEM;
1305         acm_tty_driver->owner = THIS_MODULE,
1306         acm_tty_driver->driver_name = "acm",
1307         acm_tty_driver->name = "ttyACM",
1308         acm_tty_driver->major = ACM_TTY_MAJOR,
1309         acm_tty_driver->minor_start = 0,
1310         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1311         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1312         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1313         acm_tty_driver->init_termios = tty_std_termios;
1314         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1315         tty_set_operations(acm_tty_driver, &acm_ops);
1316
1317         retval = tty_register_driver(acm_tty_driver);
1318         if (retval) {
1319                 put_tty_driver(acm_tty_driver);
1320                 return retval;
1321         }
1322
1323         retval = usb_register(&acm_driver);
1324         if (retval) {
1325                 tty_unregister_driver(acm_tty_driver);
1326                 put_tty_driver(acm_tty_driver);
1327                 return retval;
1328         }
1329
1330         info(DRIVER_VERSION ":" DRIVER_DESC);
1331
1332         return 0;
1333 }
1334
1335 static void __exit acm_exit(void)
1336 {
1337         usb_deregister(&acm_driver);
1338         tty_unregister_driver(acm_tty_driver);
1339         put_tty_driver(acm_tty_driver);
1340 }
1341
1342 module_init(acm_init);
1343 module_exit(acm_exit);
1344
1345 MODULE_AUTHOR( DRIVER_AUTHOR );
1346 MODULE_DESCRIPTION( DRIVER_DESC );
1347 MODULE_LICENSE("GPL");
1348