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  *
  10  * USB Abstract Control Model driver for USB modems and ISDN adapters
  11  *
  12  * Sponsored by SuSE
  13  *
  14  * ChangeLog:
  15  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  16  *      v0.10 - some more cleanups
  17  *      v0.11 - fixed flow control, read error doesn't stop reads
  18  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
  19  *      v0.13 - added termios, added hangup
  20  *      v0.14 - sized down struct acm
  21  *      v0.15 - fixed flow control again - characters could be lost
  22  *      v0.16 - added code for modems with swapped data and control interfaces
  23  *      v0.17 - added new style probing
  24  *      v0.18 - fixed new style probing for devices with more configurations
  25  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  26  *      v0.20 - switched to probing on interface (rather than device) class
  27  *      v0.21 - revert to probing on device for devices with multiple configs
  28  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  29  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  30  *      v0.23 - use softirq for rx processing, as needed by tty layer
  31  *      v0.24 - change probe method to evaluate CDC union descriptor
  32  */
  33
  34 /*
  35  * This program is free software; you can redistribute it and/or modify
  36  * it under the terms of the GNU General Public License as published by
  37  * the Free Software Foundation; either version 2 of the License, or
  38  * (at your option) any later version.
  39  *
  40  * This program is distributed in the hope that it will be useful,
  41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  43  * GNU General Public License for more details.
  44  *
  45  * You should have received a copy of the GNU General Public License
  46  * along with this program; if not, write to the Free Software
  47  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  48  */
  49
  50 #undef DEBUG
  51
  52 #include <linux/kernel.h>
  53 #include <linux/errno.h>
  54 #include <linux/init.h>
  55 #include <linux/slab.h>
  56 #include <linux/tty.h>
  57 #include <linux/tty_driver.h>
  58 #include <linux/tty_flip.h>
  59 #include <linux/module.h>
  60 #include <linux/smp_lock.h>
  61 #include <asm/uaccess.h>
  62 #include <linux/usb.h>
  63 #include <asm/byteorder.h>
  64 #include <asm/unaligned.h>
  65
  66 #include "cdc-acm.h"
  67
  68 /*
  69  * Version Information
  70  */
  71 #define DRIVER_VERSION "v0.23"
  72 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik"
  73 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  74
  75 static struct usb_driver acm_driver;
  76 static struct tty_driver *acm_tty_driver;
  77 static struct acm *acm_table[ACM_TTY_MINORS];
  78
  79 static DECLARE_MUTEX(open_sem);
  80
  81 #define ACM_READY(acm)  (acm && acm->dev && acm->used)
  82
  83 /*
  84  * Functions for ACM control messages.
  85  */
  86
  87 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
  88 {
  89         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  90                 request, USB_RT_ACM, value,
  91                 acm->control->altsetting[0].desc.bInterfaceNumber,
  92                 buf, len, HZ * 5);
  93         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
  94         return retval < 0 ? retval : 0;
  95 }
  96
  97 /* devices aren't required to support these requests.
  98  * the cdc acm descriptor tells whether they do...
  99  */
 100 #define acm_set_control(acm, control)   acm_ctrl_msg(acm, ACM_REQ_SET_CONTROL, control, NULL, 0)
 101 #define acm_set_line(acm, line)         acm_ctrl_msg(acm, ACM_REQ_SET_LINE, 0, line, sizeof(struct acm_line))
 102 #define acm_send_break(acm, ms)         acm_ctrl_msg(acm, ACM_REQ_SEND_BREAK, ms, NULL, 0)
 103
 104 /*
 105  * Interrupt handlers for various ACM device responses
 106  */
 107
 108 /* control interface reports status changes with "interrupt" transfers */
 109 static void acm_ctrl_irq(struct urb *urb, struct pt_regs *regs)
 110 {
 111         struct acm *acm = urb->context;
 112         struct usb_ctrlrequest *dr = urb->transfer_buffer;
 113         unsigned char *data;
 114         int newctrl;
 115         int status;
 116
 117         switch (urb->status) {
 118         case 0:
 119                 /* success */
 120                 break;
 121         case -ECONNRESET:
 122         case -ENOENT:
 123         case -ESHUTDOWN:
 124                 /* this urb is terminated, clean up */
 125                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
 126                 return;
 127         default:
 128                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
 129                 goto exit;
 130         }
 131
 132         if (!ACM_READY(acm))
 133                 goto exit;
 134
 135         data = (unsigned char *)(dr + 1);
 136         switch (dr->bRequest) {
 137
 138                 case ACM_IRQ_NETWORK:
 139
 140                         dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
 141                         break;
 142
 143                 case ACM_IRQ_LINE_STATE:
 144
 145                         newctrl = le16_to_cpu(get_unaligned((__u16 *) data));
 146
 147                         if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 148                                 dbg("calling hangup");
 149                                 tty_hangup(acm->tty);
 150                         }
 151
 152                         acm->ctrlin = newctrl;
 153
 154                         dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 155                                 acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 156                                 acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 157                                 acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 158                                 acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 159
 160                         break;
 161
 162                 default:
 163                         dbg("unknown control event received: request %d index %d len %d data0 %d data1 %d",
 164                                 dr->bRequest, dr->wIndex, dr->wLength, data[0], data[1]);
 165                         break;
 166         }
 167 exit:
 168         status = usb_submit_urb (urb, GFP_ATOMIC);
 169         if (status)
 170                 err ("%s - usb_submit_urb failed with result %d",
 171                      __FUNCTION__, status);
 172 }
 173
 174 /* data interface returns incoming bytes, or we got unthrottled */
 175 static void acm_read_bulk(struct urb *urb, struct pt_regs *regs)
 176 {
 177         struct acm *acm = urb->context;
 178         dbg("Entering acm_read_bulk with status %d\n", urb->status);
 179
 180         if (!ACM_READY(acm))
 181                 return;
 182
 183         if (urb->status)
 184                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", urb->status);
 185
 186         /* calling tty_flip_buffer_push() in_irq() isn't allowed */
 187         tasklet_schedule(&acm->bh);
 188 }
 189
 190 static void acm_rx_tasklet(unsigned long _acm)
 191 {
 192         struct acm *acm = (void *)_acm;
 193         struct urb *urb = acm->readurb;
 194         struct tty_struct *tty = acm->tty;
 195         unsigned char *data = urb->transfer_buffer;
 196         int i = 0;
 197         dbg("Entering acm_rx_tasklet");
 198
 199         if (urb->actual_length > 0 && !acm->throttle)  {
 200                 for (i = 0; i < urb->actual_length && !acm->throttle; i++) {
 201                         /* if we insert more than TTY_FLIPBUF_SIZE characters,
 202                          * we drop them. */
 203                         if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
 204                                 tty_flip_buffer_push(tty);
 205                         }
 206                         tty_insert_flip_char(tty, data[i], 0);
 207                 }
 208                 dbg("Handed %d bytes to tty layer", i+1);
 209                 tty_flip_buffer_push(tty);
 210         }
 211
 212         spin_lock(&acm->throttle_lock);
 213         if (acm->throttle) {
 214                 dbg("Throtteling noticed");
 215                 memmove(data, data + i, urb->actual_length - i);
 216                 urb->actual_length -= i;
 217                 acm->resubmit_to_unthrottle = 1;
 218                 spin_unlock(&acm->throttle_lock);
 219                 return;
 220         }
 221         spin_unlock(&acm->throttle_lock);
 222
 223         urb->actual_length = 0;
 224         urb->dev = acm->dev;
 225
 226         i = usb_submit_urb(urb, GFP_ATOMIC);
 227         if (i)
 228                 dev_dbg(&acm->data->dev, "bulk rx resubmit %d\n", i);
 229 }
 230
 231 /* data interface wrote those outgoing bytes */
 232 static void acm_write_bulk(struct urb *urb, struct pt_regs *regs)
 233 {
 234         struct acm *acm = (struct acm *)urb->context;
 235         dbg("Entering acm_write_bulk with status %d\n", urb->status);
 236
 237         if (!ACM_READY(acm))
 238                 goto out;
 239
 240         if (urb->status)
 241                 dbg("nonzero write bulk status received: %d", urb->status);
 242
 243         schedule_work(&acm->work);
 244 out:
 245         acm->ready_for_write = 1;
 246 }
 247
 248 static void acm_softint(void *private)
 249 {
 250         struct acm *acm = private;
 251         struct tty_struct *tty = acm->tty;
 252         dbg("Entering acm_softint.\n");
 253
 254         if (!ACM_READY(acm))
 255                 return;
 256
 257         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup)
 258                 (tty->ldisc.write_wakeup)(tty);
 259
 260         wake_up_interruptible(&tty->write_wait);
 261 }
 262
 263 /*
 264  * TTY handlers
 265  */
 266
 267 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 268 {
 269         struct acm *acm = acm_table[tty->index];
 270         dbg("Entering acm_tty_open.\n");
 271
 272         if (!acm || !acm->dev)
 273                 return -EINVAL;
 274
 275         tty->driver_data = acm;
 276         acm->tty = tty;
 277
 278         down(&open_sem);
 279
 280         if (acm->used) {
 281                 goto done;
 282         }
 283
 284         acm->ctrlurb->dev = acm->dev;
 285         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 286                 dbg("usb_submit_urb(ctrl irq) failed");
 287                 goto bail_out;
 288         }
 289
 290         acm->readurb->dev = acm->dev;
 291         if (usb_submit_urb(acm->readurb, GFP_KERNEL)) {
 292                 dbg("usb_submit_urb(read bulk) failed");
 293                 goto bail_out_and_unlink;
 294         }
 295
 296         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
 297                 goto full_bailout;
 298
 299         /* force low_latency on so that our tty_push actually forces the data through,
 300            otherwise it is scheduled, and with high data rates data can get lost. */
 301         tty->low_latency = 1;
 302
 303 done:
 304         acm->used++;
 305         up(&open_sem);
 306         return 0;
 307
 308 full_bailout:
 309         usb_unlink_urb(acm->readurb);
 310 bail_out_and_unlink:
 311         usb_unlink_urb(acm->ctrlurb);
 312 bail_out:
 313         up(&open_sem);
 314         return -EIO;
 315 }
 316
 317 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 318 {
 319         struct acm *acm = tty->driver_data;
 320
 321         if (!acm || !acm->used)
 322                 return;
 323
 324         down(&open_sem);
 325         if (!--acm->used) {
 326                 if (acm->dev) {
 327                         acm_set_control(acm, acm->ctrlout = 0);
 328                         usb_unlink_urb(acm->ctrlurb);
 329                         usb_unlink_urb(acm->writeurb);
 330                         usb_unlink_urb(acm->readurb);
 331                 } else {
 332                         tty_unregister_device(acm_tty_driver, acm->minor);
 333                         acm_table[acm->minor] = NULL;
 334                         usb_free_urb(acm->ctrlurb);
 335                         usb_free_urb(acm->readurb);
 336                         usb_free_urb(acm->writeurb);
 337                         kfree(acm);
 338                 }
 339         }
 340         up(&open_sem);
 341 }
 342
 343 static int acm_tty_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
 344 {
 345         struct acm *acm = tty->driver_data;
 346         int stat;
 347         dbg("Entering acm_tty_write to write %d bytes from %s space,\n", count, from_user ? "user" : "kernel");
 348
 349         if (!ACM_READY(acm))
 350                 return -EINVAL;
 351         if (!acm->ready_for_write)
 352                 return 0;
 353         if (!count)
 354                 return 0;
 355
 356         count = (count > acm->writesize) ? acm->writesize : count;
 357
 358         dbg("Get %d bytes from %s space...", count, from_user ? "user" : "kernel");
 359         if (from_user) {
 360                 if (copy_from_user(acm->write_buffer, (void __user *)buf, count))
 361                         return -EFAULT;
 362         } else
 363                 memcpy(acm->write_buffer, buf, count);
 364         dbg("  Successfully copied.\n");
 365
 366         acm->writeurb->transfer_buffer_length = count;
 367         acm->writeurb->dev = acm->dev;
 368
 369         acm->ready_for_write = 0;
 370         stat = usb_submit_urb(acm->writeurb, GFP_NOIO);
 371         if (stat < 0) {
 372                 dbg("usb_submit_urb(write bulk) failed");
 373                 acm->ready_for_write = 1;
 374                 return stat;
 375         }
 376
 377         return count;
 378 }
 379
 380 static int acm_tty_write_room(struct tty_struct *tty)
 381 {
 382         struct acm *acm = tty->driver_data;
 383         if (!ACM_READY(acm))
 384                 return -EINVAL;
 385         return !acm->ready_for_write ? 0 : acm->writesize;
 386 }
 387
 388 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 389 {
 390         struct acm *acm = tty->driver_data;
 391         if (!ACM_READY(acm))
 392                 return -EINVAL;
 393         return !acm->ready_for_write ? acm->writeurb->transfer_buffer_length : 0;
 394 }
 395
 396 static void acm_tty_throttle(struct tty_struct *tty)
 397 {
 398         struct acm *acm = tty->driver_data;
 399         if (!ACM_READY(acm))
 400                 return;
 401         spin_lock_bh(&acm->throttle_lock);
 402         acm->throttle = 1;
 403         spin_unlock_bh(&acm->throttle_lock);
 404 }
 405
 406 static void acm_tty_unthrottle(struct tty_struct *tty)
 407 {
 408         struct acm *acm = tty->driver_data;
 409         if (!ACM_READY(acm))
 410                 return;
 411         spin_lock_bh(&acm->throttle_lock);
 412         acm->throttle = 0;
 413         spin_unlock_bh(&acm->throttle_lock);
 414         if (acm->resubmit_to_unthrottle) {
 415                 acm->resubmit_to_unthrottle = 0;
 416                 acm_read_bulk(acm->readurb, NULL);
 417         }
 418 }
 419
 420 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 421 {
 422         struct acm *acm = tty->driver_data;
 423         if (!ACM_READY(acm))
 424                 return;
 425         if (acm_send_break(acm, state ? 0xffff : 0))
 426                 dbg("send break failed");
 427 }
 428
 429 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 430 {
 431         struct acm *acm = tty->driver_data;
 432
 433         if (!ACM_READY(acm))
 434                 return -EINVAL;
 435
 436         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 437                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 438                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 439                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 440                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 441                TIOCM_CTS;
 442 }
 443
 444 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 445                             unsigned int set, unsigned int clear)
 446 {
 447         struct acm *acm = tty->driver_data;
 448         unsigned int newctrl;
 449
 450         if (!ACM_READY(acm))
 451                 return -EINVAL;
 452
 453         newctrl = acm->ctrlout;
 454         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 455         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 456
 457         newctrl = (newctrl & ~clear) | set;
 458
 459         if (acm->ctrlout == newctrl)
 460                 return 0;
 461         return acm_set_control(acm, acm->ctrlout = newctrl);
 462 }
 463
 464 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 465 {
 466         struct acm *acm = tty->driver_data;
 467
 468         if (!ACM_READY(acm))
 469                 return -EINVAL;
 470
 471         return -ENOIOCTLCMD;
 472 }
 473
 474 static __u32 acm_tty_speed[] = {
 475         0, 50, 75, 110, 134, 150, 200, 300, 600,
 476         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 477         57600, 115200, 230400, 460800, 500000, 576000,
 478         921600, 1000000, 1152000, 1500000, 2000000,
 479         2500000, 3000000, 3500000, 4000000
 480 };
 481
 482 static __u8 acm_tty_size[] = {
 483         5, 6, 7, 8
 484 };
 485
 486 static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
 487 {
 488         struct acm *acm = tty->driver_data;
 489         struct termios *termios = tty->termios;
 490         struct acm_line newline;
 491         int newctrl = acm->ctrlout;
 492
 493         if (!ACM_READY(acm))
 494                 return;
 495
 496         newline.speed = cpu_to_le32p(acm_tty_speed +
 497                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 498         newline.stopbits = termios->c_cflag & CSTOPB ? 2 : 0;
 499         newline.parity = termios->c_cflag & PARENB ?
 500                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 501         newline.databits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 502
 503         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 504
 505         if (!newline.speed) {
 506                 newline.speed = acm->line.speed;
 507                 newctrl &= ~ACM_CTRL_DTR;
 508         } else  newctrl |=  ACM_CTRL_DTR;
 509
 510         if (newctrl != acm->ctrlout)
 511                 acm_set_control(acm, acm->ctrlout = newctrl);
 512
 513         if (memcmp(&acm->line, &newline, sizeof(struct acm_line))) {
 514                 memcpy(&acm->line, &newline, sizeof(struct acm_line));
 515                 dbg("set line: %d %d %d %d", newline.speed, newline.stopbits, newline.parity, newline.databits);
 516                 acm_set_line(acm, &acm->line);
 517         }
 518 }
 519
 520 /*
 521  * USB probe and disconnect routines.
 522  */
 523
 524 static int acm_probe (struct usb_interface *intf,
 525                       const struct usb_device_id *id)
 526 {
 527         struct union_desc *union_header = NULL;
 528         char *buffer = intf->altsetting->extra;
 529         int buflen = intf->altsetting->extralen;
 530         struct usb_interface *control_interface;
 531         struct usb_interface *data_interface;
 532         struct usb_endpoint_descriptor *epctrl;
 533         struct usb_endpoint_descriptor *epread;
 534         struct usb_endpoint_descriptor *epwrite;
 535         struct usb_device *usb_dev = interface_to_usbdev(intf);
 536         struct acm *acm;
 537         int minor;
 538         int ctrlsize,readsize;
 539         u8 *buf;
 540         u8 ac_management_function = 0;
 541         u8 call_management_function = 0;
 542         int call_interface_num = -1;
 543         int data_interface_num;
 544
 545         if (!buffer) {
 546                 err("Wierd descriptor references");
 547                 return -EINVAL;
 548         }
 549
 550         while (buflen > 0) {
 551                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 552                         err("skipping garbage");
 553                         goto next_desc;
 554                 }
 555
 556                 switch (buffer [2]) {
 557                         case CDC_UNION_TYPE: /* we've found it */
 558                                 if (union_header) {
 559                                         err("More than one union descriptor, skipping ...");
 560                                         goto next_desc;
 561                                 }
 562                                 union_header = (struct union_desc *)buffer;
 563                                 break;
 564                         case CDC_COUNTRY_TYPE: /* maybe somehow export */
 565                                 break; /* for now we ignore it */
 566                         case CDC_AC_MANAGEMENT_TYPE:
 567                                 ac_management_function = buffer[3];
 568                                 break;
 569                         case CDC_CALL_MANAGEMENT_TYPE:
 570                                 call_management_function = buffer[3];
 571                                 call_interface_num = buffer[4];
 572                                 if ((call_management_function & 3) != 3)
 573                                         err("This device cannot do calls on its own. It is no modem.");
 574                                 break;
 575
 576                         default:
 577                                 err("Ignoring extra header");
 578                                 break;
 579                         }
 580 next_desc:
 581                 buflen -= buffer[0];
 582                 buffer += buffer[0];
 583         }
 584
 585         if (!union_header) {
 586                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 587                 return -ENODEV;
 588         }
 589
 590         control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 591         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 592         if (!control_interface || !data_interface) {
 593                 dev_dbg(&intf->dev,"no interfaces\n");
 594                 return -ENODEV;
 595         }
 596
 597         if (data_interface_num != call_interface_num)
 598                 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
 599
 600         if (usb_interface_claimed(data_interface)) { /* valid in this context */
 601                 dev_dbg(&intf->dev,"The data interface isn't available\n");
 602                 return -EBUSY;
 603         }
 604
 605         /*workaround for switched interfaces */
 606         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 607                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 608                         struct usb_interface *t;
 609                         dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
 610
 611                         t = control_interface;
 612                         control_interface = data_interface;
 613                         data_interface = t;
 614                 } else {
 615                         return -EINVAL;
 616                 }
 617         }
 618         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 619                 return -EINVAL;
 620
 621         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 622         epread = &data_interface->cur_altsetting->endpoint[0].desc;
 623         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 624
 625
 626         /* workaround for switched endpoints */
 627         if ((epread->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) {
 628                 /* descriptors are swapped */
 629                 struct usb_endpoint_descriptor *t;
 630                 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
 631
 632                 t = epread;
 633                 epread = epwrite;
 634                 epwrite = t;
 635         }
 636         dbg("interfaces are valid");
 637         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 638
 639         if (acm_table[minor]) {
 640                 err("no more free acm devices");
 641                 return -ENODEV;
 642         }
 643
 644         if (!(acm = kmalloc(sizeof(struct acm), GFP_KERNEL))) {
 645                 dev_dbg(&intf->dev, "out of memory (acm kmalloc)\n");
 646                 goto alloc_fail;
 647         }
 648         memset(acm, 0, sizeof(struct acm));
 649
 650         ctrlsize = epctrl->wMaxPacketSize;
 651         readsize = epread->wMaxPacketSize;
 652         acm->writesize = epwrite->wMaxPacketSize;
 653         acm->control = control_interface;
 654         acm->data = data_interface;
 655         acm->minor = minor;
 656         acm->dev = usb_dev;
 657         acm->ctrl_caps = ac_management_function;
 658         acm->ctrlsize = ctrlsize;
 659         acm->readsize = readsize;
 660         acm->bh.func = acm_rx_tasklet;
 661         acm->bh.data = (unsigned long) acm;
 662         INIT_WORK(&acm->work, acm_softint, acm);
 663         spin_lock_init(&acm->throttle_lock);
 664         acm->ready_for_write = 1;
 665
 666         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 667         if (!buf) {
 668                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
 669                 goto alloc_fail2;
 670         }
 671         acm->ctrl_buffer = buf;
 672
 673         buf = usb_buffer_alloc(usb_dev, readsize, GFP_KERNEL, &acm->read_dma);
 674         if (!buf) {
 675                 dev_dbg(&intf->dev, "out of memory (read buffer alloc)\n");
 676                 goto alloc_fail3;
 677         }
 678         acm->read_buffer = buf;
 679
 680         buf = usb_buffer_alloc(usb_dev, acm->writesize, GFP_KERNEL, &acm->write_dma);
 681         if (!buf) {
 682                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
 683                 goto alloc_fail4;
 684         }
 685         acm->write_buffer = buf;
 686
 687         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 688         if (!acm->ctrlurb) {
 689                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
 690                 goto alloc_fail5;
 691         }
 692         acm->readurb = usb_alloc_urb(0, GFP_KERNEL);
 693         if (!acm->readurb) {
 694                 dev_dbg(&intf->dev, "out of memory (readurb kmalloc)\n");
 695                 goto alloc_fail6;
 696         }
 697         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
 698         if (!acm->writeurb) {
 699                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
 700                 goto alloc_fail7;
 701         }
 702
 703         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
 704                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
 705         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 706         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 707
 708         usb_fill_bulk_urb(acm->readurb, usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress),
 709                           acm->read_buffer, readsize, acm_read_bulk, acm);
 710         acm->readurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 711         acm->readurb->transfer_dma = acm->read_dma;
 712
 713         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
 714                           acm->write_buffer, acm->writesize, acm_write_bulk, acm);
 715         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 716         acm->writeurb->transfer_dma = acm->write_dma;
 717
 718         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 719
 720         acm_set_control(acm, acm->ctrlout);
 721
 722         acm->line.speed = cpu_to_le32(9600);
 723         acm->line.databits = 8;
 724         acm_set_line(acm, &acm->line);
 725
 726         usb_driver_claim_interface(&acm_driver, data_interface, acm);
 727
 728         tty_register_device(acm_tty_driver, minor, &intf->dev);
 729
 730         acm_table[minor] = acm;
 731         usb_set_intfdata (intf, acm);
 732         return 0;
 733
 734 alloc_fail7:
 735         usb_free_urb(acm->readurb);
 736 alloc_fail6:
 737         usb_free_urb(acm->ctrlurb);
 738 alloc_fail5:
 739         usb_buffer_free(usb_dev, acm->writesize, acm->write_buffer, acm->write_dma);
 740 alloc_fail4:
 741         usb_buffer_free(usb_dev, readsize, acm->read_buffer, acm->read_dma);
 742 alloc_fail3:
 743         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 744 alloc_fail2:
 745         kfree(acm);
 746 alloc_fail:
 747         return -ENOMEM;
 748 }
 749
 750 static void acm_disconnect(struct usb_interface *intf)
 751 {
 752         struct acm *acm = usb_get_intfdata (intf);
 753         struct usb_device *usb_dev = interface_to_usbdev(intf);
 754
 755         if (!acm || !acm->dev) {
 756                 dbg("disconnect on nonexisting interface");
 757                 return;
 758         }
 759
 760         down(&open_sem);
 761         acm->dev = NULL;
 762         usb_set_intfdata (intf, NULL);
 763
 764         usb_unlink_urb(acm->ctrlurb);
 765         usb_unlink_urb(acm->readurb);
 766         usb_unlink_urb(acm->writeurb);
 767
 768         flush_scheduled_work(); /* wait for acm_softint */
 769
 770         usb_buffer_free(usb_dev, acm->writesize, acm->write_buffer, acm->write_dma);
 771         usb_buffer_free(usb_dev, acm->readsize, acm->read_buffer, acm->read_dma);
 772         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 773
 774         usb_driver_release_interface(&acm_driver, acm->data);
 775
 776         if (!acm->used) {
 777                 tty_unregister_device(acm_tty_driver, acm->minor);
 778                 acm_table[acm->minor] = NULL;
 779                 usb_free_urb(acm->ctrlurb);
 780                 usb_free_urb(acm->readurb);
 781                 usb_free_urb(acm->writeurb);
 782                 kfree(acm);
 783                 up(&open_sem);
 784                 return;
 785         }
 786
 787         up(&open_sem);
 788
 789         if (acm->tty)
 790                 tty_hangup(acm->tty);
 791 }
 792
 793 /*
 794  * USB driver structure.
 795  */
 796
 797 static struct usb_device_id acm_ids[] = {
 798         /* control interfaces with various AT-command sets */
 799         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 1) },
 800         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 2) },
 801         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 3) },
 802         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 4) },
 803         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 5) },
 804         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 6) },
 805
 806         /* NOTE:  COMM/2/0xff is likely MSFT RNDIS ... NOT a modem!! */
 807         { }
 808 };
 809
 810 MODULE_DEVICE_TABLE (usb, acm_ids);
 811
 812 static struct usb_driver acm_driver = {
 813         .owner =        THIS_MODULE,
 814         .name =         "cdc_acm",
 815         .probe =        acm_probe,
 816         .disconnect =   acm_disconnect,
 817         .id_table =     acm_ids,
 818 };
 819
 820 /*
 821  * TTY driver structures.
 822  */
 823
 824 static struct tty_operations acm_ops = {
 825         .open =                 acm_tty_open,
 826         .close =                acm_tty_close,
 827         .write =                acm_tty_write,
 828         .write_room =           acm_tty_write_room,
 829         .ioctl =                acm_tty_ioctl,
 830         .throttle =             acm_tty_throttle,
 831         .unthrottle =           acm_tty_unthrottle,
 832         .chars_in_buffer =      acm_tty_chars_in_buffer,
 833         .break_ctl =            acm_tty_break_ctl,
 834         .set_termios =          acm_tty_set_termios,
 835         .tiocmget =             acm_tty_tiocmget,
 836         .tiocmset =             acm_tty_tiocmset,
 837 };
 838
 839 /*
 840  * Init / exit.
 841  */
 842
 843 static int __init acm_init(void)
 844 {
 845         int retval;
 846         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
 847         if (!acm_tty_driver)
 848                 return -ENOMEM;
 849         acm_tty_driver->owner = THIS_MODULE,
 850         acm_tty_driver->driver_name = "acm",
 851         acm_tty_driver->name = "ttyACM",
 852         acm_tty_driver->devfs_name = "usb/acm/",
 853         acm_tty_driver->major = ACM_TTY_MAJOR,
 854         acm_tty_driver->minor_start = 0,
 855         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
 856         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
 857         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
 858         acm_tty_driver->init_termios = tty_std_termios;
 859         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 860         tty_set_operations(acm_tty_driver, &acm_ops);
 861
 862         retval = tty_register_driver(acm_tty_driver);
 863         if (retval) {
 864                 put_tty_driver(acm_tty_driver);
 865                 return retval;
 866         }
 867
 868         retval = usb_register(&acm_driver);
 869         if (retval) {
 870                 tty_unregister_driver(acm_tty_driver);
 871                 put_tty_driver(acm_tty_driver);
 872                 return retval;
 873         }
 874
 875         info(DRIVER_VERSION ":" DRIVER_DESC);
 876
 877         return 0;
 878 }
 879
 880 static void __exit acm_exit(void)
 881 {
 882         usb_deregister(&acm_driver);
 883         tty_unregister_driver(acm_tty_driver);
 884         put_tty_driver(acm_tty_driver);
 885 }
 886
 887 module_init(acm_init);
 888 module_exit(acm_exit);
 889
 890 MODULE_AUTHOR( DRIVER_AUTHOR );
 891 MODULE_DESCRIPTION( DRIVER_DESC );
 892 MODULE_LICENSE("GPL");
 893