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/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_buffer_request_room(tty, buf->size);
 432                         tty_insert_flip_string(tty, buf->base, buf->size);
 433                         tty_flip_buffer_push(tty);
 434                 } else {
 435                         tty_kref_put(tty);
 436                         dbg("Throttling noticed");
 437                         spin_lock_irqsave(&acm->read_lock, flags);
 438                         list_add(&buf->list, &acm->filled_read_bufs);
 439                         spin_unlock_irqrestore(&acm->read_lock, flags);
 440                         return;
 441                 }
 442         }
 443
 444         spin_lock_irqsave(&acm->read_lock, flags);
 445         list_add(&buf->list, &acm->spare_read_bufs);
 446         spin_unlock_irqrestore(&acm->read_lock, flags);
 447         goto next_buffer;
 448
 449 urbs:
 450         tty_kref_put(tty);
 451
 452         while (!list_empty(&acm->spare_read_bufs)) {
 453                 spin_lock_irqsave(&acm->read_lock, flags);
 454                 if (list_empty(&acm->spare_read_urbs)) {
 455                         acm->processing = 0;
 456                         spin_unlock_irqrestore(&acm->read_lock, flags);
 457                         return;
 458                 }
 459                 rcv = list_entry(acm->spare_read_urbs.next,
 460                                  struct acm_ru, list);
 461                 list_del(&rcv->list);
 462                 spin_unlock_irqrestore(&acm->read_lock, flags);
 463
 464                 buf = list_entry(acm->spare_read_bufs.next,
 465                                  struct acm_rb, list);
 466                 list_del(&buf->list);
 467
 468                 rcv->buffer = buf;
 469
 470                 if (acm->is_int_ep)
 471                         usb_fill_int_urb(rcv->urb, acm->dev,
 472                                          acm->rx_endpoint,
 473                                          buf->base,
 474                                          acm->readsize,
 475                                          acm_read_bulk, rcv, acm->bInterval);
 476                 else
 477                         usb_fill_bulk_urb(rcv->urb, acm->dev,
 478                                           acm->rx_endpoint,
 479                                           buf->base,
 480                                           acm->readsize,
 481                                           acm_read_bulk, rcv);
 482                 rcv->urb->transfer_dma = buf->dma;
 483                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 484
 485                 /* This shouldn't kill the driver as unsuccessful URBs are
 486                    returned to the free-urbs-pool and resubmited ASAP */
 487                 spin_lock_irqsave(&acm->read_lock, flags);
 488                 if (acm->susp_count ||
 489                                 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 490                         list_add(&buf->list, &acm->spare_read_bufs);
 491                         list_add(&rcv->list, &acm->spare_read_urbs);
 492                         acm->processing = 0;
 493                         spin_unlock_irqrestore(&acm->read_lock, flags);
 494                         return;
 495                 } else {
 496                         spin_unlock_irqrestore(&acm->read_lock, flags);
 497                         dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 498                 }
 499         }
 500         spin_lock_irqsave(&acm->read_lock, flags);
 501         acm->processing = 0;
 502         spin_unlock_irqrestore(&acm->read_lock, flags);
 503 }
 504
 505 /* data interface wrote those outgoing bytes */
 506 static void acm_write_bulk(struct urb *urb)
 507 {
 508         struct acm_wb *wb = urb->context;
 509         struct acm *acm = wb->instance;
 510         unsigned long flags;
 511
 512         if (verbose || urb->status
 513                         || (urb->actual_length != urb->transfer_buffer_length))
 514                 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
 515                         urb->actual_length,
 516                         urb->transfer_buffer_length,
 517                         urb->status);
 518
 519         spin_lock_irqsave(&acm->write_lock, flags);
 520         acm_write_done(acm, wb);
 521         spin_unlock_irqrestore(&acm->write_lock, flags);
 522         if (ACM_READY(acm))
 523                 schedule_work(&acm->work);
 524         else
 525                 wake_up_interruptible(&acm->drain_wait);
 526 }
 527
 528 static void acm_softint(struct work_struct *work)
 529 {
 530         struct acm *acm = container_of(work, struct acm, work);
 531         struct tty_struct *tty;
 532
 533         dev_vdbg(&acm->data->dev, "tx work\n");
 534         if (!ACM_READY(acm))
 535                 return;
 536         tty = tty_port_tty_get(&acm->port);
 537         tty_wakeup(tty);
 538         tty_kref_put(tty);
 539 }
 540
 541 /*
 542  * TTY handlers
 543  */
 544
 545 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 546 {
 547         struct acm *acm;
 548         int rv = -ENODEV;
 549         int i;
 550         dbg("Entering acm_tty_open.");
 551
 552         mutex_lock(&open_mutex);
 553
 554         acm = acm_table[tty->index];
 555         if (!acm || !acm->dev)
 556                 goto out;
 557         else
 558                 rv = 0;
 559
 560         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 561
 562         tty->driver_data = acm;
 563         tty_port_tty_set(&acm->port, tty);
 564
 565         if (usb_autopm_get_interface(acm->control) < 0)
 566                 goto early_bail;
 567         else
 568                 acm->control->needs_remote_wakeup = 1;
 569
 570         mutex_lock(&acm->mutex);
 571         if (acm->port.count++) {
 572                 mutex_unlock(&acm->mutex);
 573                 usb_autopm_put_interface(acm->control);
 574                 goto out;
 575         }
 576
 577         acm->ctrlurb->dev = acm->dev;
 578         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 579                 dbg("usb_submit_urb(ctrl irq) failed");
 580                 goto bail_out;
 581         }
 582
 583         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 584             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 585                 goto full_bailout;
 586
 587         usb_autopm_put_interface(acm->control);
 588
 589         INIT_LIST_HEAD(&acm->spare_read_urbs);
 590         INIT_LIST_HEAD(&acm->spare_read_bufs);
 591         INIT_LIST_HEAD(&acm->filled_read_bufs);
 592
 593         for (i = 0; i < acm->rx_buflimit; i++)
 594                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 595         for (i = 0; i < acm->rx_buflimit; i++)
 596                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 597
 598         acm->throttle = 0;
 599
 600         set_bit(ASYNCB_INITIALIZED, &acm->port.flags);
 601         rv = tty_port_block_til_ready(&acm->port, tty, filp);
 602         tasklet_schedule(&acm->urb_task);
 603
 604         mutex_unlock(&acm->mutex);
 605 out:
 606         mutex_unlock(&open_mutex);
 607         return rv;
 608
 609 full_bailout:
 610         usb_kill_urb(acm->ctrlurb);
 611 bail_out:
 612         acm->port.count--;
 613         mutex_unlock(&acm->mutex);
 614         usb_autopm_put_interface(acm->control);
 615 early_bail:
 616         mutex_unlock(&open_mutex);
 617         tty_port_tty_set(&acm->port, NULL);
 618         return -EIO;
 619 }
 620
 621 static void acm_tty_unregister(struct acm *acm)
 622 {
 623         int i, nr;
 624
 625         nr = acm->rx_buflimit;
 626         tty_unregister_device(acm_tty_driver, acm->minor);
 627         usb_put_intf(acm->control);
 628         acm_table[acm->minor] = NULL;
 629         usb_free_urb(acm->ctrlurb);
 630         for (i = 0; i < ACM_NW; i++)
 631                 usb_free_urb(acm->wb[i].urb);
 632         for (i = 0; i < nr; i++)
 633                 usb_free_urb(acm->ru[i].urb);
 634         kfree(acm->country_codes);
 635         kfree(acm);
 636 }
 637
 638 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
 639
 640 static void acm_port_down(struct acm *acm, int drain)
 641 {
 642         int i, nr = acm->rx_buflimit;
 643         mutex_lock(&open_mutex);
 644         if (acm->dev) {
 645                 usb_autopm_get_interface(acm->control);
 646                 acm_set_control(acm, acm->ctrlout = 0);
 647                 /* try letting the last writes drain naturally */
 648                 if (drain) {
 649                         wait_event_interruptible_timeout(acm->drain_wait,
 650                                 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,
 651                                         ACM_CLOSE_TIMEOUT * HZ);
 652                 }
 653                 usb_kill_urb(acm->ctrlurb);
 654                 for (i = 0; i < ACM_NW; i++)
 655                         usb_kill_urb(acm->wb[i].urb);
 656                 for (i = 0; i < nr; i++)
 657                         usb_kill_urb(acm->ru[i].urb);
 658                 acm->control->needs_remote_wakeup = 0;
 659                 usb_autopm_put_interface(acm->control);
 660         }
 661         mutex_unlock(&open_mutex);
 662 }
 663
 664 static void acm_tty_hangup(struct tty_struct *tty)
 665 {
 666         struct acm *acm = tty->driver_data;
 667         tty_port_hangup(&acm->port);
 668         acm_port_down(acm, 0);
 669 }
 670
 671 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 672 {
 673         struct acm *acm = tty->driver_data;
 674
 675         /* Perform the closing process and see if we need to do the hardware
 676            shutdown */
 677         if (!acm)
 678                 return;
 679         if (tty_port_close_start(&acm->port, tty, filp) == 0) {
 680                 mutex_lock(&open_mutex);
 681                 if (!acm->dev) {
 682                         tty_port_tty_set(&acm->port, NULL);
 683                         acm_tty_unregister(acm);
 684                         tty->driver_data = NULL;
 685                 }
 686                 mutex_unlock(&open_mutex);
 687                 return;
 688         }
 689         acm_port_down(acm, 0);
 690         tty_port_close_end(&acm->port, tty);
 691         tty_port_tty_set(&acm->port, NULL);
 692 }
 693
 694 static int acm_tty_write(struct tty_struct *tty,
 695                                         const unsigned char *buf, int count)
 696 {
 697         struct acm *acm = tty->driver_data;
 698         int stat;
 699         unsigned long flags;
 700         int wbn;
 701         struct acm_wb *wb;
 702
 703         dbg("Entering acm_tty_write to write %d bytes,", count);
 704
 705         if (!ACM_READY(acm))
 706                 return -EINVAL;
 707         if (!count)
 708                 return 0;
 709
 710         spin_lock_irqsave(&acm->write_lock, flags);
 711         wbn = acm_wb_alloc(acm);
 712         if (wbn < 0) {
 713                 spin_unlock_irqrestore(&acm->write_lock, flags);
 714                 return 0;
 715         }
 716         wb = &acm->wb[wbn];
 717
 718         count = (count > acm->writesize) ? acm->writesize : count;
 719         dbg("Get %d bytes...", count);
 720         memcpy(wb->buf, buf, count);
 721         wb->len = count;
 722         spin_unlock_irqrestore(&acm->write_lock, flags);
 723
 724         stat = acm_write_start(acm, wbn);
 725         if (stat < 0)
 726                 return stat;
 727         return count;
 728 }
 729
 730 static int acm_tty_write_room(struct tty_struct *tty)
 731 {
 732         struct acm *acm = tty->driver_data;
 733         if (!ACM_READY(acm))
 734                 return -EINVAL;
 735         /*
 736          * Do not let the line discipline to know that we have a reserve,
 737          * or it might get too enthusiastic.
 738          */
 739         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 740 }
 741
 742 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 743 {
 744         struct acm *acm = tty->driver_data;
 745         if (!ACM_READY(acm))
 746                 return 0;
 747         /*
 748          * This is inaccurate (overcounts), but it works.
 749          */
 750         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 751 }
 752
 753 static void acm_tty_throttle(struct tty_struct *tty)
 754 {
 755         struct acm *acm = tty->driver_data;
 756         if (!ACM_READY(acm))
 757                 return;
 758         spin_lock_bh(&acm->throttle_lock);
 759         acm->throttle = 1;
 760         spin_unlock_bh(&acm->throttle_lock);
 761 }
 762
 763 static void acm_tty_unthrottle(struct tty_struct *tty)
 764 {
 765         struct acm *acm = tty->driver_data;
 766         if (!ACM_READY(acm))
 767                 return;
 768         spin_lock_bh(&acm->throttle_lock);
 769         acm->throttle = 0;
 770         spin_unlock_bh(&acm->throttle_lock);
 771         tasklet_schedule(&acm->urb_task);
 772 }
 773
 774 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 775 {
 776         struct acm *acm = tty->driver_data;
 777         int retval;
 778         if (!ACM_READY(acm))
 779                 return -EINVAL;
 780         retval = acm_send_break(acm, state ? 0xffff : 0);
 781         if (retval < 0)
 782                 dbg("send break failed");
 783         return retval;
 784 }
 785
 786 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 787 {
 788         struct acm *acm = tty->driver_data;
 789
 790         if (!ACM_READY(acm))
 791                 return -EINVAL;
 792
 793         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 794                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 795                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 796                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 797                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 798                TIOCM_CTS;
 799 }
 800
 801 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 802                             unsigned int set, unsigned int clear)
 803 {
 804         struct acm *acm = tty->driver_data;
 805         unsigned int newctrl;
 806
 807         if (!ACM_READY(acm))
 808                 return -EINVAL;
 809
 810         newctrl = acm->ctrlout;
 811         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 812                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 813         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 814                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 815
 816         newctrl = (newctrl & ~clear) | set;
 817
 818         if (acm->ctrlout == newctrl)
 819                 return 0;
 820         return acm_set_control(acm, acm->ctrlout = newctrl);
 821 }
 822
 823 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
 824                                         unsigned int cmd, unsigned long arg)
 825 {
 826         struct acm *acm = tty->driver_data;
 827
 828         if (!ACM_READY(acm))
 829                 return -EINVAL;
 830
 831         return -ENOIOCTLCMD;
 832 }
 833
 834 static const __u32 acm_tty_speed[] = {
 835         0, 50, 75, 110, 134, 150, 200, 300, 600,
 836         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 837         57600, 115200, 230400, 460800, 500000, 576000,
 838         921600, 1000000, 1152000, 1500000, 2000000,
 839         2500000, 3000000, 3500000, 4000000
 840 };
 841
 842 static const __u8 acm_tty_size[] = {
 843         5, 6, 7, 8
 844 };
 845
 846 static void acm_tty_set_termios(struct tty_struct *tty,
 847                                                 struct ktermios *termios_old)
 848 {
 849         struct acm *acm = tty->driver_data;
 850         struct ktermios *termios = tty->termios;
 851         struct usb_cdc_line_coding newline;
 852         int newctrl = acm->ctrlout;
 853
 854         if (!ACM_READY(acm))
 855                 return;
 856
 857         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 858         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 859         newline.bParityType = termios->c_cflag & PARENB ?
 860                                 (termios->c_cflag & PARODD ? 1 : 2) +
 861                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 862         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 863         /* FIXME: Needs to clear unsupported bits in the termios */
 864         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 865
 866         if (!newline.dwDTERate) {
 867                 newline.dwDTERate = acm->line.dwDTERate;
 868                 newctrl &= ~ACM_CTRL_DTR;
 869         } else
 870                 newctrl |=  ACM_CTRL_DTR;
 871
 872         if (newctrl != acm->ctrlout)
 873                 acm_set_control(acm, acm->ctrlout = newctrl);
 874
 875         if (memcmp(&acm->line, &newline, sizeof newline)) {
 876                 memcpy(&acm->line, &newline, sizeof newline);
 877                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 878                         newline.bCharFormat, newline.bParityType,
 879                         newline.bDataBits);
 880                 acm_set_line(acm, &acm->line);
 881         }
 882 }
 883
 884 /*
 885  * USB probe and disconnect routines.
 886  */
 887
 888 /* Little helpers: write/read buffers free */
 889 static void acm_write_buffers_free(struct acm *acm)
 890 {
 891         int i;
 892         struct acm_wb *wb;
 893         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 894
 895         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 896                 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
 897 }
 898
 899 static void acm_read_buffers_free(struct acm *acm)
 900 {
 901         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 902         int i, n = acm->rx_buflimit;
 903
 904         for (i = 0; i < n; i++)
 905                 usb_buffer_free(usb_dev, acm->readsize,
 906                                         acm->rb[i].base, acm->rb[i].dma);
 907 }
 908
 909 /* Little helper: write buffers allocate */
 910 static int acm_write_buffers_alloc(struct acm *acm)
 911 {
 912         int i;
 913         struct acm_wb *wb;
 914
 915         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 916                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 917                     &wb->dmah);
 918                 if (!wb->buf) {
 919                         while (i != 0) {
 920                                 --i;
 921                                 --wb;
 922                                 usb_buffer_free(acm->dev, acm->writesize,
 923                                     wb->buf, wb->dmah);
 924                         }
 925                         return -ENOMEM;
 926                 }
 927         }
 928         return 0;
 929 }
 930
 931 static int acm_probe(struct usb_interface *intf,
 932                      const struct usb_device_id *id)
 933 {
 934         struct usb_cdc_union_desc *union_header = NULL;
 935         struct usb_cdc_country_functional_desc *cfd = NULL;
 936         unsigned char *buffer = intf->altsetting->extra;
 937         int buflen = intf->altsetting->extralen;
 938         struct usb_interface *control_interface;
 939         struct usb_interface *data_interface;
 940         struct usb_endpoint_descriptor *epctrl = NULL;
 941         struct usb_endpoint_descriptor *epread = NULL;
 942         struct usb_endpoint_descriptor *epwrite = NULL;
 943         struct usb_device *usb_dev = interface_to_usbdev(intf);
 944         struct acm *acm;
 945         int minor;
 946         int ctrlsize, readsize;
 947         u8 *buf;
 948         u8 ac_management_function = 0;
 949         u8 call_management_function = 0;
 950         int call_interface_num = -1;
 951         int data_interface_num;
 952         unsigned long quirks;
 953         int num_rx_buf;
 954         int i;
 955         int combined_interfaces = 0;
 956
 957         /* normal quirks */
 958         quirks = (unsigned long)id->driver_info;
 959         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 960
 961         /* handle quirks deadly to normal probing*/
 962         if (quirks == NO_UNION_NORMAL) {
 963                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 964                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 965                 goto skip_normal_probe;
 966         }
 967
 968         /* normal probing*/
 969         if (!buffer) {
 970                 dev_err(&intf->dev, "Weird descriptor references\n");
 971                 return -EINVAL;
 972         }
 973
 974         if (!buflen) {
 975                 if (intf->cur_altsetting->endpoint->extralen &&
 976                                 intf->cur_altsetting->endpoint->extra) {
 977                         dev_dbg(&intf->dev,
 978                                 "Seeking extra descriptors on endpoint\n");
 979                         buflen = intf->cur_altsetting->endpoint->extralen;
 980                         buffer = intf->cur_altsetting->endpoint->extra;
 981                 } else {
 982                         dev_err(&intf->dev,
 983                                 "Zero length descriptor references\n");
 984                         return -EINVAL;
 985                 }
 986         }
 987
 988         while (buflen > 0) {
 989                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 990                         dev_err(&intf->dev, "skipping garbage\n");
 991                         goto next_desc;
 992                 }
 993
 994                 switch (buffer[2]) {
 995                 case USB_CDC_UNION_TYPE: /* we've found it */
 996                         if (union_header) {
 997                                 dev_err(&intf->dev, "More than one "
 998                                         "union descriptor, skipping ...\n");
 999                                 goto next_desc;
1000                         }
1001                         union_header = (struct usb_cdc_union_desc *)buffer;
1002                         break;
1003                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1004                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
1005                         break;
1006                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1007                         break; /* for now we ignore it */
1008                 case USB_CDC_ACM_TYPE:
1009                         ac_management_function = buffer[3];
1010                         break;
1011                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1012                         call_management_function = buffer[3];
1013                         call_interface_num = buffer[4];
1014                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
1015                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1016                         break;
1017                 default:
1018                         /* there are LOTS more CDC descriptors that
1019                          * could legitimately be found here.
1020                          */
1021                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1022                                         "type %02x, length %d\n",
1023                                         buffer[2], buffer[0]);
1024                         break;
1025                 }
1026 next_desc:
1027                 buflen -= buffer[0];
1028                 buffer += buffer[0];
1029         }
1030
1031         if (!union_header) {
1032                 if (call_interface_num > 0) {
1033                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1034                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1035                         control_interface = intf;
1036                 } else {
1037                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1038                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1039                                 return -ENODEV;
1040                         } else {
1041                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1042                                 combined_interfaces = 1;
1043                                 control_interface = data_interface = intf;
1044                                 goto look_for_collapsed_interface;
1045                         }
1046                 }
1047         } else {
1048                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1049                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1050                 if (!control_interface || !data_interface) {
1051                         dev_dbg(&intf->dev, "no interfaces\n");
1052                         return -ENODEV;
1053                 }
1054         }
1055
1056         if (data_interface_num != call_interface_num)
1057                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1058
1059         if (control_interface == data_interface) {
1060                 /* some broken devices designed for windows work this way */
1061                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1062                 combined_interfaces = 1;
1063                 /* a popular other OS doesn't use it */
1064                 quirks |= NO_CAP_LINE;
1065                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1066                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1067                         return -EINVAL;
1068                 }
1069 look_for_collapsed_interface:
1070                 for (i = 0; i < 3; i++) {
1071                         struct usb_endpoint_descriptor *ep;
1072                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1073
1074                         if (usb_endpoint_is_int_in(ep))
1075                                 epctrl = ep;
1076                         else if (usb_endpoint_is_bulk_out(ep))
1077                                 epwrite = ep;
1078                         else if (usb_endpoint_is_bulk_in(ep))
1079                                 epread = ep;
1080                         else
1081                                 return -EINVAL;
1082                 }
1083                 if (!epctrl || !epread || !epwrite)
1084                         return -ENODEV;
1085                 else
1086                         goto made_compressed_probe;
1087         }
1088
1089 skip_normal_probe:
1090
1091         /*workaround for switched interfaces */
1092         if (data_interface->cur_altsetting->desc.bInterfaceClass
1093                                                 != CDC_DATA_INTERFACE_TYPE) {
1094                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1095                                                 == CDC_DATA_INTERFACE_TYPE) {
1096                         struct usb_interface *t;
1097                         dev_dbg(&intf->dev,
1098                                 "Your device has switched interfaces.\n");
1099                         t = control_interface;
1100                         control_interface = data_interface;
1101                         data_interface = t;
1102                 } else {
1103                         return -EINVAL;
1104                 }
1105         }
1106
1107         /* Accept probe requests only for the control interface */
1108         if (!combined_interfaces && intf != control_interface)
1109                 return -ENODEV;
1110
1111         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1112                 /* valid in this context */
1113                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1114                 return -EBUSY;
1115         }
1116
1117
1118         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1119                 return -EINVAL;
1120
1121         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1122         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1123         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1124
1125
1126         /* workaround for switched endpoints */
1127         if (!usb_endpoint_dir_in(epread)) {
1128                 /* descriptors are swapped */
1129                 struct usb_endpoint_descriptor *t;
1130                 dev_dbg(&intf->dev,
1131                         "The data interface has switched endpoints\n");
1132                 t = epread;
1133                 epread = epwrite;
1134                 epwrite = t;
1135         }
1136 made_compressed_probe:
1137         dbg("interfaces are valid");
1138         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1139
1140         if (minor == ACM_TTY_MINORS) {
1141                 dev_err(&intf->dev, "no more free acm devices\n");
1142                 return -ENODEV;
1143         }
1144
1145         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1146         if (acm == NULL) {
1147                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1148                 goto alloc_fail;
1149         }
1150
1151         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1152         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1153                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1154         acm->combined_interfaces = combined_interfaces;
1155         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1156         acm->control = control_interface;
1157         acm->data = data_interface;
1158         acm->minor = minor;
1159         acm->dev = usb_dev;
1160         acm->ctrl_caps = ac_management_function;
1161         if (quirks & NO_CAP_LINE)
1162                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1163         acm->ctrlsize = ctrlsize;
1164         acm->readsize = readsize;
1165         acm->rx_buflimit = num_rx_buf;
1166         acm->urb_task.func = acm_rx_tasklet;
1167         acm->urb_task.data = (unsigned long) acm;
1168         INIT_WORK(&acm->work, acm_softint);
1169         init_waitqueue_head(&acm->drain_wait);
1170         spin_lock_init(&acm->throttle_lock);
1171         spin_lock_init(&acm->write_lock);
1172         spin_lock_init(&acm->read_lock);
1173         mutex_init(&acm->mutex);
1174         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1175         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1176         if (acm->is_int_ep)
1177                 acm->bInterval = epread->bInterval;
1178         tty_port_init(&acm->port);
1179         acm->port.ops = &acm_port_ops;
1180
1181         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1182         if (!buf) {
1183                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1184                 goto alloc_fail2;
1185         }
1186         acm->ctrl_buffer = buf;
1187
1188         if (acm_write_buffers_alloc(acm) < 0) {
1189                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1190                 goto alloc_fail4;
1191         }
1192
1193         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1194         if (!acm->ctrlurb) {
1195                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1196                 goto alloc_fail5;
1197         }
1198         for (i = 0; i < num_rx_buf; i++) {
1199                 struct acm_ru *rcv = &(acm->ru[i]);
1200
1201                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1202                 if (rcv->urb == NULL) {
1203                         dev_dbg(&intf->dev,
1204                                 "out of memory (read urbs usb_alloc_urb)\n");
1205                         goto alloc_fail7;
1206                 }
1207
1208                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1209                 rcv->instance = acm;
1210         }
1211         for (i = 0; i < num_rx_buf; i++) {
1212                 struct acm_rb *rb = &(acm->rb[i]);
1213
1214                 rb->base = usb_buffer_alloc(acm->dev, readsize,
1215                                 GFP_KERNEL, &rb->dma);
1216                 if (!rb->base) {
1217                         dev_dbg(&intf->dev,
1218                                 "out of memory (read bufs usb_buffer_alloc)\n");
1219                         goto alloc_fail7;
1220                 }
1221         }
1222         for (i = 0; i < ACM_NW; i++) {
1223                 struct acm_wb *snd = &(acm->wb[i]);
1224
1225                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1226                 if (snd->urb == NULL) {
1227                         dev_dbg(&intf->dev,
1228                                 "out of memory (write urbs usb_alloc_urb)");
1229                         goto alloc_fail7;
1230                 }
1231
1232                 if (usb_endpoint_xfer_int(epwrite))
1233                         usb_fill_int_urb(snd->urb, usb_dev,
1234                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1235                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1236                 else
1237                         usb_fill_bulk_urb(snd->urb, usb_dev,
1238                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1239                                 NULL, acm->writesize, acm_write_bulk, snd);
1240                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1241                 snd->instance = acm;
1242         }
1243
1244         usb_set_intfdata(intf, acm);
1245
1246         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1247         if (i < 0)
1248                 goto alloc_fail8;
1249
1250         if (cfd) { /* export the country data */
1251                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1252                 if (!acm->country_codes)
1253                         goto skip_countries;
1254                 acm->country_code_size = cfd->bLength - 4;
1255                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1256                                                         cfd->bLength - 4);
1257                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1258
1259                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1260                 if (i < 0) {
1261                         kfree(acm->country_codes);
1262                         goto skip_countries;
1263                 }
1264
1265                 i = device_create_file(&intf->dev,
1266                                                 &dev_attr_iCountryCodeRelDate);
1267                 if (i < 0) {
1268                         kfree(acm->country_codes);
1269                         goto skip_countries;
1270                 }
1271         }
1272
1273 skip_countries:
1274         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1275                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1276                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1277                          /* works around buggy devices */
1278                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1279         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1280         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1281
1282         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1283
1284         acm_set_control(acm, acm->ctrlout);
1285
1286         acm->line.dwDTERate = cpu_to_le32(9600);
1287         acm->line.bDataBits = 8;
1288         acm_set_line(acm, &acm->line);
1289
1290         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1291         usb_set_intfdata(data_interface, acm);
1292
1293         usb_get_intf(control_interface);
1294         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1295
1296         acm_table[minor] = acm;
1297
1298         return 0;
1299 alloc_fail8:
1300         for (i = 0; i < ACM_NW; i++)
1301                 usb_free_urb(acm->wb[i].urb);
1302 alloc_fail7:
1303         acm_read_buffers_free(acm);
1304         for (i = 0; i < num_rx_buf; i++)
1305                 usb_free_urb(acm->ru[i].urb);
1306         usb_free_urb(acm->ctrlurb);
1307 alloc_fail5:
1308         acm_write_buffers_free(acm);
1309 alloc_fail4:
1310         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1311 alloc_fail2:
1312         kfree(acm);
1313 alloc_fail:
1314         return -ENOMEM;
1315 }
1316
1317 static void stop_data_traffic(struct acm *acm)
1318 {
1319         int i;
1320         dbg("Entering stop_data_traffic");
1321
1322         tasklet_disable(&acm->urb_task);
1323
1324         usb_kill_urb(acm->ctrlurb);
1325         for (i = 0; i < ACM_NW; i++)
1326                 usb_kill_urb(acm->wb[i].urb);
1327         for (i = 0; i < acm->rx_buflimit; i++)
1328                 usb_kill_urb(acm->ru[i].urb);
1329
1330         tasklet_enable(&acm->urb_task);
1331
1332         cancel_work_sync(&acm->work);
1333 }
1334
1335 static void acm_disconnect(struct usb_interface *intf)
1336 {
1337         struct acm *acm = usb_get_intfdata(intf);
1338         struct usb_device *usb_dev = interface_to_usbdev(intf);
1339         struct tty_struct *tty;
1340
1341         /* sibling interface is already cleaning up */
1342         if (!acm)
1343                 return;
1344
1345         mutex_lock(&open_mutex);
1346         if (acm->country_codes) {
1347                 device_remove_file(&acm->control->dev,
1348                                 &dev_attr_wCountryCodes);
1349                 device_remove_file(&acm->control->dev,
1350                                 &dev_attr_iCountryCodeRelDate);
1351         }
1352         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1353         acm->dev = NULL;
1354         usb_set_intfdata(acm->control, NULL);
1355         usb_set_intfdata(acm->data, NULL);
1356
1357         stop_data_traffic(acm);
1358
1359         acm_write_buffers_free(acm);
1360         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1361                                                                 acm->ctrl_dma);
1362         acm_read_buffers_free(acm);
1363
1364         if (!acm->combined_interfaces)
1365                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1366                                         acm->data : acm->control);
1367
1368         if (acm->port.count == 0) {
1369                 acm_tty_unregister(acm);
1370                 mutex_unlock(&open_mutex);
1371                 return;
1372         }
1373
1374         mutex_unlock(&open_mutex);
1375         tty = tty_port_tty_get(&acm->port);
1376         if (tty) {
1377                 tty_hangup(tty);
1378                 tty_kref_put(tty);
1379         }
1380 }
1381
1382 #ifdef CONFIG_PM
1383 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1384 {
1385         struct acm *acm = usb_get_intfdata(intf);
1386         int cnt;
1387
1388         if (message.event & PM_EVENT_AUTO) {
1389                 int b;
1390
1391                 spin_lock_irq(&acm->read_lock);
1392                 spin_lock(&acm->write_lock);
1393                 b = acm->processing + acm->transmitting;
1394                 spin_unlock(&acm->write_lock);
1395                 spin_unlock_irq(&acm->read_lock);
1396                 if (b)
1397                         return -EBUSY;
1398         }
1399
1400         spin_lock_irq(&acm->read_lock);
1401         spin_lock(&acm->write_lock);
1402         cnt = acm->susp_count++;
1403         spin_unlock(&acm->write_lock);
1404         spin_unlock_irq(&acm->read_lock);
1405
1406         if (cnt)
1407                 return 0;
1408         /*
1409         we treat opened interfaces differently,
1410         we must guard against open
1411         */
1412         mutex_lock(&acm->mutex);
1413
1414         if (acm->port.count)
1415                 stop_data_traffic(acm);
1416
1417         mutex_unlock(&acm->mutex);
1418         return 0;
1419 }
1420
1421 static int acm_resume(struct usb_interface *intf)
1422 {
1423         struct acm *acm = usb_get_intfdata(intf);
1424         struct acm_wb *wb;
1425         int rv = 0;
1426         int cnt;
1427
1428         spin_lock_irq(&acm->read_lock);
1429         acm->susp_count -= 1;
1430         cnt = acm->susp_count;
1431         spin_unlock_irq(&acm->read_lock);
1432
1433         if (cnt)
1434                 return 0;
1435
1436         mutex_lock(&acm->mutex);
1437         if (acm->port.count) {
1438                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1439
1440                 spin_lock_irq(&acm->write_lock);
1441                 if (acm->delayed_wb) {
1442                         wb = acm->delayed_wb;
1443                         acm->delayed_wb = NULL;
1444                         spin_unlock_irq(&acm->write_lock);
1445                         acm_start_wb(acm, acm->delayed_wb);
1446                 } else {
1447                         spin_unlock_irq(&acm->write_lock);
1448                 }
1449
1450                 /*
1451                  * delayed error checking because we must
1452                  * do the write path at all cost
1453                  */
1454                 if (rv < 0)
1455                         goto err_out;
1456
1457                 tasklet_schedule(&acm->urb_task);
1458         }
1459
1460 err_out:
1461         mutex_unlock(&acm->mutex);
1462         return rv;
1463 }
1464
1465 static int acm_reset_resume(struct usb_interface *intf)
1466 {
1467         struct acm *acm = usb_get_intfdata(intf);
1468         struct tty_struct *tty;
1469
1470         mutex_lock(&acm->mutex);
1471         if (acm->port.count) {
1472                 tty = tty_port_tty_get(&acm->port);
1473                 if (tty) {
1474                         tty_hangup(tty);
1475                         tty_kref_put(tty);
1476                 }
1477         }
1478         mutex_unlock(&acm->mutex);
1479         return acm_resume(intf);
1480 }
1481
1482 #endif /* CONFIG_PM */
1483
1484 #define NOKIA_PCSUITE_ACM_INFO(x) \
1485                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1486                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1487                 USB_CDC_ACM_PROTO_VENDOR)
1488
1489 /*
1490  * USB driver structure.
1491  */
1492
1493 static const struct usb_device_id acm_ids[] = {
1494         /* quirky and broken devices */
1495         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1496         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1497         },
1498         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1499         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1500         },
1501         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1502         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1503         },
1504         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1505         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1506         },
1507         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1508         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1509         },
1510         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1511         .driver_info = SINGLE_RX_URB,
1512         },
1513         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1514         .driver_info = SINGLE_RX_URB, /* firmware bug */
1515         },
1516         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1517         .driver_info = SINGLE_RX_URB, /* firmware bug */
1518         },
1519         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1520         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1521         },
1522         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1523         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1524         },
1525         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1526         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1527         },
1528         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1529         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1530         },
1531         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1532         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1533         },
1534         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1535         },
1536         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1537         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1538                                            data interface instead of
1539                                            communications interface.
1540                                            Maybe we should define a new
1541                                            quirk for this. */
1542         },
1543         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1544         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1545         },
1546
1547         /* Nokia S60 phones expose two ACM channels. The first is
1548          * a modem and is picked up by the standard AT-command
1549          * information below. The second is 'vendor-specific' but
1550          * is treated as a serial device at the S60 end, so we want
1551          * to expose it on Linux too. */
1552         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1553         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1554         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1556         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1557         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1558         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1559         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1561         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1562         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1563         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1564         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1565         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1567         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1568         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1570         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1571         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1572         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1573         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1574         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1575         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1576         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1577         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1578         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1579         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1580         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1581         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1582         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1583         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1584         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1585         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1586         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1587         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1588         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1589         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1590         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1591         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1592         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1593         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1594         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1595
1596         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1597
1598         /* Support Lego NXT using pbLua firmware */
1599         { USB_DEVICE(0x0694, 0xff00),
1600         .driver_info = NOT_A_MODEM,
1601         },
1602
1603         /* control interfaces with various AT-command sets */
1604         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1605                 USB_CDC_ACM_PROTO_AT_V25TER) },
1606         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1607                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1608         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1609                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1610         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1611                 USB_CDC_ACM_PROTO_AT_GSM) },
1612         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1613                 USB_CDC_ACM_PROTO_AT_3G) },
1614         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1615                 USB_CDC_ACM_PROTO_AT_CDMA) },
1616
1617         { }
1618 };
1619
1620 MODULE_DEVICE_TABLE(usb, acm_ids);
1621
1622 static struct usb_driver acm_driver = {
1623         .name =         "cdc_acm",
1624         .probe =        acm_probe,
1625         .disconnect =   acm_disconnect,
1626 #ifdef CONFIG_PM
1627         .suspend =      acm_suspend,
1628         .resume =       acm_resume,
1629         .reset_resume = acm_reset_resume,
1630 #endif
1631         .id_table =     acm_ids,
1632 #ifdef CONFIG_PM
1633         .supports_autosuspend = 1,
1634 #endif
1635 };
1636
1637 /*
1638  * TTY driver structures.
1639  */
1640
1641 static const struct tty_operations acm_ops = {
1642         .open =                 acm_tty_open,
1643         .close =                acm_tty_close,
1644         .hangup =               acm_tty_hangup,
1645         .write =                acm_tty_write,
1646         .write_room =           acm_tty_write_room,
1647         .ioctl =                acm_tty_ioctl,
1648         .throttle =             acm_tty_throttle,
1649         .unthrottle =           acm_tty_unthrottle,
1650         .chars_in_buffer =      acm_tty_chars_in_buffer,
1651         .break_ctl =            acm_tty_break_ctl,
1652         .set_termios =          acm_tty_set_termios,
1653         .tiocmget =             acm_tty_tiocmget,
1654         .tiocmset =             acm_tty_tiocmset,
1655 };
1656
1657 /*
1658  * Init / exit.
1659  */
1660
1661 static int __init acm_init(void)
1662 {
1663         int retval;
1664         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1665         if (!acm_tty_driver)
1666                 return -ENOMEM;
1667         acm_tty_driver->owner = THIS_MODULE,
1668         acm_tty_driver->driver_name = "acm",
1669         acm_tty_driver->name = "ttyACM",
1670         acm_tty_driver->major = ACM_TTY_MAJOR,
1671         acm_tty_driver->minor_start = 0,
1672         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1673         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1674         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1675         acm_tty_driver->init_termios = tty_std_termios;
1676         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1677                                                                 HUPCL | CLOCAL;
1678         tty_set_operations(acm_tty_driver, &acm_ops);
1679
1680         retval = tty_register_driver(acm_tty_driver);
1681         if (retval) {
1682                 put_tty_driver(acm_tty_driver);
1683                 return retval;
1684         }
1685
1686         retval = usb_register(&acm_driver);
1687         if (retval) {
1688                 tty_unregister_driver(acm_tty_driver);
1689                 put_tty_driver(acm_tty_driver);
1690                 return retval;
1691         }
1692
1693         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1694                DRIVER_DESC "\n");
1695
1696         return 0;
1697 }
1698
1699 static void __exit acm_exit(void)
1700 {
1701         usb_deregister(&acm_driver);
1702         tty_unregister_driver(acm_tty_driver);
1703         put_tty_driver(acm_tty_driver);
1704 }
1705
1706 module_init(acm_init);
1707 module_exit(acm_exit);
1708
1709 MODULE_AUTHOR(DRIVER_AUTHOR);
1710 MODULE_DESCRIPTION(DRIVER_DESC);
1711 MODULE_LICENSE("GPL");
1712 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);