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 (acm->used++) {
 500                 goto done;
 501         }
 502
 503         acm->ctrlurb->dev = acm->dev;
 504         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 505                 dbg("usb_submit_urb(ctrl irq) failed");
 506                 goto bail_out;
 507         }
 508
 509         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 510             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 511                 goto full_bailout;
 512
 513         INIT_LIST_HEAD(&acm->spare_read_urbs);
 514         INIT_LIST_HEAD(&acm->spare_read_bufs);
 515         INIT_LIST_HEAD(&acm->filled_read_bufs);
 516         for (i = 0; i < acm->rx_buflimit; i++) {
 517                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 518         }
 519         for (i = 0; i < acm->rx_buflimit; i++) {
 520                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 521         }
 522
 523         acm->throttle = 0;
 524
 525         tasklet_schedule(&acm->urb_task);
 526
 527 done:
 528 err_out:
 529         mutex_unlock(&open_mutex);
 530         return rv;
 531
 532 full_bailout:
 533         usb_kill_urb(acm->ctrlurb);
 534 bail_out:
 535         acm->used--;
 536         mutex_unlock(&open_mutex);
 537         return -EIO;
 538 }
 539
 540 static void acm_tty_unregister(struct acm *acm)
 541 {
 542         int i,nr;
 543
 544         nr = acm->rx_buflimit;
 545         tty_unregister_device(acm_tty_driver, acm->minor);
 546         usb_put_intf(acm->control);
 547         acm_table[acm->minor] = NULL;
 548         usb_free_urb(acm->ctrlurb);
 549         usb_free_urb(acm->writeurb);
 550         for (i = 0; i < nr; i++)
 551                 usb_free_urb(acm->ru[i].urb);
 552         kfree(acm->country_codes);
 553         kfree(acm);
 554 }
 555
 556 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 557 {
 558         struct acm *acm = tty->driver_data;
 559         int i,nr;
 560
 561         if (!acm || !acm->used)
 562                 return;
 563
 564         nr = acm->rx_buflimit;
 565         mutex_lock(&open_mutex);
 566         if (!--acm->used) {
 567                 if (acm->dev) {
 568                         acm_set_control(acm, acm->ctrlout = 0);
 569                         usb_kill_urb(acm->ctrlurb);
 570                         usb_kill_urb(acm->writeurb);
 571                         for (i = 0; i < nr; i++)
 572                                 usb_kill_urb(acm->ru[i].urb);
 573                 } else
 574                         acm_tty_unregister(acm);
 575         }
 576         mutex_unlock(&open_mutex);
 577 }
 578
 579 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 580 {
 581         struct acm *acm = tty->driver_data;
 582         int stat;
 583         unsigned long flags;
 584         int wbn;
 585         struct acm_wb *wb;
 586
 587         dbg("Entering acm_tty_write to write %d bytes,", count);
 588
 589         if (!ACM_READY(acm))
 590                 return -EINVAL;
 591         if (!count)
 592                 return 0;
 593
 594         spin_lock_irqsave(&acm->write_lock, flags);
 595         if ((wbn = acm_wb_alloc(acm)) < 0) {
 596                 spin_unlock_irqrestore(&acm->write_lock, flags);
 597                 acm_write_start(acm);
 598                 return 0;
 599         }
 600         wb = &acm->wb[wbn];
 601
 602         count = (count > acm->writesize) ? acm->writesize : count;
 603         dbg("Get %d bytes...", count);
 604         memcpy(wb->buf, buf, count);
 605         wb->len = count;
 606         spin_unlock_irqrestore(&acm->write_lock, flags);
 607
 608         if ((stat = acm_write_start(acm)) < 0)
 609                 return stat;
 610         return count;
 611 }
 612
 613 static int acm_tty_write_room(struct tty_struct *tty)
 614 {
 615         struct acm *acm = tty->driver_data;
 616         if (!ACM_READY(acm))
 617                 return -EINVAL;
 618         /*
 619          * Do not let the line discipline to know that we have a reserve,
 620          * or it might get too enthusiastic.
 621          */
 622         return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
 623 }
 624
 625 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 626 {
 627         struct acm *acm = tty->driver_data;
 628         if (!ACM_READY(acm))
 629                 return -EINVAL;
 630         /*
 631          * This is inaccurate (overcounts), but it works.
 632          */
 633         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 634 }
 635
 636 static void acm_tty_throttle(struct tty_struct *tty)
 637 {
 638         struct acm *acm = tty->driver_data;
 639         if (!ACM_READY(acm))
 640                 return;
 641         spin_lock_bh(&acm->throttle_lock);
 642         acm->throttle = 1;
 643         spin_unlock_bh(&acm->throttle_lock);
 644 }
 645
 646 static void acm_tty_unthrottle(struct tty_struct *tty)
 647 {
 648         struct acm *acm = tty->driver_data;
 649         if (!ACM_READY(acm))
 650                 return;
 651         spin_lock_bh(&acm->throttle_lock);
 652         acm->throttle = 0;
 653         spin_unlock_bh(&acm->throttle_lock);
 654         tasklet_schedule(&acm->urb_task);
 655 }
 656
 657 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 658 {
 659         struct acm *acm = tty->driver_data;
 660         if (!ACM_READY(acm))
 661                 return;
 662         if (acm_send_break(acm, state ? 0xffff : 0))
 663                 dbg("send break failed");
 664 }
 665
 666 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 667 {
 668         struct acm *acm = tty->driver_data;
 669
 670         if (!ACM_READY(acm))
 671                 return -EINVAL;
 672
 673         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 674                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 675                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 676                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 677                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 678                TIOCM_CTS;
 679 }
 680
 681 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 682                             unsigned int set, unsigned int clear)
 683 {
 684         struct acm *acm = tty->driver_data;
 685         unsigned int newctrl;
 686
 687         if (!ACM_READY(acm))
 688                 return -EINVAL;
 689
 690         newctrl = acm->ctrlout;
 691         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 692         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 693
 694         newctrl = (newctrl & ~clear) | set;
 695
 696         if (acm->ctrlout == newctrl)
 697                 return 0;
 698         return acm_set_control(acm, acm->ctrlout = newctrl);
 699 }
 700
 701 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 702 {
 703         struct acm *acm = tty->driver_data;
 704
 705         if (!ACM_READY(acm))
 706                 return -EINVAL;
 707
 708         return -ENOIOCTLCMD;
 709 }
 710
 711 static const __u32 acm_tty_speed[] = {
 712         0, 50, 75, 110, 134, 150, 200, 300, 600,
 713         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 714         57600, 115200, 230400, 460800, 500000, 576000,
 715         921600, 1000000, 1152000, 1500000, 2000000,
 716         2500000, 3000000, 3500000, 4000000
 717 };
 718
 719 static const __u8 acm_tty_size[] = {
 720         5, 6, 7, 8
 721 };
 722
 723 static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
 724 {
 725         struct acm *acm = tty->driver_data;
 726         struct ktermios *termios = tty->termios;
 727         struct usb_cdc_line_coding newline;
 728         int newctrl = acm->ctrlout;
 729
 730         if (!ACM_READY(acm))
 731                 return;
 732
 733         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 734                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 735         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 736         newline.bParityType = termios->c_cflag & PARENB ?
 737                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 738         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 739
 740         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 741
 742         if (!newline.dwDTERate) {
 743                 newline.dwDTERate = acm->line.dwDTERate;
 744                 newctrl &= ~ACM_CTRL_DTR;
 745         } else  newctrl |=  ACM_CTRL_DTR;
 746
 747         if (newctrl != acm->ctrlout)
 748                 acm_set_control(acm, acm->ctrlout = newctrl);
 749
 750         if (memcmp(&acm->line, &newline, sizeof newline)) {
 751                 memcpy(&acm->line, &newline, sizeof newline);
 752                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 753                         newline.bCharFormat, newline.bParityType,
 754                         newline.bDataBits);
 755                 acm_set_line(acm, &acm->line);
 756         }
 757 }
 758
 759 /*
 760  * USB probe and disconnect routines.
 761  */
 762
 763 /* Little helper: write buffers free */
 764 static void acm_write_buffers_free(struct acm *acm)
 765 {
 766         int i;
 767         struct acm_wb *wb;
 768
 769         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 770                 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 771         }
 772 }
 773
 774 /* Little helper: write buffers allocate */
 775 static int acm_write_buffers_alloc(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                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 782                     &wb->dmah);
 783                 if (!wb->buf) {
 784                         while (i != 0) {
 785                                 --i;
 786                                 --wb;
 787                                 usb_buffer_free(acm->dev, acm->writesize,
 788                                     wb->buf, wb->dmah);
 789                         }
 790                         return -ENOMEM;
 791                 }
 792         }
 793         return 0;
 794 }
 795
 796 static int acm_probe (struct usb_interface *intf,
 797                       const struct usb_device_id *id)
 798 {
 799         struct usb_cdc_union_desc *union_header = NULL;
 800         struct usb_cdc_country_functional_desc *cfd = NULL;
 801         char *buffer = intf->altsetting->extra;
 802         int buflen = intf->altsetting->extralen;
 803         struct usb_interface *control_interface;
 804         struct usb_interface *data_interface;
 805         struct usb_endpoint_descriptor *epctrl;
 806         struct usb_endpoint_descriptor *epread;
 807         struct usb_endpoint_descriptor *epwrite;
 808         struct usb_device *usb_dev = interface_to_usbdev(intf);
 809         struct acm *acm;
 810         int minor;
 811         int ctrlsize,readsize;
 812         u8 *buf;
 813         u8 ac_management_function = 0;
 814         u8 call_management_function = 0;
 815         int call_interface_num = -1;
 816         int data_interface_num;
 817         unsigned long quirks;
 818         int num_rx_buf;
 819         int i;
 820
 821         /* normal quirks */
 822         quirks = (unsigned long)id->driver_info;
 823         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 824
 825         /* handle quirks deadly to normal probing*/
 826         if (quirks == NO_UNION_NORMAL) {
 827                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 828                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 829                 goto skip_normal_probe;
 830         }
 831
 832         /* normal probing*/
 833         if (!buffer) {
 834                 err("Weird descriptor references\n");
 835                 return -EINVAL;
 836         }
 837
 838         if (!buflen) {
 839                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 840                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
 841                         buflen = intf->cur_altsetting->endpoint->extralen;
 842                         buffer = intf->cur_altsetting->endpoint->extra;
 843                 } else {
 844                         err("Zero length descriptor references\n");
 845                         return -EINVAL;
 846                 }
 847         }
 848
 849         while (buflen > 0) {
 850                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 851                         err("skipping garbage\n");
 852                         goto next_desc;
 853                 }
 854
 855                 switch (buffer [2]) {
 856                         case USB_CDC_UNION_TYPE: /* we've found it */
 857                                 if (union_header) {
 858                                         err("More than one union descriptor, skipping ...");
 859                                         goto next_desc;
 860                                 }
 861                                 union_header = (struct usb_cdc_union_desc *)
 862                                                         buffer;
 863                                 break;
 864                         case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 865                                 cfd = (struct usb_cdc_country_functional_desc *)buffer;
 866                                 break;
 867                         case USB_CDC_HEADER_TYPE: /* maybe check version */
 868                                 break; /* for now we ignore it */
 869                         case USB_CDC_ACM_TYPE:
 870                                 ac_management_function = buffer[3];
 871                                 break;
 872                         case USB_CDC_CALL_MANAGEMENT_TYPE:
 873                                 call_management_function = buffer[3];
 874                                 call_interface_num = buffer[4];
 875                                 if ((call_management_function & 3) != 3)
 876                                         err("This device cannot do calls on its own. It is no modem.");
 877                                 break;
 878
 879                         default:
 880                                 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
 881                                 break;
 882                         }
 883 next_desc:
 884                 buflen -= buffer[0];
 885                 buffer += buffer[0];
 886         }
 887
 888         if (!union_header) {
 889                 if (call_interface_num > 0) {
 890                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
 891                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 892                         control_interface = intf;
 893                 } else {
 894                         dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 895                         return -ENODEV;
 896                 }
 897         } else {
 898                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 899                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 900                 if (!control_interface || !data_interface) {
 901                         dev_dbg(&intf->dev,"no interfaces\n");
 902                         return -ENODEV;
 903                 }
 904         }
 905
 906         if (data_interface_num != call_interface_num)
 907                 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.\n");
 908
 909 skip_normal_probe:
 910
 911         /*workaround for switched interfaces */
 912         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 913                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 914                         struct usb_interface *t;
 915                         dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
 916
 917                         t = control_interface;
 918                         control_interface = data_interface;
 919                         data_interface = t;
 920                 } else {
 921                         return -EINVAL;
 922                 }
 923         }
 924
 925         /* Accept probe requests only for the control interface */
 926         if (intf != control_interface)
 927                 return -ENODEV;
 928
 929         if (usb_interface_claimed(data_interface)) { /* valid in this context */
 930                 dev_dbg(&intf->dev,"The data interface isn't available\n");
 931                 return -EBUSY;
 932         }
 933
 934
 935         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 936                 return -EINVAL;
 937
 938         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 939         epread = &data_interface->cur_altsetting->endpoint[0].desc;
 940         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 941
 942
 943         /* workaround for switched endpoints */
 944         if (!usb_endpoint_dir_in(epread)) {
 945                 /* descriptors are swapped */
 946                 struct usb_endpoint_descriptor *t;
 947                 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
 948
 949                 t = epread;
 950                 epread = epwrite;
 951                 epwrite = t;
 952         }
 953         dbg("interfaces are valid");
 954         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 955
 956         if (minor == ACM_TTY_MINORS) {
 957                 err("no more free acm devices");
 958                 return -ENODEV;
 959         }
 960
 961         if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
 962                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
 963                 goto alloc_fail;
 964         }
 965
 966         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 967         readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
 968         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
 969         acm->control = control_interface;
 970         acm->data = data_interface;
 971         acm->minor = minor;
 972         acm->dev = usb_dev;
 973         acm->ctrl_caps = ac_management_function;
 974         acm->ctrlsize = ctrlsize;
 975         acm->readsize = readsize;
 976         acm->rx_buflimit = num_rx_buf;
 977         acm->urb_task.func = acm_rx_tasklet;
 978         acm->urb_task.data = (unsigned long) acm;
 979         INIT_WORK(&acm->work, acm_softint);
 980         spin_lock_init(&acm->throttle_lock);
 981         spin_lock_init(&acm->write_lock);
 982         spin_lock_init(&acm->read_lock);
 983         acm->write_ready = 1;
 984         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 985
 986         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 987         if (!buf) {
 988                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
 989                 goto alloc_fail2;
 990         }
 991         acm->ctrl_buffer = buf;
 992
 993         if (acm_write_buffers_alloc(acm) < 0) {
 994                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
 995                 goto alloc_fail4;
 996         }
 997
 998         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 999         if (!acm->ctrlurb) {
1000                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1001                 goto alloc_fail5;
1002         }
1003         for (i = 0; i < num_rx_buf; i++) {
1004                 struct acm_ru *rcv = &(acm->ru[i]);
1005
1006                 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
1007                         dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
1008                         goto alloc_fail7;
1009                 }
1010
1011                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1012                 rcv->instance = acm;
1013         }
1014         for (i = 0; i < num_rx_buf; i++) {
1015                 struct acm_rb *buf = &(acm->rb[i]);
1016
1017                 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
1018                         dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
1019                         goto alloc_fail7;
1020                 }
1021         }
1022         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
1023         if (!acm->writeurb) {
1024                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
1025                 goto alloc_fail7;
1026         }
1027
1028         usb_set_intfdata (intf, acm);
1029
1030         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1031         if (i < 0)
1032                 goto alloc_fail8;
1033
1034         if (cfd) { /* export the country data */
1035                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1036                 if (!acm->country_codes)
1037                         goto skip_countries;
1038                 acm->country_code_size = cfd->bLength - 4;
1039                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
1040                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1041
1042                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1043                 if (i < 0) {
1044                         kfree(acm->country_codes);
1045                         goto skip_countries;
1046                 }
1047
1048                 i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
1049                 if (i < 0) {
1050                         kfree(acm->country_codes);
1051                         goto skip_countries;
1052                 }
1053         }
1054
1055 skip_countries:
1056         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1057                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
1058         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1059         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1060
1061         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1062                           NULL, acm->writesize, acm_write_bulk, acm);
1063         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
1064
1065         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1066
1067         acm_set_control(acm, acm->ctrlout);
1068
1069         acm->line.dwDTERate = cpu_to_le32(9600);
1070         acm->line.bDataBits = 8;
1071         acm_set_line(acm, &acm->line);
1072
1073         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1074
1075         usb_get_intf(control_interface);
1076         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1077
1078         acm_table[minor] = acm;
1079
1080         return 0;
1081 alloc_fail8:
1082         usb_free_urb(acm->writeurb);
1083 alloc_fail7:
1084         for (i = 0; i < num_rx_buf; i++)
1085                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1086         for (i = 0; i < num_rx_buf; i++)
1087                 usb_free_urb(acm->ru[i].urb);
1088         usb_free_urb(acm->ctrlurb);
1089 alloc_fail5:
1090         acm_write_buffers_free(acm);
1091 alloc_fail4:
1092         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1093 alloc_fail2:
1094         kfree(acm);
1095 alloc_fail:
1096         return -ENOMEM;
1097 }
1098
1099 static void acm_disconnect(struct usb_interface *intf)
1100 {
1101         struct acm *acm = usb_get_intfdata(intf);
1102         struct usb_device *usb_dev = interface_to_usbdev(intf);
1103         int i;
1104
1105         if (!acm || !acm->dev) {
1106                 dbg("disconnect on nonexisting interface");
1107                 return;
1108         }
1109
1110         mutex_lock(&open_mutex);
1111         if (!usb_get_intfdata(intf)) {
1112                 mutex_unlock(&open_mutex);
1113                 return;
1114         }
1115         if (acm->country_codes){
1116                 device_remove_file(&acm->control->dev,
1117                                 &dev_attr_wCountryCodes);
1118                 device_remove_file(&acm->control->dev,
1119                                 &dev_attr_iCountryCodeRelDate);
1120         }
1121         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1122         acm->dev = NULL;
1123         usb_set_intfdata(acm->control, NULL);
1124         usb_set_intfdata(acm->data, NULL);
1125
1126         tasklet_disable(&acm->urb_task);
1127
1128         usb_kill_urb(acm->ctrlurb);
1129         usb_kill_urb(acm->writeurb);
1130         for (i = 0; i < acm->rx_buflimit; i++)
1131                 usb_kill_urb(acm->ru[i].urb);
1132
1133         INIT_LIST_HEAD(&acm->filled_read_bufs);
1134         INIT_LIST_HEAD(&acm->spare_read_bufs);
1135
1136         tasklet_enable(&acm->urb_task);
1137
1138         flush_scheduled_work(); /* wait for acm_softint */
1139
1140         acm_write_buffers_free(acm);
1141         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1142         for (i = 0; i < acm->rx_buflimit; i++)
1143                 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1144
1145         usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1146
1147         if (!acm->used) {
1148                 acm_tty_unregister(acm);
1149                 mutex_unlock(&open_mutex);
1150                 return;
1151         }
1152
1153         mutex_unlock(&open_mutex);
1154
1155         if (acm->tty)
1156                 tty_hangup(acm->tty);
1157 }
1158
1159 /*
1160  * USB driver structure.
1161  */
1162
1163 static struct usb_device_id acm_ids[] = {
1164         /* quirky and broken devices */
1165         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1166         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1167         },
1168         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1169         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1170         },
1171         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1172         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1173         },
1174         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1175         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1176         },
1177         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1178         .driver_info = SINGLE_RX_URB, /* firmware bug */
1179         },
1180         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1181         .driver_info = SINGLE_RX_URB, /* firmware bug */
1182         },
1183         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1184         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1185         },
1186
1187         /* control interfaces with various AT-command sets */
1188         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1189                 USB_CDC_ACM_PROTO_AT_V25TER) },
1190         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1191                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1192         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1193                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1194         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1195                 USB_CDC_ACM_PROTO_AT_GSM) },
1196         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1197                 USB_CDC_ACM_PROTO_AT_3G ) },
1198         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1199                 USB_CDC_ACM_PROTO_AT_CDMA) },
1200
1201         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1202         { }
1203 };
1204
1205 MODULE_DEVICE_TABLE (usb, acm_ids);
1206
1207 static struct usb_driver acm_driver = {
1208         .name =         "cdc_acm",
1209         .probe =        acm_probe,
1210         .disconnect =   acm_disconnect,
1211         .id_table =     acm_ids,
1212 };
1213
1214 /*
1215  * TTY driver structures.
1216  */
1217
1218 static const struct tty_operations acm_ops = {
1219         .open =                 acm_tty_open,
1220         .close =                acm_tty_close,
1221         .write =                acm_tty_write,
1222         .write_room =           acm_tty_write_room,
1223         .ioctl =                acm_tty_ioctl,
1224         .throttle =             acm_tty_throttle,
1225         .unthrottle =           acm_tty_unthrottle,
1226         .chars_in_buffer =      acm_tty_chars_in_buffer,
1227         .break_ctl =            acm_tty_break_ctl,
1228         .set_termios =          acm_tty_set_termios,
1229         .tiocmget =             acm_tty_tiocmget,
1230         .tiocmset =             acm_tty_tiocmset,
1231 };
1232
1233 /*
1234  * Init / exit.
1235  */
1236
1237 static int __init acm_init(void)
1238 {
1239         int retval;
1240         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1241         if (!acm_tty_driver)
1242                 return -ENOMEM;
1243         acm_tty_driver->owner = THIS_MODULE,
1244         acm_tty_driver->driver_name = "acm",
1245         acm_tty_driver->name = "ttyACM",
1246         acm_tty_driver->major = ACM_TTY_MAJOR,
1247         acm_tty_driver->minor_start = 0,
1248         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1249         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1250         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1251         acm_tty_driver->init_termios = tty_std_termios;
1252         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1253         tty_set_operations(acm_tty_driver, &acm_ops);
1254
1255         retval = tty_register_driver(acm_tty_driver);
1256         if (retval) {
1257                 put_tty_driver(acm_tty_driver);
1258                 return retval;
1259         }
1260
1261         retval = usb_register(&acm_driver);
1262         if (retval) {
1263                 tty_unregister_driver(acm_tty_driver);
1264                 put_tty_driver(acm_tty_driver);
1265                 return retval;
1266         }
1267
1268         info(DRIVER_VERSION ":" DRIVER_DESC);
1269
1270         return 0;
1271 }
1272
1273 static void __exit acm_exit(void)
1274 {
1275         usb_deregister(&acm_driver);
1276         tty_unregister_driver(acm_tty_driver);
1277         put_tty_driver(acm_tty_driver);
1278 }
1279
1280 module_init(acm_init);
1281 module_exit(acm_exit);
1282
1283 MODULE_AUTHOR( DRIVER_AUTHOR );
1284 MODULE_DESCRIPTION( DRIVER_DESC );
1285 MODULE_LICENSE("GPL");
1286