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