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 void acm_tty_set_termios(struct tty_struct *tty,
 764                                                 struct ktermios *termios_old)
 765 {
 766         struct acm *acm = tty->driver_data;
 767         struct ktermios *termios = tty->termios;
 768         struct usb_cdc_line_coding newline;
 769         int newctrl = acm->ctrlout;
 770
 771         if (!ACM_READY(acm))
 772                 return;
 773
 774         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
 775         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 776         newline.bParityType = termios->c_cflag & PARENB ?
 777                                 (termios->c_cflag & PARODD ? 1 : 2) +
 778                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 779         switch (termios->c_cflag & CSIZE) {
 780         case CS5:
 781                 newline.bDataBits = 5;
 782                 break;
 783         case CS6:
 784                 newline.bDataBits = 6;
 785                 break;
 786         case CS7:
 787                 newline.bDataBits = 7;
 788                 break;
 789         case CS8:
 790         default:
 791                 newline.bDataBits = 8;
 792                 break;
 793         }
 794         /* FIXME: Needs to clear unsupported bits in the termios */
 795         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 796
 797         if (!newline.dwDTERate) {
 798                 newline.dwDTERate = acm->line.dwDTERate;
 799                 newctrl &= ~ACM_CTRL_DTR;
 800         } else
 801                 newctrl |=  ACM_CTRL_DTR;
 802
 803         if (newctrl != acm->ctrlout)
 804                 acm_set_control(acm, acm->ctrlout = newctrl);
 805
 806         if (memcmp(&acm->line, &newline, sizeof newline)) {
 807                 memcpy(&acm->line, &newline, sizeof newline);
 808                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
 809                         __func__,
 810                         le32_to_cpu(newline.dwDTERate),
 811                         newline.bCharFormat, newline.bParityType,
 812                         newline.bDataBits);
 813                 acm_set_line(acm, &acm->line);
 814         }
 815 }
 816
 817 /*
 818  * USB probe and disconnect routines.
 819  */
 820
 821 /* Little helpers: write/read buffers free */
 822 static void acm_write_buffers_free(struct acm *acm)
 823 {
 824         int i;
 825         struct acm_wb *wb;
 826         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 827
 828         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 829                 usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah);
 830 }
 831
 832 static void acm_read_buffers_free(struct acm *acm)
 833 {
 834         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 835         int i;
 836
 837         for (i = 0; i < acm->rx_buflimit; i++)
 838                 usb_free_coherent(usb_dev, acm->readsize,
 839                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
 840 }
 841
 842 /* Little helper: write buffers allocate */
 843 static int acm_write_buffers_alloc(struct acm *acm)
 844 {
 845         int i;
 846         struct acm_wb *wb;
 847
 848         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 849                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
 850                     &wb->dmah);
 851                 if (!wb->buf) {
 852                         while (i != 0) {
 853                                 --i;
 854                                 --wb;
 855                                 usb_free_coherent(acm->dev, acm->writesize,
 856                                     wb->buf, wb->dmah);
 857                         }
 858                         return -ENOMEM;
 859                 }
 860         }
 861         return 0;
 862 }
 863
 864 static int acm_probe(struct usb_interface *intf,
 865                      const struct usb_device_id *id)
 866 {
 867         struct usb_cdc_union_desc *union_header = NULL;
 868         struct usb_cdc_country_functional_desc *cfd = NULL;
 869         unsigned char *buffer = intf->altsetting->extra;
 870         int buflen = intf->altsetting->extralen;
 871         struct usb_interface *control_interface;
 872         struct usb_interface *data_interface;
 873         struct usb_endpoint_descriptor *epctrl = NULL;
 874         struct usb_endpoint_descriptor *epread = NULL;
 875         struct usb_endpoint_descriptor *epwrite = NULL;
 876         struct usb_device *usb_dev = interface_to_usbdev(intf);
 877         struct acm *acm;
 878         int minor;
 879         int ctrlsize, readsize;
 880         u8 *buf;
 881         u8 ac_management_function = 0;
 882         u8 call_management_function = 0;
 883         int call_interface_num = -1;
 884         int data_interface_num = -1;
 885         unsigned long quirks;
 886         int num_rx_buf;
 887         int i;
 888         int combined_interfaces = 0;
 889
 890         /* normal quirks */
 891         quirks = (unsigned long)id->driver_info;
 892         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 893
 894         /* handle quirks deadly to normal probing*/
 895         if (quirks == NO_UNION_NORMAL) {
 896                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 897                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 898                 goto skip_normal_probe;
 899         }
 900
 901         /* normal probing*/
 902         if (!buffer) {
 903                 dev_err(&intf->dev, "Weird descriptor references\n");
 904                 return -EINVAL;
 905         }
 906
 907         if (!buflen) {
 908                 if (intf->cur_altsetting->endpoint &&
 909                                 intf->cur_altsetting->endpoint->extralen &&
 910                                 intf->cur_altsetting->endpoint->extra) {
 911                         dev_dbg(&intf->dev,
 912                                 "Seeking extra descriptors on endpoint\n");
 913                         buflen = intf->cur_altsetting->endpoint->extralen;
 914                         buffer = intf->cur_altsetting->endpoint->extra;
 915                 } else {
 916                         dev_err(&intf->dev,
 917                                 "Zero length descriptor references\n");
 918                         return -EINVAL;
 919                 }
 920         }
 921
 922         while (buflen > 0) {
 923                 if (buffer[1] != USB_DT_CS_INTERFACE) {
 924                         dev_err(&intf->dev, "skipping garbage\n");
 925                         goto next_desc;
 926                 }
 927
 928                 switch (buffer[2]) {
 929                 case USB_CDC_UNION_TYPE: /* we've found it */
 930                         if (union_header) {
 931                                 dev_err(&intf->dev, "More than one "
 932                                         "union descriptor, skipping ...\n");
 933                                 goto next_desc;
 934                         }
 935                         union_header = (struct usb_cdc_union_desc *)buffer;
 936                         break;
 937                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
 938                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
 939                         break;
 940                 case USB_CDC_HEADER_TYPE: /* maybe check version */
 941                         break; /* for now we ignore it */
 942                 case USB_CDC_ACM_TYPE:
 943                         ac_management_function = buffer[3];
 944                         break;
 945                 case USB_CDC_CALL_MANAGEMENT_TYPE:
 946                         call_management_function = buffer[3];
 947                         call_interface_num = buffer[4];
 948                         if ( (quirks & NOT_A_MODEM) == 0 && (call_management_function & 3) != 3)
 949                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
 950                         break;
 951                 default:
 952                         /* there are LOTS more CDC descriptors that
 953                          * could legitimately be found here.
 954                          */
 955                         dev_dbg(&intf->dev, "Ignoring descriptor: "
 956                                         "type %02x, length %d\n",
 957                                         buffer[2], buffer[0]);
 958                         break;
 959                 }
 960 next_desc:
 961                 buflen -= buffer[0];
 962                 buffer += buffer[0];
 963         }
 964
 965         if (!union_header) {
 966                 if (call_interface_num > 0) {
 967                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
 968                         /* quirks for Droids MuIn LCD */
 969                         if (quirks & NO_DATA_INTERFACE)
 970                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
 971                         else
 972                                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 973                         control_interface = intf;
 974                 } else {
 975                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
 976                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
 977                                 return -ENODEV;
 978                         } else {
 979                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
 980                                 combined_interfaces = 1;
 981                                 control_interface = data_interface = intf;
 982                                 goto look_for_collapsed_interface;
 983                         }
 984                 }
 985         } else {
 986                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 987                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 988                 if (!control_interface || !data_interface) {
 989                         dev_dbg(&intf->dev, "no interfaces\n");
 990                         return -ENODEV;
 991                 }
 992         }
 993
 994         if (data_interface_num != call_interface_num)
 995                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
 996
 997         if (control_interface == data_interface) {
 998                 /* some broken devices designed for windows work this way */
 999                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1000                 combined_interfaces = 1;
1001                 /* a popular other OS doesn't use it */
1002                 quirks |= NO_CAP_LINE;
1003                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1004                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1005                         return -EINVAL;
1006                 }
1007 look_for_collapsed_interface:
1008                 for (i = 0; i < 3; i++) {
1009                         struct usb_endpoint_descriptor *ep;
1010                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1011
1012                         if (usb_endpoint_is_int_in(ep))
1013                                 epctrl = ep;
1014                         else if (usb_endpoint_is_bulk_out(ep))
1015                                 epwrite = ep;
1016                         else if (usb_endpoint_is_bulk_in(ep))
1017                                 epread = ep;
1018                         else
1019                                 return -EINVAL;
1020                 }
1021                 if (!epctrl || !epread || !epwrite)
1022                         return -ENODEV;
1023                 else
1024                         goto made_compressed_probe;
1025         }
1026
1027 skip_normal_probe:
1028
1029         /*workaround for switched interfaces */
1030         if (data_interface->cur_altsetting->desc.bInterfaceClass
1031                                                 != CDC_DATA_INTERFACE_TYPE) {
1032                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1033                                                 == CDC_DATA_INTERFACE_TYPE) {
1034                         struct usb_interface *t;
1035                         dev_dbg(&intf->dev,
1036                                 "Your device has switched interfaces.\n");
1037                         t = control_interface;
1038                         control_interface = data_interface;
1039                         data_interface = t;
1040                 } else {
1041                         return -EINVAL;
1042                 }
1043         }
1044
1045         /* Accept probe requests only for the control interface */
1046         if (!combined_interfaces && intf != control_interface)
1047                 return -ENODEV;
1048
1049         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1050                 /* valid in this context */
1051                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1052                 return -EBUSY;
1053         }
1054
1055
1056         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1057             control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1058                 return -EINVAL;
1059
1060         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1061         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1062         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1063
1064
1065         /* workaround for switched endpoints */
1066         if (!usb_endpoint_dir_in(epread)) {
1067                 /* descriptors are swapped */
1068                 struct usb_endpoint_descriptor *t;
1069                 dev_dbg(&intf->dev,
1070                         "The data interface has switched endpoints\n");
1071                 t = epread;
1072                 epread = epwrite;
1073                 epwrite = t;
1074         }
1075 made_compressed_probe:
1076         dev_dbg(&intf->dev, "interfaces are valid\n");
1077         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1078
1079         if (minor == ACM_TTY_MINORS) {
1080                 dev_err(&intf->dev, "no more free acm devices\n");
1081                 return -ENODEV;
1082         }
1083
1084         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1085         if (acm == NULL) {
1086                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1087                 goto alloc_fail;
1088         }
1089
1090         ctrlsize = usb_endpoint_maxp(epctrl);
1091         readsize = usb_endpoint_maxp(epread) *
1092                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1093         acm->combined_interfaces = combined_interfaces;
1094         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1095         acm->control = control_interface;
1096         acm->data = data_interface;
1097         acm->minor = minor;
1098         acm->dev = usb_dev;
1099         acm->ctrl_caps = ac_management_function;
1100         if (quirks & NO_CAP_LINE)
1101                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1102         acm->ctrlsize = ctrlsize;
1103         acm->readsize = readsize;
1104         acm->rx_buflimit = num_rx_buf;
1105         INIT_WORK(&acm->work, acm_softint);
1106         spin_lock_init(&acm->write_lock);
1107         spin_lock_init(&acm->read_lock);
1108         mutex_init(&acm->mutex);
1109         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1110         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1111         if (acm->is_int_ep)
1112                 acm->bInterval = epread->bInterval;
1113         tty_port_init(&acm->port);
1114         acm->port.ops = &acm_port_ops;
1115
1116         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1117         if (!buf) {
1118                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1119                 goto alloc_fail2;
1120         }
1121         acm->ctrl_buffer = buf;
1122
1123         if (acm_write_buffers_alloc(acm) < 0) {
1124                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1125                 goto alloc_fail4;
1126         }
1127
1128         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1129         if (!acm->ctrlurb) {
1130                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1131                 goto alloc_fail5;
1132         }
1133         for (i = 0; i < num_rx_buf; i++) {
1134                 struct acm_rb *rb = &(acm->read_buffers[i]);
1135                 struct urb *urb;
1136
1137                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1138                                                                 &rb->dma);
1139                 if (!rb->base) {
1140                         dev_err(&intf->dev, "out of memory "
1141                                         "(read bufs usb_alloc_coherent)\n");
1142                         goto alloc_fail6;
1143                 }
1144                 rb->index = i;
1145                 rb->instance = acm;
1146
1147                 urb = usb_alloc_urb(0, GFP_KERNEL);
1148                 if (!urb) {
1149                         dev_err(&intf->dev,
1150                                 "out of memory (read urbs usb_alloc_urb)\n");
1151                         goto alloc_fail6;
1152                 }
1153                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1154                 urb->transfer_dma = rb->dma;
1155                 if (acm->is_int_ep) {
1156                         usb_fill_int_urb(urb, acm->dev,
1157                                          acm->rx_endpoint,
1158                                          rb->base,
1159                                          acm->readsize,
1160                                          acm_read_bulk_callback, rb,
1161                                          acm->bInterval);
1162                 } else {
1163                         usb_fill_bulk_urb(urb, acm->dev,
1164                                           acm->rx_endpoint,
1165                                           rb->base,
1166                                           acm->readsize,
1167                                           acm_read_bulk_callback, rb);
1168                 }
1169
1170                 acm->read_urbs[i] = urb;
1171                 __set_bit(i, &acm->read_urbs_free);
1172         }
1173         for (i = 0; i < ACM_NW; i++) {
1174                 struct acm_wb *snd = &(acm->wb[i]);
1175
1176                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1177                 if (snd->urb == NULL) {
1178                         dev_err(&intf->dev,
1179                                 "out of memory (write urbs usb_alloc_urb)\n");
1180                         goto alloc_fail7;
1181                 }
1182
1183                 if (usb_endpoint_xfer_int(epwrite))
1184                         usb_fill_int_urb(snd->urb, usb_dev,
1185                                 usb_sndintpipe(usb_dev, epwrite->bEndpointAddress),
1186                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1187                 else
1188                         usb_fill_bulk_urb(snd->urb, usb_dev,
1189                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1190                                 NULL, acm->writesize, acm_write_bulk, snd);
1191                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1192                 snd->instance = acm;
1193         }
1194
1195         usb_set_intfdata(intf, acm);
1196
1197         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1198         if (i < 0)
1199                 goto alloc_fail7;
1200
1201         if (cfd) { /* export the country data */
1202                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1203                 if (!acm->country_codes)
1204                         goto skip_countries;
1205                 acm->country_code_size = cfd->bLength - 4;
1206                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1207                                                         cfd->bLength - 4);
1208                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1209
1210                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1211                 if (i < 0) {
1212                         kfree(acm->country_codes);
1213                         acm->country_codes = NULL;
1214                         acm->country_code_size = 0;
1215                         goto skip_countries;
1216                 }
1217
1218                 i = device_create_file(&intf->dev,
1219                                                 &dev_attr_iCountryCodeRelDate);
1220                 if (i < 0) {
1221                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1222                         kfree(acm->country_codes);
1223                         acm->country_codes = NULL;
1224                         acm->country_code_size = 0;
1225                         goto skip_countries;
1226                 }
1227         }
1228
1229 skip_countries:
1230         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1231                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1232                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1233                          /* works around buggy devices */
1234                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1235         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1236         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1237
1238         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1239
1240         acm_set_control(acm, acm->ctrlout);
1241
1242         acm->line.dwDTERate = cpu_to_le32(9600);
1243         acm->line.bDataBits = 8;
1244         acm_set_line(acm, &acm->line);
1245
1246         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1247         usb_set_intfdata(data_interface, acm);
1248
1249         usb_get_intf(control_interface);
1250         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1251
1252         acm_table[minor] = acm;
1253
1254         return 0;
1255 alloc_fail7:
1256         for (i = 0; i < ACM_NW; i++)
1257                 usb_free_urb(acm->wb[i].urb);
1258 alloc_fail6:
1259         for (i = 0; i < num_rx_buf; i++)
1260                 usb_free_urb(acm->read_urbs[i]);
1261         acm_read_buffers_free(acm);
1262         usb_free_urb(acm->ctrlurb);
1263 alloc_fail5:
1264         acm_write_buffers_free(acm);
1265 alloc_fail4:
1266         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1267 alloc_fail2:
1268         kfree(acm);
1269 alloc_fail:
1270         return -ENOMEM;
1271 }
1272
1273 static void stop_data_traffic(struct acm *acm)
1274 {
1275         int i;
1276
1277         dev_dbg(&acm->control->dev, "%s\n", __func__);
1278
1279         usb_kill_urb(acm->ctrlurb);
1280         for (i = 0; i < ACM_NW; i++)
1281                 usb_kill_urb(acm->wb[i].urb);
1282         for (i = 0; i < acm->rx_buflimit; i++)
1283                 usb_kill_urb(acm->read_urbs[i]);
1284
1285         cancel_work_sync(&acm->work);
1286 }
1287
1288 static void acm_disconnect(struct usb_interface *intf)
1289 {
1290         struct acm *acm = usb_get_intfdata(intf);
1291         struct usb_device *usb_dev = interface_to_usbdev(intf);
1292         struct tty_struct *tty;
1293
1294         /* sibling interface is already cleaning up */
1295         if (!acm)
1296                 return;
1297
1298         mutex_lock(&open_mutex);
1299         if (acm->country_codes) {
1300                 device_remove_file(&acm->control->dev,
1301                                 &dev_attr_wCountryCodes);
1302                 device_remove_file(&acm->control->dev,
1303                                 &dev_attr_iCountryCodeRelDate);
1304         }
1305         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1306         acm->dev = NULL;
1307         usb_set_intfdata(acm->control, NULL);
1308         usb_set_intfdata(acm->data, NULL);
1309
1310         stop_data_traffic(acm);
1311
1312         acm_write_buffers_free(acm);
1313         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1314                           acm->ctrl_dma);
1315         acm_read_buffers_free(acm);
1316
1317         if (!acm->combined_interfaces)
1318                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1319                                         acm->data : acm->control);
1320
1321         if (acm->port.count == 0) {
1322                 acm_tty_unregister(acm);
1323                 mutex_unlock(&open_mutex);
1324                 return;
1325         }
1326
1327         mutex_unlock(&open_mutex);
1328         tty = tty_port_tty_get(&acm->port);
1329         if (tty) {
1330                 tty_hangup(tty);
1331                 tty_kref_put(tty);
1332         }
1333 }
1334
1335 #ifdef CONFIG_PM
1336 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1337 {
1338         struct acm *acm = usb_get_intfdata(intf);
1339         int cnt;
1340
1341         if (PMSG_IS_AUTO(message)) {
1342                 int b;
1343
1344                 spin_lock_irq(&acm->write_lock);
1345                 b = acm->transmitting;
1346                 spin_unlock_irq(&acm->write_lock);
1347                 if (b)
1348                         return -EBUSY;
1349         }
1350
1351         spin_lock_irq(&acm->read_lock);
1352         spin_lock(&acm->write_lock);
1353         cnt = acm->susp_count++;
1354         spin_unlock(&acm->write_lock);
1355         spin_unlock_irq(&acm->read_lock);
1356
1357         if (cnt)
1358                 return 0;
1359         /*
1360         we treat opened interfaces differently,
1361         we must guard against open
1362         */
1363         mutex_lock(&acm->mutex);
1364
1365         if (acm->port.count)
1366                 stop_data_traffic(acm);
1367
1368         mutex_unlock(&acm->mutex);
1369         return 0;
1370 }
1371
1372 static int acm_resume(struct usb_interface *intf)
1373 {
1374         struct acm *acm = usb_get_intfdata(intf);
1375         struct acm_wb *wb;
1376         int rv = 0;
1377         int cnt;
1378
1379         spin_lock_irq(&acm->read_lock);
1380         acm->susp_count -= 1;
1381         cnt = acm->susp_count;
1382         spin_unlock_irq(&acm->read_lock);
1383
1384         if (cnt)
1385                 return 0;
1386
1387         mutex_lock(&acm->mutex);
1388         if (acm->port.count) {
1389                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1390
1391                 spin_lock_irq(&acm->write_lock);
1392                 if (acm->delayed_wb) {
1393                         wb = acm->delayed_wb;
1394                         acm->delayed_wb = NULL;
1395                         spin_unlock_irq(&acm->write_lock);
1396                         acm_start_wb(acm, wb);
1397                 } else {
1398                         spin_unlock_irq(&acm->write_lock);
1399                 }
1400
1401                 /*
1402                  * delayed error checking because we must
1403                  * do the write path at all cost
1404                  */
1405                 if (rv < 0)
1406                         goto err_out;
1407
1408                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1409         }
1410
1411 err_out:
1412         mutex_unlock(&acm->mutex);
1413         return rv;
1414 }
1415
1416 static int acm_reset_resume(struct usb_interface *intf)
1417 {
1418         struct acm *acm = usb_get_intfdata(intf);
1419         struct tty_struct *tty;
1420
1421         mutex_lock(&acm->mutex);
1422         if (acm->port.count) {
1423                 tty = tty_port_tty_get(&acm->port);
1424                 if (tty) {
1425                         tty_hangup(tty);
1426                         tty_kref_put(tty);
1427                 }
1428         }
1429         mutex_unlock(&acm->mutex);
1430         return acm_resume(intf);
1431 }
1432
1433 #endif /* CONFIG_PM */
1434
1435 #define NOKIA_PCSUITE_ACM_INFO(x) \
1436                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1437                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1438                 USB_CDC_ACM_PROTO_VENDOR)
1439
1440 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1441                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1442                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1443                 USB_CDC_ACM_PROTO_VENDOR)
1444
1445 /*
1446  * USB driver structure.
1447  */
1448
1449 static const struct usb_device_id acm_ids[] = {
1450         /* quirky and broken devices */
1451         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1452         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1453         },
1454         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1455         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1456         },
1457         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1458         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1459         },
1460         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1461         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1462         },
1463         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1464         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1465         },
1466         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1467         .driver_info = SINGLE_RX_URB,
1468         },
1469         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1470         .driver_info = SINGLE_RX_URB, /* firmware bug */
1471         },
1472         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1473         .driver_info = SINGLE_RX_URB, /* firmware bug */
1474         },
1475         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1476         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1477         },
1478         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1479         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1480         },
1481         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1482         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1483         },
1484         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1485         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1486         },
1487         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1488         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1489         },
1490         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1491         },
1492         /* Motorola H24 HSPA module: */
1493         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1494         { USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1495         { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1496         { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1497         { USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1498         { USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1499         { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1500         { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1501
1502         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1503         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1504                                            data interface instead of
1505                                            communications interface.
1506                                            Maybe we should define a new
1507                                            quirk for this. */
1508         },
1509         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1510         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1511         },
1512         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1513         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1514         },
1515
1516         /* Nokia S60 phones expose two ACM channels. The first is
1517          * a modem and is picked up by the standard AT-command
1518          * information below. The second is 'vendor-specific' but
1519          * is treated as a serial device at the S60 end, so we want
1520          * to expose it on Linux too. */
1521         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1522         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1523         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1524         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1525         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1526         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1527         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1528         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1529         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1530         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1531         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1532         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1533         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1534         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1535         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1536         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1537         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1538         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1539         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1540         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1541         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1542         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1543         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1544         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1545         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1546         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1547         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1548         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1549         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1550         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1551         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1552         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1553         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1554         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1556         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1557         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1558         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1559         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1561         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1562         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1563         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1564         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1565         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1567         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1568         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1569         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1570         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1571         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1572         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1573         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1574         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1575         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1576         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1577         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1578         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1579
1580         /* Support for Owen devices */
1581         { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1582
1583         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1584
1585         /* Support Lego NXT using pbLua firmware */
1586         { USB_DEVICE(0x0694, 0xff00),
1587         .driver_info = NOT_A_MODEM,
1588         },
1589
1590         /* Support for Droids MuIn LCD */
1591         { USB_DEVICE(0x04d8, 0x000b),
1592         .driver_info = NO_DATA_INTERFACE,
1593         },
1594
1595         /* control interfaces without any protocol set */
1596         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1597                 USB_CDC_PROTO_NONE) },
1598
1599         /* control interfaces with various AT-command sets */
1600         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1601                 USB_CDC_ACM_PROTO_AT_V25TER) },
1602         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1603                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1604         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1605                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1606         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1607                 USB_CDC_ACM_PROTO_AT_GSM) },
1608         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1609                 USB_CDC_ACM_PROTO_AT_3G) },
1610         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1611                 USB_CDC_ACM_PROTO_AT_CDMA) },
1612
1613         { }
1614 };
1615
1616 MODULE_DEVICE_TABLE(usb, acm_ids);
1617
1618 static struct usb_driver acm_driver = {
1619         .name =         "cdc_acm",
1620         .probe =        acm_probe,
1621         .disconnect =   acm_disconnect,
1622 #ifdef CONFIG_PM
1623         .suspend =      acm_suspend,
1624         .resume =       acm_resume,
1625         .reset_resume = acm_reset_resume,
1626 #endif
1627         .id_table =     acm_ids,
1628 #ifdef CONFIG_PM
1629         .supports_autosuspend = 1,
1630 #endif
1631 };
1632
1633 /*
1634  * TTY driver structures.
1635  */
1636
1637 static const struct tty_operations acm_ops = {
1638         .open =                 acm_tty_open,
1639         .close =                acm_tty_close,
1640         .hangup =               acm_tty_hangup,
1641         .write =                acm_tty_write,
1642         .write_room =           acm_tty_write_room,
1643         .ioctl =                acm_tty_ioctl,
1644         .throttle =             acm_tty_throttle,
1645         .unthrottle =           acm_tty_unthrottle,
1646         .chars_in_buffer =      acm_tty_chars_in_buffer,
1647         .break_ctl =            acm_tty_break_ctl,
1648         .set_termios =          acm_tty_set_termios,
1649         .tiocmget =             acm_tty_tiocmget,
1650         .tiocmset =             acm_tty_tiocmset,
1651 };
1652
1653 /*
1654  * Init / exit.
1655  */
1656
1657 static int __init acm_init(void)
1658 {
1659         int retval;
1660         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1661         if (!acm_tty_driver)
1662                 return -ENOMEM;
1663         acm_tty_driver->owner = THIS_MODULE,
1664         acm_tty_driver->driver_name = "acm",
1665         acm_tty_driver->name = "ttyACM",
1666         acm_tty_driver->major = ACM_TTY_MAJOR,
1667         acm_tty_driver->minor_start = 0,
1668         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1669         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1670         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1671         acm_tty_driver->init_termios = tty_std_termios;
1672         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1673                                                                 HUPCL | CLOCAL;
1674         tty_set_operations(acm_tty_driver, &acm_ops);
1675
1676         retval = tty_register_driver(acm_tty_driver);
1677         if (retval) {
1678                 put_tty_driver(acm_tty_driver);
1679                 return retval;
1680         }
1681
1682         retval = usb_register(&acm_driver);
1683         if (retval) {
1684                 tty_unregister_driver(acm_tty_driver);
1685                 put_tty_driver(acm_tty_driver);
1686                 return retval;
1687         }
1688
1689         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1690
1691         return 0;
1692 }
1693
1694 static void __exit acm_exit(void)
1695 {
1696         usb_deregister(&acm_driver);
1697         tty_unregister_driver(acm_tty_driver);
1698         put_tty_driver(acm_tty_driver);
1699 }
1700
1701 module_init(acm_init);
1702 module_exit(acm_exit);
1703
1704 MODULE_AUTHOR(DRIVER_AUTHOR);
1705 MODULE_DESCRIPTION(DRIVER_DESC);
1706 MODULE_LICENSE("GPL");
1707 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);