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((__le16 *) 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         dbg("Entering acm_softint.\n");
 252
 253         if (!ACM_READY(acm))
 254                 return;
 255         tty_wakeup(acm->tty);
 256 }
 257
 258 /*
 259  * TTY handlers
 260  */
 261
 262 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 263 {
 264         struct acm *acm;
 265         int rv = -EINVAL;
 266         dbg("Entering acm_tty_open.\n");
 267
 268         down(&open_sem);
 269
 270         acm = acm_table[tty->index];
 271         if (!acm || !acm->dev)
 272                 goto err_out;
 273         else
 274                 rv = 0;
 275
 276         tty->driver_data = acm;
 277         acm->tty = tty;
 278
 279
 280
 281         if (acm->used++) {
 282                 goto done;
 283         }
 284
 285         acm->ctrlurb->dev = acm->dev;
 286         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 287                 dbg("usb_submit_urb(ctrl irq) failed");
 288                 goto bail_out;
 289         }
 290
 291         acm->readurb->dev = acm->dev;
 292         if (usb_submit_urb(acm->readurb, GFP_KERNEL)) {
 293                 dbg("usb_submit_urb(read bulk) failed");
 294                 goto bail_out_and_unlink;
 295         }
 296
 297         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
 298                 goto full_bailout;
 299
 300         /* force low_latency on so that our tty_push actually forces the data through,
 301            otherwise it is scheduled, and with high data rates data can get lost. */
 302         tty->low_latency = 1;
 303
 304 done:
 305 err_out:
 306         up(&open_sem);
 307         return rv;
 308
 309 full_bailout:
 310         usb_kill_urb(acm->readurb);
 311 bail_out_and_unlink:
 312         usb_kill_urb(acm->ctrlurb);
 313 bail_out:
 314         acm->used--;
 315         up(&open_sem);
 316         return -EIO;
 317 }
 318
 319 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 320 {
 321         struct acm *acm = tty->driver_data;
 322
 323         if (!acm || !acm->used)
 324                 return;
 325
 326         down(&open_sem);
 327         if (!--acm->used) {
 328                 if (acm->dev) {
 329                         acm_set_control(acm, acm->ctrlout = 0);
 330                         usb_kill_urb(acm->ctrlurb);
 331                         usb_kill_urb(acm->writeurb);
 332                         usb_kill_urb(acm->readurb);
 333                 } else {
 334                         tty_unregister_device(acm_tty_driver, acm->minor);
 335                         acm_table[acm->minor] = NULL;
 336                         usb_free_urb(acm->ctrlurb);
 337                         usb_free_urb(acm->readurb);
 338                         usb_free_urb(acm->writeurb);
 339                         kfree(acm);
 340                 }
 341         }
 342         up(&open_sem);
 343 }
 344
 345 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 346 {
 347         struct acm *acm = tty->driver_data;
 348         int stat;
 349         dbg("Entering acm_tty_write to write %d bytes,\n", count);
 350
 351         if (!ACM_READY(acm))
 352                 return -EINVAL;
 353         if (!acm->ready_for_write)
 354                 return 0;
 355         if (!count)
 356                 return 0;
 357
 358         count = (count > acm->writesize) ? acm->writesize : count;
 359
 360         dbg("Get %d bytes...", count);
 361         memcpy(acm->write_buffer, buf, count);
 362         dbg("  Successfully copied.\n");
 363
 364         acm->writeurb->transfer_buffer_length = count;
 365         acm->writeurb->dev = acm->dev;
 366
 367         acm->ready_for_write = 0;
 368         stat = usb_submit_urb(acm->writeurb, GFP_ATOMIC);
 369         if (stat < 0) {
 370                 dbg("usb_submit_urb(write bulk) failed");
 371                 acm->ready_for_write = 1;
 372                 return stat;
 373         }
 374
 375         return count;
 376 }
 377
 378 static int acm_tty_write_room(struct tty_struct *tty)
 379 {
 380         struct acm *acm = tty->driver_data;
 381         if (!ACM_READY(acm))
 382                 return -EINVAL;
 383         return !acm->ready_for_write ? 0 : acm->writesize;
 384 }
 385
 386 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 387 {
 388         struct acm *acm = tty->driver_data;
 389         if (!ACM_READY(acm))
 390                 return -EINVAL;
 391         return !acm->ready_for_write ? acm->writeurb->transfer_buffer_length : 0;
 392 }
 393
 394 static void acm_tty_throttle(struct tty_struct *tty)
 395 {
 396         struct acm *acm = tty->driver_data;
 397         if (!ACM_READY(acm))
 398                 return;
 399         spin_lock_bh(&acm->throttle_lock);
 400         acm->throttle = 1;
 401         spin_unlock_bh(&acm->throttle_lock);
 402 }
 403
 404 static void acm_tty_unthrottle(struct tty_struct *tty)
 405 {
 406         struct acm *acm = tty->driver_data;
 407         if (!ACM_READY(acm))
 408                 return;
 409         spin_lock_bh(&acm->throttle_lock);
 410         acm->throttle = 0;
 411         spin_unlock_bh(&acm->throttle_lock);
 412         if (acm->resubmit_to_unthrottle) {
 413                 acm->resubmit_to_unthrottle = 0;
 414                 acm_read_bulk(acm->readurb, NULL);
 415         }
 416 }
 417
 418 static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 419 {
 420         struct acm *acm = tty->driver_data;
 421         if (!ACM_READY(acm))
 422                 return;
 423         if (acm_send_break(acm, state ? 0xffff : 0))
 424                 dbg("send break failed");
 425 }
 426
 427 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 428 {
 429         struct acm *acm = tty->driver_data;
 430
 431         if (!ACM_READY(acm))
 432                 return -EINVAL;
 433
 434         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 435                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 436                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 437                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 438                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 439                TIOCM_CTS;
 440 }
 441
 442 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 443                             unsigned int set, unsigned int clear)
 444 {
 445         struct acm *acm = tty->driver_data;
 446         unsigned int newctrl;
 447
 448         if (!ACM_READY(acm))
 449                 return -EINVAL;
 450
 451         newctrl = acm->ctrlout;
 452         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 453         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 454
 455         newctrl = (newctrl & ~clear) | set;
 456
 457         if (acm->ctrlout == newctrl)
 458                 return 0;
 459         return acm_set_control(acm, acm->ctrlout = newctrl);
 460 }
 461
 462 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 463 {
 464         struct acm *acm = tty->driver_data;
 465
 466         if (!ACM_READY(acm))
 467                 return -EINVAL;
 468
 469         return -ENOIOCTLCMD;
 470 }
 471
 472 static __u32 acm_tty_speed[] = {
 473         0, 50, 75, 110, 134, 150, 200, 300, 600,
 474         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 475         57600, 115200, 230400, 460800, 500000, 576000,
 476         921600, 1000000, 1152000, 1500000, 2000000,
 477         2500000, 3000000, 3500000, 4000000
 478 };
 479
 480 static __u8 acm_tty_size[] = {
 481         5, 6, 7, 8
 482 };
 483
 484 static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
 485 {
 486         struct acm *acm = tty->driver_data;
 487         struct termios *termios = tty->termios;
 488         struct acm_line newline;
 489         int newctrl = acm->ctrlout;
 490
 491         if (!ACM_READY(acm))
 492                 return;
 493
 494         newline.speed = cpu_to_le32p(acm_tty_speed +
 495                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 496         newline.stopbits = termios->c_cflag & CSTOPB ? 2 : 0;
 497         newline.parity = termios->c_cflag & PARENB ?
 498                 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 499         newline.databits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 500
 501         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 502
 503         if (!newline.speed) {
 504                 newline.speed = acm->line.speed;
 505                 newctrl &= ~ACM_CTRL_DTR;
 506         } else  newctrl |=  ACM_CTRL_DTR;
 507
 508         if (newctrl != acm->ctrlout)
 509                 acm_set_control(acm, acm->ctrlout = newctrl);
 510
 511         if (memcmp(&acm->line, &newline, sizeof(struct acm_line))) {
 512                 memcpy(&acm->line, &newline, sizeof(struct acm_line));
 513                 dbg("set line: %d %d %d %d", newline.speed, newline.stopbits, newline.parity, newline.databits);
 514                 acm_set_line(acm, &acm->line);
 515         }
 516 }
 517
 518 /*
 519  * USB probe and disconnect routines.
 520  */
 521
 522 static int acm_probe (struct usb_interface *intf,
 523                       const struct usb_device_id *id)
 524 {
 525         struct union_desc *union_header = NULL;
 526         char *buffer = intf->altsetting->extra;
 527         int buflen = intf->altsetting->extralen;
 528         struct usb_interface *control_interface;
 529         struct usb_interface *data_interface;
 530         struct usb_endpoint_descriptor *epctrl;
 531         struct usb_endpoint_descriptor *epread;
 532         struct usb_endpoint_descriptor *epwrite;
 533         struct usb_device *usb_dev = interface_to_usbdev(intf);
 534         struct acm *acm;
 535         int minor;
 536         int ctrlsize,readsize;
 537         u8 *buf;
 538         u8 ac_management_function = 0;
 539         u8 call_management_function = 0;
 540         int call_interface_num = -1;
 541         int data_interface_num;
 542         unsigned long quirks;
 543
 544         /* handle quirks deadly to normal probing*/
 545         quirks = (unsigned long)id->driver_info;
 546         if (quirks == NO_UNION_NORMAL) {
 547                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 548                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 549                 goto skip_normal_probe;
 550         }
 551
 552         /* normal probing*/
 553         if (!buffer) {
 554                 err("Wierd descriptor references\n");
 555                 return -EINVAL;
 556         }
 557
 558         if (!buflen) {
 559                 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 560                         dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
 561                         buflen = intf->cur_altsetting->endpoint->extralen;
 562                         buffer = intf->cur_altsetting->endpoint->extra;
 563                 } else {
 564                         err("Zero length descriptor references\n");
 565                         return -EINVAL;
 566                 }
 567         }
 568
 569         while (buflen > 0) {
 570                 if (buffer [1] != USB_DT_CS_INTERFACE) {
 571                         err("skipping garbage\n");
 572                         goto next_desc;
 573                 }
 574
 575                 switch (buffer [2]) {
 576                         case CDC_UNION_TYPE: /* we've found it */
 577                                 if (union_header) {
 578                                         err("More than one union descriptor, skipping ...");
 579                                         goto next_desc;
 580                                 }
 581                                 union_header = (struct union_desc *)buffer;
 582                                 break;
 583                         case CDC_COUNTRY_TYPE: /* maybe somehow export */
 584                                 break; /* for now we ignore it */
 585                         case CDC_HEADER_TYPE: /* maybe check version */
 586                                 break; /* for now we ignore it */
 587                         case CDC_AC_MANAGEMENT_TYPE:
 588                                 ac_management_function = buffer[3];
 589                                 break;
 590                         case CDC_CALL_MANAGEMENT_TYPE:
 591                                 call_management_function = buffer[3];
 592                                 call_interface_num = buffer[4];
 593                                 if ((call_management_function & 3) != 3)
 594                                         err("This device cannot do calls on its own. It is no modem.");
 595                                 break;
 596
 597                         default:
 598                                 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
 599                                 break;
 600                         }
 601 next_desc:
 602                 buflen -= buffer[0];
 603                 buffer += buffer[0];
 604         }
 605
 606         if (!union_header) {
 607                 if (call_interface_num > 0) {
 608                         dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
 609                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 610                         control_interface = intf;
 611                 } else {
 612                         dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 613                         return -ENODEV;
 614                 }
 615         } else {
 616                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 617                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 618                 if (!control_interface || !data_interface) {
 619                         dev_dbg(&intf->dev,"no interfaces\n");
 620                         return -ENODEV;
 621                 }
 622         }
 623
 624         if (data_interface_num != call_interface_num)
 625                 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.\n");
 626
 627 skip_normal_probe:
 628
 629         /*workaround for switched interfaces */
 630         if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 631                 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 632                         struct usb_interface *t;
 633                         dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
 634
 635                         t = control_interface;
 636                         control_interface = data_interface;
 637                         data_interface = t;
 638                 } else {
 639                         return -EINVAL;
 640                 }
 641         }
 642
 643         if (usb_interface_claimed(data_interface)) { /* valid in this context */
 644                 dev_dbg(&intf->dev,"The data interface isn't available\n");
 645                 return -EBUSY;
 646         }
 647
 648
 649         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 650                 return -EINVAL;
 651
 652         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 653         epread = &data_interface->cur_altsetting->endpoint[0].desc;
 654         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 655
 656
 657         /* workaround for switched endpoints */
 658         if ((epread->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) {
 659                 /* descriptors are swapped */
 660                 struct usb_endpoint_descriptor *t;
 661                 dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
 662
 663                 t = epread;
 664                 epread = epwrite;
 665                 epwrite = t;
 666         }
 667         dbg("interfaces are valid");
 668         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 669
 670         if (minor == ACM_TTY_MINORS) {
 671                 err("no more free acm devices");
 672                 return -ENODEV;
 673         }
 674
 675         if (!(acm = kmalloc(sizeof(struct acm), GFP_KERNEL))) {
 676                 dev_dbg(&intf->dev, "out of memory (acm kmalloc)\n");
 677                 goto alloc_fail;
 678         }
 679         memset(acm, 0, sizeof(struct acm));
 680
 681         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 682         readsize = le16_to_cpu(epread->wMaxPacketSize);
 683         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
 684         acm->control = control_interface;
 685         acm->data = data_interface;
 686         acm->minor = minor;
 687         acm->dev = usb_dev;
 688         acm->ctrl_caps = ac_management_function;
 689         acm->ctrlsize = ctrlsize;
 690         acm->readsize = readsize;
 691         acm->bh.func = acm_rx_tasklet;
 692         acm->bh.data = (unsigned long) acm;
 693         INIT_WORK(&acm->work, acm_softint, acm);
 694         spin_lock_init(&acm->throttle_lock);
 695         acm->ready_for_write = 1;
 696
 697         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 698         if (!buf) {
 699                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
 700                 goto alloc_fail2;
 701         }
 702         acm->ctrl_buffer = buf;
 703
 704         buf = usb_buffer_alloc(usb_dev, readsize, GFP_KERNEL, &acm->read_dma);
 705         if (!buf) {
 706                 dev_dbg(&intf->dev, "out of memory (read buffer alloc)\n");
 707                 goto alloc_fail3;
 708         }
 709         acm->read_buffer = buf;
 710
 711         buf = usb_buffer_alloc(usb_dev, acm->writesize, GFP_KERNEL, &acm->write_dma);
 712         if (!buf) {
 713                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
 714                 goto alloc_fail4;
 715         }
 716         acm->write_buffer = buf;
 717
 718         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 719         if (!acm->ctrlurb) {
 720                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
 721                 goto alloc_fail5;
 722         }
 723         acm->readurb = usb_alloc_urb(0, GFP_KERNEL);
 724         if (!acm->readurb) {
 725                 dev_dbg(&intf->dev, "out of memory (readurb kmalloc)\n");
 726                 goto alloc_fail6;
 727         }
 728         acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
 729         if (!acm->writeurb) {
 730                 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n");
 731                 goto alloc_fail7;
 732         }
 733
 734         usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
 735                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
 736         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 737         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 738
 739         usb_fill_bulk_urb(acm->readurb, usb_dev, usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress),
 740                           acm->read_buffer, readsize, acm_read_bulk, acm);
 741         acm->readurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 742         acm->readurb->transfer_dma = acm->read_dma;
 743
 744         usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
 745                           acm->write_buffer, acm->writesize, acm_write_bulk, acm);
 746         acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 747         acm->writeurb->transfer_dma = acm->write_dma;
 748
 749         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 750
 751         acm_set_control(acm, acm->ctrlout);
 752
 753         acm->line.speed = cpu_to_le32(9600);
 754         acm->line.databits = 8;
 755         acm_set_line(acm, &acm->line);
 756
 757         usb_driver_claim_interface(&acm_driver, data_interface, acm);
 758
 759         tty_register_device(acm_tty_driver, minor, &intf->dev);
 760
 761         acm_table[minor] = acm;
 762         usb_set_intfdata (intf, acm);
 763         return 0;
 764
 765 alloc_fail7:
 766         usb_free_urb(acm->readurb);
 767 alloc_fail6:
 768         usb_free_urb(acm->ctrlurb);
 769 alloc_fail5:
 770         usb_buffer_free(usb_dev, acm->writesize, acm->write_buffer, acm->write_dma);
 771 alloc_fail4:
 772         usb_buffer_free(usb_dev, readsize, acm->read_buffer, acm->read_dma);
 773 alloc_fail3:
 774         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 775 alloc_fail2:
 776         kfree(acm);
 777 alloc_fail:
 778         return -ENOMEM;
 779 }
 780
 781 static void acm_disconnect(struct usb_interface *intf)
 782 {
 783         struct acm *acm = usb_get_intfdata (intf);
 784         struct usb_device *usb_dev = interface_to_usbdev(intf);
 785
 786         if (!acm || !acm->dev) {
 787                 dbg("disconnect on nonexisting interface");
 788                 return;
 789         }
 790
 791         down(&open_sem);
 792         acm->dev = NULL;
 793         usb_set_intfdata (intf, NULL);
 794
 795         usb_kill_urb(acm->ctrlurb);
 796         usb_kill_urb(acm->readurb);
 797         usb_kill_urb(acm->writeurb);
 798
 799         flush_scheduled_work(); /* wait for acm_softint */
 800
 801         usb_buffer_free(usb_dev, acm->writesize, acm->write_buffer, acm->write_dma);
 802         usb_buffer_free(usb_dev, acm->readsize, acm->read_buffer, acm->read_dma);
 803         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
 804
 805         usb_driver_release_interface(&acm_driver, acm->data);
 806
 807         if (!acm->used) {
 808                 tty_unregister_device(acm_tty_driver, acm->minor);
 809                 acm_table[acm->minor] = NULL;
 810                 usb_free_urb(acm->ctrlurb);
 811                 usb_free_urb(acm->readurb);
 812                 usb_free_urb(acm->writeurb);
 813                 kfree(acm);
 814                 up(&open_sem);
 815                 return;
 816         }
 817
 818         up(&open_sem);
 819
 820         if (acm->tty)
 821                 tty_hangup(acm->tty);
 822 }
 823
 824 /*
 825  * USB driver structure.
 826  */
 827
 828 static struct usb_device_id acm_ids[] = {
 829         /* quirky and broken devices */
 830         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
 831         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 832         },
 833         /* control interfaces with various AT-command sets */
 834         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 1) },
 835         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 2) },
 836         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 3) },
 837         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 4) },
 838         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 5) },
 839         { USB_INTERFACE_INFO(USB_CLASS_COMM, 2, 6) },
 840
 841         /* NOTE:  COMM/2/0xff is likely MSFT RNDIS ... NOT a modem!! */
 842         { }
 843 };
 844
 845 MODULE_DEVICE_TABLE (usb, acm_ids);
 846
 847 static struct usb_driver acm_driver = {
 848         .owner =        THIS_MODULE,
 849         .name =         "cdc_acm",
 850         .probe =        acm_probe,
 851         .disconnect =   acm_disconnect,
 852         .id_table =     acm_ids,
 853 };
 854
 855 /*
 856  * TTY driver structures.
 857  */
 858
 859 static struct tty_operations acm_ops = {
 860         .open =                 acm_tty_open,
 861         .close =                acm_tty_close,
 862         .write =                acm_tty_write,
 863         .write_room =           acm_tty_write_room,
 864         .ioctl =                acm_tty_ioctl,
 865         .throttle =             acm_tty_throttle,
 866         .unthrottle =           acm_tty_unthrottle,
 867         .chars_in_buffer =      acm_tty_chars_in_buffer,
 868         .break_ctl =            acm_tty_break_ctl,
 869         .set_termios =          acm_tty_set_termios,
 870         .tiocmget =             acm_tty_tiocmget,
 871         .tiocmset =             acm_tty_tiocmset,
 872 };
 873
 874 /*
 875  * Init / exit.
 876  */
 877
 878 static int __init acm_init(void)
 879 {
 880         int retval;
 881         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
 882         if (!acm_tty_driver)
 883                 return -ENOMEM;
 884         acm_tty_driver->owner = THIS_MODULE,
 885         acm_tty_driver->driver_name = "acm",
 886         acm_tty_driver->name = "ttyACM",
 887         acm_tty_driver->devfs_name = "usb/acm/",
 888         acm_tty_driver->major = ACM_TTY_MAJOR,
 889         acm_tty_driver->minor_start = 0,
 890         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
 891         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
 892         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
 893         acm_tty_driver->init_termios = tty_std_termios;
 894         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 895         tty_set_operations(acm_tty_driver, &acm_ops);
 896
 897         retval = tty_register_driver(acm_tty_driver);
 898         if (retval) {
 899                 put_tty_driver(acm_tty_driver);
 900                 return retval;
 901         }
 902
 903         retval = usb_register(&acm_driver);
 904         if (retval) {
 905                 tty_unregister_driver(acm_tty_driver);
 906                 put_tty_driver(acm_tty_driver);
 907                 return retval;
 908         }
 909
 910         info(DRIVER_VERSION ":" DRIVER_DESC);
 911
 912         return 0;
 913 }
 914
 915 static void __exit acm_exit(void)
 916 {
 917         usb_deregister(&acm_driver);
 918         tty_unregister_driver(acm_tty_driver);
 919         put_tty_driver(acm_tty_driver);
 920 }
 921
 922 module_init(acm_init);
 923 module_exit(acm_exit);
 924
 925 MODULE_AUTHOR( DRIVER_AUTHOR );
 926 MODULE_DESCRIPTION( DRIVER_DESC );
 927 MODULE_LICENSE("GPL");
 928