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@ucw.cz>
   6  * Copyright (c) 1999 Johannes Erdfelt  <johannes@erdfelt.com>
   7  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
   8  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
   9  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
  10  *
  11  * USB Abstract Control Model driver for USB modems and ISDN adapters
  12  *
  13  * Sponsored by SuSE
  14  *
  15  * ChangeLog:
  16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  17  *      v0.10 - some more cleanups
  18  *      v0.11 - fixed flow control, read error doesn't stop reads
  19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm
  20  *              kmalloced
  21  *      v0.13 - added termios, added hangup
  22  *      v0.14 - sized down struct acm
  23  *      v0.15 - fixed flow control again - characters could be lost
  24  *      v0.16 - added code for modems with swapped data and control interfaces
  25  *      v0.17 - added new style probing
  26  *      v0.18 - fixed new style probing for devices with more configurations
  27  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  28  *      v0.20 - switched to probing on interface (rather than device) class
  29  *      v0.21 - revert to probing on device for devices with multiple configs
  30  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  31  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  32  *      v0.23 - use softirq for rx processing, as needed by tty layer
  33  *      v0.24 - change probe method to evaluate CDC union descriptor
  34  *      v0.25 - downstream tasks paralelized to maximize throughput
  35  *      v0.26 - multiple write urbs, writesize increased
  36  */
  37
  38 /*
  39  * This program is free software; you can redistribute it and/or modify
  40  * it under the terms of the GNU General Public License as published by
  41  * the Free Software Foundation; either version 2 of the License, or
  42  * (at your option) any later version.
  43  *
  44  * This program is distributed in the hope that it will be useful,
  45  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  46  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  47  * GNU General Public License for more details.
  48  *
  49  * You should have received a copy of the GNU General Public License
  50  * along with this program; if not, write to the Free Software
  51  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  52  */
  53
  54 #undef DEBUG
  55 #undef VERBOSE_DEBUG
  56
  57 #include <linux/kernel.h>
  58 #include <linux/errno.h>
  59 #include <linux/init.h>
  60 #include <linux/slab.h>
  61 #include <linux/tty.h>
  62 #include <linux/serial.h>
  63 #include <linux/tty_driver.h>
  64 #include <linux/tty_flip.h>
  65 #include <linux/module.h>
  66 #include <linux/mutex.h>
  67 #include <linux/uaccess.h>
  68 #include <linux/usb.h>
  69 #include <linux/usb/cdc.h>
  70 #include <asm/byteorder.h>
  71 #include <asm/unaligned.h>
  72 #include <linux/list.h>
  73
  74 #include "cdc-acm.h"
  75
  76
  77 #define ACM_CLOSE_TIMEOUT       15      /* seconds to let writes drain */
  78
  79 /*
  80  * Version Information
  81  */
  82 #define DRIVER_VERSION "v0.26"
  83 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  84 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  85
  86 static struct usb_driver acm_driver;
  87 static struct tty_driver *acm_tty_driver;
  88 static struct acm *acm_table[ACM_TTY_MINORS];
  89
  90 static DEFINE_MUTEX(open_mutex);
  91
  92 #define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
  93
  94 static const struct tty_port_operations acm_port_ops = {
  95 };
  96
  97 #ifdef VERBOSE_DEBUG
  98 #define verbose 1
  99 #else
 100 #define verbose 0
 101 #endif
 102
 103 /*
 104  * Functions for ACM control messages.
 105  */
 106
 107 static int acm_ctrl_msg(struct acm *acm, int request, int value,
 108                                                         void *buf, int len)
 109 {
 110         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
 111                 request, USB_RT_ACM, value,
 112                 acm->control->altsetting[0].desc.bInterfaceNumber,
 113                 buf, len, 5000);
 114         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
 115                                                 request, value, len, retval);
 116         return retval < 0 ? retval : 0;
 117 }
 118
 119 /* devices aren't required to support these requests.
 120  * the cdc acm descriptor tells whether they do...
 121  */
 122 #define acm_set_control(acm, control) \
 123         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 124 #define acm_set_line(acm, line) \
 125         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 126 #define acm_send_break(acm, ms) \
 127         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 128
 129 /*
 130  * Write buffer management.
 131  * All of these assume proper locks taken by the caller.
 132  */
 133
 134 static int acm_wb_alloc(struct acm *acm)
 135 {
 136         int i, wbn;
 137         struct acm_wb *wb;
 138
 139         wbn = 0;
 140         i = 0;
 141         for (;;) {
 142                 wb = &acm->wb[wbn];
 143                 if (!wb->use) {
 144                         wb->use = 1;
 145                         return wbn;
 146                 }
 147                 wbn = (wbn + 1) % ACM_NW;
 148                 if (++i >= ACM_NW)
 149                         return -1;
 150         }
 151 }
 152
 153 static int acm_wb_is_avail(struct acm *acm)
 154 {
 155         int i, n;
 156         unsigned long flags;
 157
 158         n = ACM_NW;
 159         spin_lock_irqsave(&acm->write_lock, flags);
 160         for (i = 0; i < ACM_NW; i++)
 161                 n -= acm->wb[i].use;
 162         spin_unlock_irqrestore(&acm->write_lock, flags);
 163         return n;
 164 }
 165
 166 /*
 167  * Finish write. Caller must hold acm->write_lock
 168  */
 169 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 170 {
 171         wb->use = 0;
 172         acm->transmitting--;
 173         usb_autopm_put_interface_async(acm->control);
 174 }
 175
 176 /*
 177  * Poke write.
 178  *
 179  * the caller is responsible for locking
 180  */
 181
 182 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 183 {
 184         int rc;
 185
 186         acm->transmitting++;
 187
 188         wb->urb->transfer_buffer = wb->buf;
 189         wb->urb->transfer_dma = wb->dmah;
 190         wb->urb->transfer_buffer_length = wb->len;
 191         wb->urb->dev = acm->dev;
 192
 193         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 194         if (rc < 0) {
 195                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
 196                 acm_write_done(acm, wb);
 197         }
 198         return rc;
 199 }
 200
 201 static int acm_write_start(struct acm *acm, int wbn)
 202 {
 203         unsigned long flags;
 204         struct acm_wb *wb = &acm->wb[wbn];
 205         int rc;
 206
 207         spin_lock_irqsave(&acm->write_lock, flags);
 208         if (!acm->dev) {
 209                 wb->use = 0;
 210                 spin_unlock_irqrestore(&acm->write_lock, flags);
 211                 return -ENODEV;
 212         }
 213
 214         dbg("%s susp_count: %d", __func__, acm->susp_count);
 215         usb_autopm_get_interface_async(acm->control);
 216         if (acm->susp_count) {
 217                 if (!acm->delayed_wb)
 218                         acm->delayed_wb = wb;
 219                 else
 220                         usb_autopm_put_interface_async(acm->control);
 221                 spin_unlock_irqrestore(&acm->write_lock, flags);
 222                 return 0;       /* A white lie */
 223         }
 224         usb_mark_last_busy(acm->dev);
 225
 226         rc = acm_start_wb(acm, wb);
 227         spin_unlock_irqrestore(&acm->write_lock, flags);
 228
 229         return rc;
 230
 231 }
 232 /*
 233  * attributes exported through sysfs
 234  */
 235 static ssize_t show_caps
 236 (struct device *dev, struct device_attribute *attr, char *buf)
 237 {
 238         struct usb_interface *intf = to_usb_interface(dev);
 239         struct acm *acm = usb_get_intfdata(intf);
 240
 241         return sprintf(buf, "%d", acm->ctrl_caps);
 242 }
 243 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 244
 245 static ssize_t show_country_codes
 246 (struct device *dev, struct device_attribute *attr, char *buf)
 247 {
 248         struct usb_interface *intf = to_usb_interface(dev);
 249         struct acm *acm = usb_get_intfdata(intf);
 250
 251         memcpy(buf, acm->country_codes, acm->country_code_size);
 252         return acm->country_code_size;
 253 }
 254
 255 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 256
 257 static ssize_t show_country_rel_date
 258 (struct device *dev, struct device_attribute *attr, char *buf)
 259 {
 260         struct usb_interface *intf = to_usb_interface(dev);
 261         struct acm *acm = usb_get_intfdata(intf);
 262
 263         return sprintf(buf, "%d", acm->country_rel_date);
 264 }
 265
 266 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 267 /*
 268  * Interrupt handlers for various ACM device responses
 269  */
 270
 271 /* control interface reports status changes with "interrupt" transfers */
 272 static void acm_ctrl_irq(struct urb *urb)
 273 {
 274         struct acm *acm = urb->context;
 275         struct usb_cdc_notification *dr = urb->transfer_buffer;
 276         struct tty_struct *tty;
 277         unsigned char *data;
 278         int newctrl;
 279         int retval;
 280         int status = urb->status;
 281
 282         switch (status) {
 283         case 0:
 284                 /* success */
 285                 break;
 286         case -ECONNRESET:
 287         case -ENOENT:
 288         case -ESHUTDOWN:
 289                 /* this urb is terminated, clean up */
 290                 dbg("%s - urb shutting down with status: %d", __func__, status);
 291                 return;
 292         default:
 293                 dbg("%s - nonzero urb status received: %d", __func__, status);
 294                 goto exit;
 295         }
 296
 297         if (!ACM_READY(acm))
 298                 goto exit;
 299
 300         data = (unsigned char *)(dr + 1);
 301         switch (dr->bNotificationType) {
 302         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 303                 dbg("%s network", dr->wValue ?
 304                                         "connected to" : "disconnected from");
 305                 break;
 306
 307         case USB_CDC_NOTIFY_SERIAL_STATE:
 308                 tty = tty_port_tty_get(&acm->port);
 309                 newctrl = get_unaligned_le16(data);
 310
 311                 if (tty) {
 312                         if (!acm->clocal &&
 313                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 314                                 dbg("calling hangup");
 315                                 tty_hangup(tty);
 316                         }
 317                         tty_kref_put(tty);
 318                 }
 319
 320                 acm->ctrlin = newctrl;
 321
 322                 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 323                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
 324                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 325                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
 326                         acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 327                         acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
 328                         acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 329                         acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 330                         break;
 331
 332         default:
 333                 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 334                         dr->bNotificationType, dr->wIndex,
 335                         dr->wLength, data[0], data[1]);
 336                 break;
 337         }
 338 exit:
 339         usb_mark_last_busy(acm->dev);
 340         retval = usb_submit_urb(urb, GFP_ATOMIC);
 341         if (retval)
 342                 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
 343                         "result %d", __func__, retval);
 344 }
 345
 346 /* data interface returns incoming bytes, or we got unthrottled */
 347 static void acm_read_bulk(struct urb *urb)
 348 {
 349         struct acm_rb *buf;
 350         struct acm_ru *rcv = urb->context;
 351         struct acm *acm = rcv->instance;
 352         int status = urb->status;
 353
 354         dbg("Entering acm_read_bulk with status %d", status);
 355
 356         if (!ACM_READY(acm)) {
 357                 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
 358                 return;
 359         }
 360         usb_mark_last_busy(acm->dev);
 361
 362         if (status)
 363                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
 364
 365         buf = rcv->buffer;
 366         buf->size = urb->actual_length;
 367
 368         if (likely(status == 0)) {
 369                 spin_lock(&acm->read_lock);
 370                 acm->processing++;
 371                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 372                 list_add_tail(&buf->list, &acm->filled_read_bufs);
 373                 spin_unlock(&acm->read_lock);
 374         } else {
 375                 /* we drop the buffer due to an error */
 376                 spin_lock(&acm->read_lock);
 377                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 378                 list_add(&buf->list, &acm->spare_read_bufs);
 379                 spin_unlock(&acm->read_lock);
 380                 /* nevertheless the tasklet must be kicked unconditionally
 381                 so the queue cannot dry up */
 382         }
 383         if (likely(!acm->susp_count))
 384                 tasklet_schedule(&acm->urb_task);
 385 }
 386
 387 static void acm_rx_tasklet(unsigned long _acm)
 388 {
 389         struct acm *acm = (void *)_acm;
 390         struct acm_rb *buf;
 391         struct tty_struct *tty;
 392         struct acm_ru *rcv;
 393         unsigned long flags;
 394         unsigned char throttled;
 395
 396         dbg("Entering acm_rx_tasklet");
 397
 398         if (!ACM_READY(acm)) {
 399                 dbg("acm_rx_tasklet: ACM not ready");
 400                 return;
 401         }
 402
 403         spin_lock_irqsave(&acm->throttle_lock, flags);
 404         throttled = acm->throttle;
 405         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 406         if (throttled) {
 407                 dbg("acm_rx_tasklet: throttled");
 408                 return;
 409         }
 410
 411         tty = tty_port_tty_get(&acm->port);
 412
 413 next_buffer:
 414         spin_lock_irqsave(&acm->read_lock, flags);
 415         if (list_empty(&acm->filled_read_bufs)) {
 416                 spin_unlock_irqrestore(&acm->read_lock, flags);
 417                 goto urbs;
 418         }
 419         buf = list_entry(acm->filled_read_bufs.next,
 420                          struct acm_rb, list);
 421         list_del(&buf->list);
 422         spin_unlock_irqrestore(&acm->read_lock, flags);
 423
 424         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 425
 426         if (tty) {
 427                 spin_lock_irqsave(&acm->throttle_lock, flags);
 428                 throttled = acm->throttle;
 429                 spin_unlock_irqrestore(&acm->throttle_lock, flags);
 430                 if (!throttled) {
 431                         tty_insert_flip_string(tty, buf->base, buf->size);
 432                         tty_flip_buffer_push(tty);
 433                 } else {
 434                         tty_kref_put(tty);
 435                         dbg("Throttling noticed");
 436                         spin_lock_irqsave(&acm->read_lock, flags);
 437                         list_add(&buf->list, &acm->filled_read_bufs);
 438                         spin_unlock_irqrestore(&acm->read_lock, flags);
 439                         return;
 440                 }
 441         }
 442
 443         spin_lock_irqsave(&acm->read_lock, flags);
 444         list_add(&buf->list, &acm->spare_read_bufs);
 445         spin_unlock_irqrestore(&acm->read_lock, flags);
 446         goto next_buffer;
 447
 448 urbs:
 449         tty_kref_put(tty);
 450
 451         while (!list_empty(&acm->spare_read_bufs)) {
 452                 spin_lock_irqsave(&acm->read_lock, flags);
 453                 if (list_empty(&acm->spare_read_urbs)) {
 454                         acm->processing = 0;
 455                         spin_unlock_irqrestore(&acm->read_lock, flags);
 456                         return;
 457                 }
 458                 rcv = list_entry(acm->spare_read_urbs.next,
 459                                  struct acm_ru, list);
 460                 list_del(&rcv->list);
 461                 spin_unlock_irqrestore(&acm->read_lock, flags);
 462
 463                 buf = list_entry(acm->spare_read_bufs.next,
 464                                  struct acm_rb, list);
 465                 list_del(&buf->list);
 466
 467                 rcv->buffer = buf;
 468
 469                 if (acm->is_int_ep)
 470                         usb_fill_int_urb(rcv->urb, acm->dev,
 471                                          acm->rx_endpoint,
 472                                          buf->base,
 473                                          acm->readsize,
 474                                          acm_read_bulk, rcv, acm->bInterval);
 475                 else
 476                         usb_fill_bulk_urb(rcv->urb, acm->dev,
 477                                           acm->rx_endpoint,
 478                                           buf->base,
 479                                           acm->readsize,
 480                                           acm_read_bulk, rcv);
 481                 rcv->urb->transfer_dma = buf->dma;
 482                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 483
 484                 /* This shouldn't kill the driver as unsuccessful URBs are
 485                    returned to the free-urbs-pool and resubmited ASAP */
 486                 spin_lock_irqsave(&acm->read_lock, flags);
 487                 if (acm->susp_count ||
 488                                 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 489                         list_add(&buf->list, &acm->spare_read_bufs);
 490                         list_add(&rcv->list, &acm->spare_read_urbs);
 491                         acm->processing = 0;
 492                         spin_unlock_irqrestore(&acm->read_lock, flags);
 493                         return;
 494                 } else {
 495                         spin_unlock_irqrestore(&acm->read_lock, flags);
 496                         dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 497                 }
 498         }
 499         spin_lock_irqsave(&acm->read_lock, flags);
 500         acm->processing = 0;
 501         spin_unlock_irqrestore(&acm->read_lock, flags);
 502 }
 503
 504 /* data interface wrote those outgoing bytes */
 505 static void acm_write_bulk(struct urb *urb)
 506 {
 507         struct acm_wb *wb = urb->context;
 508         struct acm *acm = wb->instance;
 509         unsigned long flags;
 510
 511         if (verbose || urb->status
 512                         || (urb->actual_length != urb->transfer_buffer_length))
 513                 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
 514                         urb->actual_length,
 515                         urb->transfer_buffer_length,
 516                         urb->status);
 517
 518         spin_lock_irqsave(&acm->write_lock, flags);
 519         acm_write_done(acm, wb);
 520         spin_unlock_irqrestore(&acm->write_lock, flags);
 521         if (ACM_READY(acm))
 522                 schedule_work(&acm->work);
 523         else
 524                 wake_up_interruptible(&acm->drain_wait);
 525 }
 526
 527 static void acm_softint(struct work_struct *work)
 528 {
 529         struct acm *acm = container_of(work, struct acm, work);
 530         struct tty_struct *tty;
 531
 532         dev_vdbg(&acm->data->dev, "tx work\n");
 533         if (!ACM_READY(acm))
 534                 return;
 535         tty = tty_port_tty_get(&acm->port);
 536         tty_wakeup(tty);
 537         tty_kref_put(tty);
 538 }
 539
 540 /*
 541  * TTY handlers
 542  */
 543
 544 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 545 {
 546         struct acm *acm;
 547         int rv = -ENODEV;
 548         int i;
 549         dbg("Entering acm_tty_open.");
 550
 551         mutex_lock(&open_mutex);
 552
 553         acm = acm_table[tty->index];
 554         if (!acm || !acm->dev)
 555                 goto out;
 556         else
 557                 rv = 0;
 558
 559         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 560
 561         tty->driver_data = acm;
 562         tty_port_tty_set(&acm->port, tty);
 563
 564         if (usb_autopm_get_interface(acm->control) < 0)
 565                 goto early_bail;
 566         else
 567                 acm->control->needs_remote_wakeup = 1;
 568
 569         mutex_lock(&acm->mutex);
 570         if (acm->port.count++) {
 571                 mutex_unlock(&acm->mutex);
 572                 usb_autopm_put_interface(acm->control);
 573                 goto out;
 574         }
 575
 576         acm->ctrlurb->dev = acm->dev;
 577         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 578                 dbg("usb_submit_urb(ctrl irq) failed");
 579                 goto bail_out;
 580         }
 581
 582         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 583             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 584                 goto full_bailout;
 585
 586         usb_autopm_put_interface(acm->control);
 587
 588         INIT_LIST_HEAD(&acm->spare_read_urbs);
 589         INIT_LIST_HEAD(&acm->spare_read_bufs);
 590         INIT_LIST_HEAD(&acm->filled_read_bufs);
 591
 592         for (i = 0; i < acm->rx_buflimit; i++)
 593                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 594         for (i = 0; i < acm->rx_buflimit; i++)
 595                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 596
 597         acm->throttle = 0;
 598
 599         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
 600         rv = tty_port_block_til_ready(&acm->port, tty, filp);
 601         tasklet_schedule(&acm->urb_task);
 602
 603         mutex_unlock(&acm->mutex);
 604 out:
 605         mutex_unlock(&open_mutex);
 606         return rv;
 607
 608 full_bailout:
 609         usb_kill_urb(acm->ctrlurb);
 610 bail_out:
 611         acm->port.count--;
 612         mutex_unlock(&acm->mutex);
 613         usb_autopm_put_interface(acm->control);
 614 early_bail:
 615         mutex_unlock(&open_mutex);
 616         tty_port_tty_set(&acm->port, NULL);
 617         return -EIO;
 618 }
 619
 620 static void acm_tty_unregister(struct acm *acm)
 621 {
 622         int i, nr;
 623
 624         nr = acm->rx_buflimit;
 625         tty_unregister_device(acm_tty_driver, acm->minor);
 626         usb_put_intf(acm->control);
 627         acm_table[acm->minor] = NULL;
 628         usb_free_urb(acm->ctrlurb);
 629         for (i = 0; i < ACM_NW; i++)
 630                 usb_free_urb(acm->wb[i].urb);
 631         for (i = 0; i < nr; i++)
 632                 usb_free_urb(acm->ru[i].urb);
 633         kfree(acm->country_codes);
 634         kfree(acm);
 635 }
 636
 637 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
 638
 639 static void acm_port_down(struct acm *acm)
 640 {
 641         int i, nr = acm->rx_buflimit;
 642         mutex_lock(&open_mutex);
 643         if (acm->dev) {
 644                 usb_autopm_get_interface(acm->control);
 645                 acm_set_control(acm, acm->ctrlout = 0);
 646                 usb_kill_urb(acm->ctrlurb);
 647                 for (i = 0; i < ACM_NW; i++)
 648                         usb_kill_urb(acm->wb[i].urb);
 649                 for (i = 0; i < nr; i++)
 650                         usb_kill_urb(acm->ru[i].urb);
 651                 acm->control->needs_remote_wakeup = 0;
 652                 usb_autopm_put_interface(acm->control);
 653         }
 654         mutex_unlock(&open_mutex);
 655 }
 656
 657 static void acm_tty_hangup(struct tty_struct *tty)
 658 {
 659         struct acm *acm = tty->driver_data;
 660         tty_port_hangup(&acm->port);
 661         acm_port_down(acm);
 662 }
 663
 664 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 665 {
 666         struct acm *acm = tty->driver_data;
 667
 668         /* Perform the closing process and see if we need to do the hardware
 669            shutdown */
 670         if (!acm)
 671                 return;
 672         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
 673                 mutex_lock(&open_mutex);
 674                 if (!acm->dev) {
 675                         tty_port_tty_set(&acm->port, NULL);
 676                         acm_tty_unregister(acm);
 677                         tty->driver_data = NULL;
 678                 }
 679                 mutex_unlock(&open_mutex);
 680                 return;
 681         }
 682         acm_port_down(acm);
 683         tty_port_close_end(&acm->port, tty);
 684         tty_port_tty_set(&acm->port, NULL);
 685 }
 686
 687 static int acm_tty_write(struct tty_struct *tty,
 688                                         const unsigned char *buf, int count)
 689 {
 690         struct acm *acm = tty->driver_data;
 691         int stat;
 692         unsigned long flags;
 693         int wbn;
 694         struct acm_wb *wb;
 695
 696         dbg("Entering acm_tty_write to write %d bytes,", count);
 697
 698         if (!ACM_READY(acm))
 699                 return -EINVAL;
 700         if (!count)
 701                 return 0;
 702
 703         spin_lock_irqsave(&acm->write_lock, flags);
 704         wbn = acm_wb_alloc(acm);
 705         if (wbn < 0) {
 706                 spin_unlock_irqrestore(&acm->write_lock, flags);
 707                 return 0;
 708         }
 709         wb = &acm->wb[wbn];
 710
 711         count = (count > acm->writesize) ? acm->writesize : count;
 712         dbg("Get %d bytes...", count);
 713         memcpy(wb->buf, buf, count);
 714         wb->len = count;
 715         spin_unlock_irqrestore(&acm->write_lock, flags);
 716
 717         stat = acm_write_start(acm, wbn);
 718         if (stat < 0)
 719                 return stat;
 720         return count;
 721 }
 722
 723 static int acm_tty_write_room(struct tty_struct *tty)
 724 {
 725         struct acm *acm = tty->driver_data;
 726         if (!ACM_READY(acm))
 727                 return -EINVAL;
 728         /*
 729          * Do not let the line discipline to know that we have a reserve,
 730          * or it might get too enthusiastic.
 731          */
 732         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 733 }
 734
 735 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 736 {
 737         struct acm *acm = tty->driver_data;
 738         if (!ACM_READY(acm))
 739                 return 0;
 740         /*
 741          * This is inaccurate (overcounts), but it works.
 742          */
 743         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 744 }
 745
 746 static void acm_tty_throttle(struct tty_struct *tty)
 747 {
 748         struct acm *acm = tty->driver_data;
 749         if (!ACM_READY(acm))
 750                 return;
 751         spin_lock_bh(&acm->throttle_lock);
 752         acm->throttle = 1;
 753         spin_unlock_bh(&acm->throttle_lock);
 754 }
 755
 756 static void acm_tty_unthrottle(struct tty_struct *tty)
 757 {
 758         struct acm *acm = tty->driver_data;
 759         if (!ACM_READY(acm))
 760                 return;
 761         spin_lock_bh(&acm->throttle_lock);
 762         acm->throttle = 0;
 763         spin_unlock_bh(&acm->throttle_lock);
 764         tasklet_schedule(&acm->urb_task);
 765 }
 766
 767 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 768 {
 769         struct acm *acm = tty->driver_data;
 770         int retval;
 771         if (!ACM_READY(acm))
 772                 return -EINVAL;
 773         retval = acm_send_break(acm, state ? 0xffff : 0);
 774         if (retval < 0)
 775                 dbg("send break failed");
 776         return retval;
 777 }
 778
 779 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 780 {
 781         struct acm *acm = tty->driver_data;
 782
 783         if (!ACM_READY(acm))
 784                 return -EINVAL;
 785
 786         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 787                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 788                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 789                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 790                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 791                TIOCM_CTS;
 792 }
 793
 794 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 795                             unsigned int set, unsigned int clear)
 796 {
 797         struct acm *acm = tty->driver_data;
 798         unsigned int newctrl;
 799
 800         if (!ACM_READY(acm))
 801                 return -EINVAL;
 802
 803         newctrl = acm->ctrlout;
 804         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 805                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 806         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 807                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 808
 809         newctrl = (newctrl & ~clear) | set;
 810
 811         if (acm->ctrlout == newctrl)
 812                 return 0;
 813         return acm_set_control(acm, acm->ctrlout = newctrl);
 814 }
 815
 816 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
 817                                         unsigned int cmd, unsigned long arg)
 818 {
 819         struct acm *acm = tty->driver_data;
 820
 821         if (!ACM_READY(acm))
 822                 return -EINVAL;
 823
 824         return -ENOIOCTLCMD;
 825 }
 826
 827 static const __u32 acm_tty_speed[] = {
 828         0, 50, 75, 110, 134, 150, 200, 300, 600,
 829         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 830         57600, 115200, 230400, 460800, 500000, 576000,
 831         921600, 1000000, 1152000, 1500000, 2000000,
 832         2500000, 3000000, 3500000, 4000000
 833 };
 834
 835 static const __u8 acm_tty_size[] = {
 836         5, 6, 7, 8
 837 };
 838
 839 static void acm_tty_set_termios(struct tty_struct *tty,
 840                                                 struct ktermios *termios_old)
 841 {
 842         struct acm *acm = tty->driver_data;
 843         struct ktermios *termios = tty->termios;
 844         struct usb_cdc_line_coding newline;
 845         int newctrl = acm->ctrlout;
 846
 847         if (!ACM_READY(acm))
 848                 return;
 849
 850         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 851         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 852         newline.bParityType = termios->c_cflag & PARENB ?
 853                                 (termios->c_cflag & PARODD ? 1 : 2) +
 854                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 855         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 856         /* FIXME: Needs to clear unsupported bits in the termios */
 857         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 858
 859         if (!newline.dwDTERate) {
 860                 newline.dwDTERate = acm->line.dwDTERate;
 861                 newctrl &= ~ACM_CTRL_DTR;
 862         } else
 863                 newctrl |=  ACM_CTRL_DTR;
 864
 865         if (newctrl != acm->ctrlout)
 866                 acm_set_control(acm, acm->ctrlout = newctrl);
 867
 868         if (memcmp(&acm->line, &newline, sizeof newline)) {
 869                 memcpy(&acm->line, &newline, sizeof newline);
 870                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 871                         newline.bCharFormat, newline.bParityType,
 872                         newline.bDataBits);
 873                 acm_set_line(acm, &acm->line);
 874         }
 875 }
 876
 877 /*
 878  * USB probe and disconnect routines.
 879  */
 880
 881 /* Little helpers: write/read buffers free */
 882 static void acm_write_buffers_free(struct acm *acm)
 883 {
 884         int i;
 885         struct acm_wb *wb;
 886         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 887
 888         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 889                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 890 }
 891
 892 static void acm_read_buffers_free(struct acm *acm)
 893 {
 894         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 895         int i, n = acm->rx_buflimit;
 896
 897         for (i = 0; i < n; i++)
 898                 usb_free_coherent(usb_dev, acm->readsize,
 899                                   acm->rb[i].base, acm->rb[i].dma);
 900 }
 901
 902 /* Little helper: write buffers allocate */
 903 static int acm_write_buffers_alloc(struct acm *acm)
 904 {
 905         int i;
 906         struct acm_wb *wb;
 907
 908         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 909                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 910                     &wb->dmah);
 911                 if (!wb->buf) {
 912                         while (i != 0) {
 913                                 --i;
 914                                 --wb;
 915                                 usb_free_coherent(acm->dev, acm->writesize,
 916                                     wb->buf, wb->dmah);
 917                         }
 918                         return -ENOMEM;
 919                 }
 920         }
 921         return 0;
 922 }
 923
 924 static int acm_probe(struct usb_interface *intf,
 925                      const struct usb_device_id *id)
 926 {
 927         struct usb_cdc_union_desc *union_header = NULL;
 928         struct usb_cdc_country_functional_desc *cfd = NULL;
 929         unsigned char *buffer = intf->altsetting->extra;
 930         int buflen = intf->altsetting->extralen;
 931         struct usb_interface *control_interface;
 932         struct usb_interface *data_interface;
 933         struct usb_endpoint_descriptor *epctrl = NULL;
 934         struct usb_endpoint_descriptor *epread = NULL;
 935         struct usb_endpoint_descriptor *epwrite = NULL;
 936         struct usb_device *usb_dev = interface_to_usbdev(intf);
 937         struct acm *acm;
 938         int minor;
 939         int ctrlsize, readsize;
 940         u8 *buf;
 941         u8 ac_management_function = 0;
 942         u8 call_management_function = 0;
 943         int call_interface_num = -1;
 944         int data_interface_num;
 945         unsigned long quirks;
 946         int num_rx_buf;
 947         int i;
 948         int combined_interfaces = 0;
 949
 950         /* normal quirks */
 951         quirks = (unsigned long)id->driver_info;
 952         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 953
 954         /* handle quirks deadly to normal probing*/
 955         if (quirks == NO_UNION_NORMAL) {
 956                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 957                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 958                 goto skip_normal_probe;
 959         }
 960
 961         /* normal probing*/
 962         if (!buffer) {
 963                 dev_err(&intf->dev, "Weird descriptor references\n");
 964                 return -EINVAL;
 965         }
 966
 967         if (!buflen) {
 968                 if (intf->cur_altsetting->endpoint->extralen &&
 969                                 intf->cur_altsetting->endpoint->extra) {
 970                         dev_dbg(&intf->dev,
 971                                 "Seeking extra descriptors on endpoint\n");
 972                         buflen = intf->cur_altsetting->endpoint->extralen;
 973                         buffer = intf->cur_altsetting->endpoint->extra;
 974                 } else {
 975                         dev_err(&intf->dev,
 976                                 "Zero length descriptor references\n");
 977                         return -EINVAL;
 978                 }
 979         }
 980
 981         while (buflen > 0) {
 982                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 983                         dev_err(&intf->dev, "skipping garbage\n");
 984                         goto next_desc;
 985                 }
 986
 987                 switch (buffer[2]) {
 988                 case USB_CDC_UNION_TYPE: /* we've found it */
 989                         if (union_header) {
 990                                 dev_err(&intf->dev, "More than one "
 991                                         "union descriptor, skipping ...\n");
 992                                 goto next_desc;
 993                         }
 994                         union_header = (struct usb_cdc_union_desc *)buffer;
 995                         break;
 996                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 997                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
 998                         break;
 999                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1000                         break; /* for now we ignore it */
1001                 case USB_CDC_ACM_TYPE:
1002                         ac_management_function = buffer[3];
1003                         break;
1004                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1005                         call_management_function = buffer[3];
1006                         call_interface_num = buffer[4];
1007                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1008                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1009                         break;
1010                 default:
1011                         /* there are LOTS more CDC descriptors that
1012                          * could legitimately be found here.
1013                          */
1014                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1015                                         "type %02x, length %d\n",
1016                                         buffer[2], buffer[0]);
1017                         break;
1018                 }
1019 next_desc:
1020                 buflen -= buffer[0];
1021                 buffer += buffer[0];
1022         }
1023
1024         if (!union_header) {
1025                 if (call_interface_num > 0) {
1026                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1027                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1028                         control_interface = intf;
1029                 } else {
1030                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1031                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1032                                 return -ENODEV;
1033                         } else {
1034                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1035                                 combined_interfaces = 1;
1036                                 control_interface = data_interface = intf;
1037                                 goto look_for_collapsed_interface;
1038                         }
1039                 }
1040         } else {
1041                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1042                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1043                 if (!control_interface || !data_interface) {
1044                         dev_dbg(&intf->dev, "no interfaces\n");
1045                         return -ENODEV;
1046                 }
1047         }
1048
1049         if (data_interface_num != call_interface_num)
1050                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1051
1052         if (control_interface == data_interface) {
1053                 /* some broken devices designed for windows work this way */
1054                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1055                 combined_interfaces = 1;
1056                 /* a popular other OS doesn't use it */
1057                 quirks |= NO_CAP_LINE;
1058                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1059                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1060                         return -EINVAL;
1061                 }
1062 look_for_collapsed_interface:
1063                 for (i = 0; i < 3; i++) {
1064                         struct usb_endpoint_descriptor *ep;
1065                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1066
1067                         if (usb_endpoint_is_int_in(ep))
1068                                 epctrl = ep;
1069                         else if (usb_endpoint_is_bulk_out(ep))
1070                                 epwrite = ep;
1071                         else if (usb_endpoint_is_bulk_in(ep))
1072                                 epread = ep;
1073                         else
1074                                 return -EINVAL;
1075                 }
1076                 if (!epctrl || !epread || !epwrite)
1077                         return -ENODEV;
1078                 else
1079                         goto made_compressed_probe;
1080         }
1081
1082 skip_normal_probe:
1083
1084         /*workaround for switched interfaces */
1085         if (data_interface->cur_altsetting->desc.bInterfaceClass
1086                                                 != CDC_DATA_INTERFACE_TYPE) {
1087                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1088                                                 == CDC_DATA_INTERFACE_TYPE) {
1089                         struct usb_interface *t;
1090                         dev_dbg(&intf->dev,
1091                                 "Your device has switched interfaces.\n");
1092                         t = control_interface;
1093                         control_interface = data_interface;
1094                         data_interface = t;
1095                 } else {
1096                         return -EINVAL;
1097                 }
1098         }
1099
1100         /* Accept probe requests only for the control interface */
1101         if (!combined_interfaces && intf != control_interface)
1102                 return -ENODEV;
1103
1104         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1105                 /* valid in this context */
1106                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1107                 return -EBUSY;
1108         }
1109
1110
1111         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1112                 return -EINVAL;
1113
1114         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1115         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1116         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1117
1118
1119         /* workaround for switched endpoints */
1120         if (!usb_endpoint_dir_in(epread)) {
1121                 /* descriptors are swapped */
1122                 struct usb_endpoint_descriptor *t;
1123                 dev_dbg(&intf->dev,
1124                         "The data interface has switched endpoints\n");
1125                 t = epread;
1126                 epread = epwrite;
1127                 epwrite = t;
1128         }
1129 made_compressed_probe:
1130         dbg("interfaces are valid");
1131         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1132
1133         if (minor == ACM_TTY_MINORS) {
1134                 dev_err(&intf->dev, "no more free acm devices\n");
1135                 return -ENODEV;
1136         }
1137
1138         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1139         if (acm == NULL) {
1140                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1141                 goto alloc_fail;
1142         }
1143
1144         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1145         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1146                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1147         acm->combined_interfaces = combined_interfaces;
1148         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1149         acm->control = control_interface;
1150         acm->data = data_interface;
1151         acm->minor = minor;
1152         acm->dev = usb_dev;
1153         acm->ctrl_caps = ac_management_function;
1154         if (quirks & NO_CAP_LINE)
1155                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1156         acm->ctrlsize = ctrlsize;
1157         acm->readsize = readsize;
1158         acm->rx_buflimit = num_rx_buf;
1159         acm->urb_task.func = acm_rx_tasklet;
1160         acm->urb_task.data = (unsigned long) acm;
1161         INIT_WORK(&acm->work, acm_softint);
1162         init_waitqueue_head(&acm->drain_wait);
1163         spin_lock_init(&acm->throttle_lock);
1164         spin_lock_init(&acm->write_lock);
1165         spin_lock_init(&acm->read_lock);
1166         mutex_init(&acm->mutex);
1167         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1168         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1169         if (acm->is_int_ep)
1170                 acm->bInterval = epread->bInterval;
1171         tty_port_init(&acm->port);
1172         acm->port.ops = &acm_port_ops;
1173
1174         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1175         if (!buf) {
1176                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1177                 goto alloc_fail2;
1178         }
1179         acm->ctrl_buffer = buf;
1180
1181         if (acm_write_buffers_alloc(acm) < 0) {
1182                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1183                 goto alloc_fail4;
1184         }
1185
1186         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1187         if (!acm->ctrlurb) {
1188                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1189                 goto alloc_fail5;
1190         }
1191         for (i = 0; i < num_rx_buf; i++) {
1192                 struct acm_ru *rcv = &(acm->ru[i]);
1193
1194                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1195                 if (rcv->urb == NULL) {
1196                         dev_dbg(&intf->dev,
1197                                 "out of memory (read urbs usb_alloc_urb)\n");
1198                         goto alloc_fail6;
1199                 }
1200
1201                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1202                 rcv->instance = acm;
1203         }
1204         for (i = 0; i < num_rx_buf; i++) {
1205                 struct acm_rb *rb = &(acm->rb[i]);
1206
1207                 rb->base = usb_alloc_coherent(acm->dev, readsize,
1208                                 GFP_KERNEL, &rb->dma);
1209                 if (!rb->base) {
1210                         dev_dbg(&intf->dev,
1211                                 "out of memory (read bufs usb_alloc_coherent)\n");
1212                         goto alloc_fail7;
1213                 }
1214         }
1215         for (i = 0; i < ACM_NW; i++) {
1216                 struct acm_wb *snd = &(acm->wb[i]);
1217
1218                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1219                 if (snd->urb == NULL) {
1220                         dev_dbg(&intf->dev,
1221                                 "out of memory (write urbs usb_alloc_urb)");
1222                         goto alloc_fail8;
1223                 }
1224
1225                 if (usb_endpoint_xfer_int(epwrite))
1226                         usb_fill_int_urb(snd->urb, usb_dev,
1227                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1228                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1229                 else
1230                         usb_fill_bulk_urb(snd->urb, usb_dev,
1231                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1232                                 NULL, acm->writesize, acm_write_bulk, snd);
1233                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1234                 snd->instance = acm;
1235         }
1236
1237         usb_set_intfdata(intf, acm);
1238
1239         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1240         if (i < 0)
1241                 goto alloc_fail8;
1242
1243         if (cfd) { /* export the country data */
1244                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1245                 if (!acm->country_codes)
1246                         goto skip_countries;
1247                 acm->country_code_size = cfd->bLength - 4;
1248                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1249                                                         cfd->bLength - 4);
1250                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1251
1252                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1253                 if (i < 0) {
1254                         kfree(acm->country_codes);
1255                         goto skip_countries;
1256                 }
1257
1258                 i = device_create_file(&intf->dev,
1259                                                 &dev_attr_iCountryCodeRelDate);
1260                 if (i < 0) {
1261                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1262                         kfree(acm->country_codes);
1263                         goto skip_countries;
1264                 }
1265         }
1266
1267 skip_countries:
1268         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1269                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1270                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1271                          /* works around buggy devices */
1272                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1273         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1274         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1275
1276         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1277
1278         acm_set_control(acm, acm->ctrlout);
1279
1280         acm->line.dwDTERate = cpu_to_le32(9600);
1281         acm->line.bDataBits = 8;
1282         acm_set_line(acm, &acm->line);
1283
1284         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1285         usb_set_intfdata(data_interface, acm);
1286
1287         usb_get_intf(control_interface);
1288         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1289
1290         acm_table[minor] = acm;
1291
1292         return 0;
1293 alloc_fail8:
1294         for (i = 0; i < ACM_NW; i++)
1295                 usb_free_urb(acm->wb[i].urb);
1296 alloc_fail7:
1297         acm_read_buffers_free(acm);
1298 alloc_fail6:
1299         for (i = 0; i < num_rx_buf; i++)
1300                 usb_free_urb(acm->ru[i].urb);
1301         usb_free_urb(acm->ctrlurb);
1302 alloc_fail5:
1303         acm_write_buffers_free(acm);
1304 alloc_fail4:
1305         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1306 alloc_fail2:
1307         kfree(acm);
1308 alloc_fail:
1309         return -ENOMEM;
1310 }
1311
1312 static void stop_data_traffic(struct acm *acm)
1313 {
1314         int i;
1315         dbg("Entering stop_data_traffic");
1316
1317         tasklet_disable(&acm->urb_task);
1318
1319         usb_kill_urb(acm->ctrlurb);
1320         for (i = 0; i < ACM_NW; i++)
1321                 usb_kill_urb(acm->wb[i].urb);
1322         for (i = 0; i < acm->rx_buflimit; i++)
1323                 usb_kill_urb(acm->ru[i].urb);
1324
1325         tasklet_enable(&acm->urb_task);
1326
1327         cancel_work_sync(&acm->work);
1328 }
1329
1330 static void acm_disconnect(struct usb_interface *intf)
1331 {
1332         struct acm *acm = usb_get_intfdata(intf);
1333         struct usb_device *usb_dev = interface_to_usbdev(intf);
1334         struct tty_struct *tty;
1335
1336         /* sibling interface is already cleaning up */
1337         if (!acm)
1338                 return;
1339
1340         mutex_lock(&open_mutex);
1341         if (acm->country_codes) {
1342                 device_remove_file(&acm->control->dev,
1343                                 &dev_attr_wCountryCodes);
1344                 device_remove_file(&acm->control->dev,
1345                                 &dev_attr_iCountryCodeRelDate);
1346         }
1347         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1348         acm->dev = NULL;
1349         usb_set_intfdata(acm->control, NULL);
1350         usb_set_intfdata(acm->data, NULL);
1351
1352         stop_data_traffic(acm);
1353
1354         acm_write_buffers_free(acm);
1355         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1356                           acm->ctrl_dma);
1357         acm_read_buffers_free(acm);
1358
1359         if (!acm->combined_interfaces)
1360                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1361                                         acm->data : acm->control);
1362
1363         if (acm->port.count == 0) {
1364                 acm_tty_unregister(acm);
1365                 mutex_unlock(&open_mutex);
1366                 return;
1367         }
1368
1369         mutex_unlock(&open_mutex);
1370         tty = tty_port_tty_get(&acm->port);
1371         if (tty) {
1372                 tty_hangup(tty);
1373                 tty_kref_put(tty);
1374         }
1375 }
1376
1377 #ifdef CONFIG_PM
1378 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1379 {
1380         struct acm *acm = usb_get_intfdata(intf);
1381         int cnt;
1382
1383         if (message.event & PM_EVENT_AUTO) {
1384                 int b;
1385
1386                 spin_lock_irq(&acm->read_lock);
1387                 spin_lock(&acm->write_lock);
1388                 b = acm->processing + acm->transmitting;
1389                 spin_unlock(&acm->write_lock);
1390                 spin_unlock_irq(&acm->read_lock);
1391                 if (b)
1392                         return -EBUSY;
1393         }
1394
1395         spin_lock_irq(&acm->read_lock);
1396         spin_lock(&acm->write_lock);
1397         cnt = acm->susp_count++;
1398         spin_unlock(&acm->write_lock);
1399         spin_unlock_irq(&acm->read_lock);
1400
1401         if (cnt)
1402                 return 0;
1403         /*
1404         we treat opened interfaces differently,
1405         we must guard against open
1406         */
1407         mutex_lock(&acm->mutex);
1408
1409         if (acm->port.count)
1410                 stop_data_traffic(acm);
1411
1412         mutex_unlock(&acm->mutex);
1413         return 0;
1414 }
1415
1416 static int acm_resume(struct usb_interface *intf)
1417 {
1418         struct acm *acm = usb_get_intfdata(intf);
1419         struct acm_wb *wb;
1420         int rv = 0;
1421         int cnt;
1422
1423         spin_lock_irq(&acm->read_lock);
1424         acm->susp_count -= 1;
1425         cnt = acm->susp_count;
1426         spin_unlock_irq(&acm->read_lock);
1427
1428         if (cnt)
1429                 return 0;
1430
1431         mutex_lock(&acm->mutex);
1432         if (acm->port.count) {
1433                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1434
1435                 spin_lock_irq(&acm->write_lock);
1436                 if (acm->delayed_wb) {
1437                         wb = acm->delayed_wb;
1438                         acm->delayed_wb = NULL;
1439                         spin_unlock_irq(&acm->write_lock);
1440                         acm_start_wb(acm, wb);
1441                 } else {
1442                         spin_unlock_irq(&acm->write_lock);
1443                 }
1444
1445                 /*
1446                  * delayed error checking because we must
1447                  * do the write path at all cost
1448                  */
1449                 if (rv < 0)
1450                         goto err_out;
1451
1452                 tasklet_schedule(&acm->urb_task);
1453         }
1454
1455 err_out:
1456         mutex_unlock(&acm->mutex);
1457         return rv;
1458 }
1459
1460 static int acm_reset_resume(struct usb_interface *intf)
1461 {
1462         struct acm *acm = usb_get_intfdata(intf);
1463         struct tty_struct *tty;
1464
1465         mutex_lock(&acm->mutex);
1466         if (acm->port.count) {
1467                 tty = tty_port_tty_get(&acm->port);
1468                 if (tty) {
1469                         tty_hangup(tty);
1470                         tty_kref_put(tty);
1471                 }
1472         }
1473         mutex_unlock(&acm->mutex);
1474         return acm_resume(intf);
1475 }
1476
1477 #endif /* CONFIG_PM */
1478
1479 #define NOKIA_PCSUITE_ACM_INFO(x) \
1480                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1481                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1482                 USB_CDC_ACM_PROTO_VENDOR)
1483
1484 /*
1485  * USB driver structure.
1486  */
1487
1488 static const struct usb_device_id acm_ids[] = {
1489         /* quirky and broken devices */
1490         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1491         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1492         },
1493         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1494         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1495         },
1496         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1497         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1498         },
1499         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1500         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1501         },
1502         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1503         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1504         },
1505         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1506         .driver_info = SINGLE_RX_URB,
1507         },
1508         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1509         .driver_info = SINGLE_RX_URB, /* firmware bug */
1510         },
1511         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1512         .driver_info = SINGLE_RX_URB, /* firmware bug */
1513         },
1514         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1515         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1516         },
1517         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1518         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1519         },
1520         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1521         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1522         },
1523         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1524         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1525         },
1526         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1527         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1528         },
1529         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1530         },
1531         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1532         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1533                                            data interface instead of
1534                                            communications interface.
1535                                            Maybe we should define a new
1536                                            quirk for this. */
1537         },
1538         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1539         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1540         },
1541         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1542         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1543         },
1544
1545         /* Nokia S60 phones expose two ACM channels. The first is
1546          * a modem and is picked up by the standard AT-command
1547          * information below. The second is 'vendor-specific' but
1548          * is treated as a serial device at the S60 end, so we want
1549          * to expose it on Linux too. */
1550         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1551         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1552         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1553         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1554         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1556         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1557         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1558         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1559         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1561         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1562         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1563         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1564         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1565         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1567         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1568         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1569         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1570         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1571         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1573         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1574         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1575         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1576         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1577         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1578         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1579         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1580         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1581         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1582         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1583         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1584         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1585         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1586         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1587         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1588         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1589         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1590         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1591         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1592         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1593         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1594
1595         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1596
1597         /* Support Lego NXT using pbLua firmware */
1598         { USB_DEVICE(0x0694, 0xff00),
1599         .driver_info = NOT_A_MODEM,
1600         },
1601
1602         /* control interfaces with various AT-command sets */
1603         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1604                 USB_CDC_ACM_PROTO_AT_V25TER) },
1605         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1606                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1607         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1608                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1609         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1610                 USB_CDC_ACM_PROTO_AT_GSM) },
1611         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1612                 USB_CDC_ACM_PROTO_AT_3G) },
1613         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1614                 USB_CDC_ACM_PROTO_AT_CDMA) },
1615
1616         { }
1617 };
1618
1619 MODULE_DEVICE_TABLE(usb, acm_ids);
1620
1621 static struct usb_driver acm_driver = {
1622         .name =         "cdc_acm",
1623         .probe =        acm_probe,
1624         .disconnect =   acm_disconnect,
1625 #ifdef CONFIG_PM
1626         .suspend =      acm_suspend,
1627         .resume =       acm_resume,
1628         .reset_resume = acm_reset_resume,
1629 #endif
1630         .id_table =     acm_ids,
1631 #ifdef CONFIG_PM
1632         .supports_autosuspend = 1,
1633 #endif
1634 };
1635
1636 /*
1637  * TTY driver structures.
1638  */
1639
1640 static const struct tty_operations acm_ops = {
1641         .open =                 acm_tty_open,
1642         .close =                acm_tty_close,
1643         .hangup =               acm_tty_hangup,
1644         .write =                acm_tty_write,
1645         .write_room =           acm_tty_write_room,
1646         .ioctl =                acm_tty_ioctl,
1647         .throttle =             acm_tty_throttle,
1648         .unthrottle =           acm_tty_unthrottle,
1649         .chars_in_buffer =      acm_tty_chars_in_buffer,
1650         .break_ctl =            acm_tty_break_ctl,
1651         .set_termios =          acm_tty_set_termios,
1652         .tiocmget =             acm_tty_tiocmget,
1653         .tiocmset =             acm_tty_tiocmset,
1654 };
1655
1656 /*
1657  * Init / exit.
1658  */
1659
1660 static int __init acm_init(void)
1661 {
1662         int retval;
1663         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1664         if (!acm_tty_driver)
1665                 return -ENOMEM;
1666         acm_tty_driver->owner = THIS_MODULE,
1667         acm_tty_driver->driver_name = "acm",
1668         acm_tty_driver->name = "ttyACM",
1669         acm_tty_driver->major = ACM_TTY_MAJOR,
1670         acm_tty_driver->minor_start = 0,
1671         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1672         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1673         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1674         acm_tty_driver->init_termios = tty_std_termios;
1675         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1676                                                                 HUPCL | CLOCAL;
1677         tty_set_operations(acm_tty_driver, &acm_ops);
1678
1679         retval = tty_register_driver(acm_tty_driver);
1680         if (retval) {
1681                 put_tty_driver(acm_tty_driver);
1682                 return retval;
1683         }
1684
1685         retval = usb_register(&acm_driver);
1686         if (retval) {
1687                 tty_unregister_driver(acm_tty_driver);
1688                 put_tty_driver(acm_tty_driver);
1689                 return retval;
1690         }
1691
1692         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1693                DRIVER_DESC "\n");
1694
1695         return 0;
1696 }
1697
1698 static void __exit acm_exit(void)
1699 {
1700         usb_deregister(&acm_driver);
1701         tty_unregister_driver(acm_tty_driver);
1702         put_tty_driver(acm_tty_driver);
1703 }
1704
1705 module_init(acm_init);
1706 module_exit(acm_exit);
1707
1708 MODULE_AUTHOR(DRIVER_AUTHOR);
1709 MODULE_DESCRIPTION(DRIVER_DESC);
1710 MODULE_LICENSE("GPL");
1711 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);