drivers/usb/class/cdc-acm.c

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