drivers/usb/class/cdc-acm.c

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