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                 return -EINVAL;
1048
1049         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1050         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1051         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1052
1053
1054         /* workaround for switched endpoints */
1055         if (!usb_endpoint_dir_in(epread)) {
1056                 /* descriptors are swapped */
1057                 struct usb_endpoint_descriptor *t;
1058                 dev_dbg(&intf->dev,
1059                         "The data interface has switched endpoints\n");
1060                 t = epread;
1061                 epread = epwrite;
1062                 epwrite = t;
1063         }
1064 made_compressed_probe:
1065         dev_dbg(&intf->dev, "interfaces are valid\n");
1066         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1067
1068         if (minor == ACM_TTY_MINORS) {
1069                 dev_err(&intf->dev, "no more free acm devices\n");
1070                 return -ENODEV;
1071         }
1072
1073         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1074         if (acm == NULL) {
1075                 dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
1076                 goto alloc_fail;
1077         }
1078
1079         ctrlsize = usb_endpoint_maxp(epctrl);
1080         readsize = usb_endpoint_maxp(epread) *
1081                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1082         acm->combined_interfaces = combined_interfaces;
1083         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1084         acm->control = control_interface;
1085         acm->data = data_interface;
1086         acm->minor = minor;
1087         acm->dev = usb_dev;
1088         acm->ctrl_caps = ac_management_function;
1089         if (quirks & NO_CAP_LINE)
1090                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1091         acm->ctrlsize = ctrlsize;
1092         acm->readsize = readsize;
1093         acm->rx_buflimit = num_rx_buf;
1094         INIT_WORK(&acm->work, acm_softint);
1095         spin_lock_init(&acm->write_lock);
1096         spin_lock_init(&acm->read_lock);
1097         mutex_init(&acm->mutex);
1098         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1099         acm->is_int_ep = usb_endpoint_xfer_int(epread);
1100         if (acm->is_int_ep)
1101                 acm->bInterval = epread->bInterval;
1102         tty_port_init(&acm->port);
1103         acm->port.ops = &acm_port_ops;
1104
1105         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1106         if (!buf) {
1107                 dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1108                 goto alloc_fail2;
1109         }
1110         acm->ctrl_buffer = buf;
1111
1112         if (acm_write_buffers_alloc(acm) < 0) {
1113                 dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
1114                 goto alloc_fail4;
1115         }
1116
1117         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1118         if (!acm->ctrlurb) {
1119                 dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1120                 goto alloc_fail5;
1121         }
1122         for (i = 0; i < num_rx_buf; i++) {
1123                 struct acm_rb *rb = &(acm->read_buffers[i]);
1124                 struct urb *urb;
1125
1126                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1127                                                                 &rb->dma);
1128                 if (!rb->base) {
1129                         dev_err(&intf->dev, "out of memory "
1130                                         "(read bufs usb_alloc_coherent)\n");
1131                         goto alloc_fail6;
1132                 }
1133                 rb->index = i;
1134                 rb->instance = acm;
1135
1136                 urb = usb_alloc_urb(0, GFP_KERNEL);
1137                 if (!urb) {
1138                         dev_err(&intf->dev,
1139                                 "out of memory (read urbs usb_alloc_urb)\n");
1140                         goto alloc_fail6;
1141                 }
1142                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1143                 urb->transfer_dma = rb->dma;
1144                 if (acm->is_int_ep) {
1145                         usb_fill_int_urb(urb, acm->dev,
1146                                          acm->rx_endpoint,
1147                                          rb->base,
1148                                          acm->readsize,
1149                                          acm_read_bulk_callback, rb,
1150                                          acm->bInterval);
1151                 } else {
1152                         usb_fill_bulk_urb(urb, acm->dev,
1153                                           acm->rx_endpoint,
1154                                           rb->base,
1155                                           acm->readsize,
1156                                           acm_read_bulk_callback, rb);
1157                 }
1158
1159                 acm->read_urbs[i] = urb;
1160                 __set_bit(i, &acm->read_urbs_free);
1161         }
1162         for (i = 0; i < ACM_NW; i++) {
1163                 struct acm_wb *snd = &(acm->wb[i]);
1164
1165                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1166                 if (snd->urb == NULL) {
1167                         dev_err(&intf->dev,
1168                                 "out of memory (write urbs usb_alloc_urb)\n");
1169                         goto alloc_fail7;
1170                 }
1171
1172                 if (usb_endpoint_xfer_int(epwrite))
1173                         usb_fill_int_urb(snd->urb, usb_dev,
1174                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1175                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1176                 else
1177                         usb_fill_bulk_urb(snd->urb, usb_dev,
1178                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1179                                 NULL, acm->writesize, acm_write_bulk, snd);
1180                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1181                 snd->instance = acm;
1182         }
1183
1184         usb_set_intfdata(intf, acm);
1185
1186         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1187         if (i < 0)
1188                 goto alloc_fail7;
1189
1190         if (cfd) { /* export the country data */
1191                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1192                 if (!acm->country_codes)
1193                         goto skip_countries;
1194                 acm->country_code_size = cfd->bLength - 4;
1195                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1196                                                         cfd->bLength - 4);
1197                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1198
1199                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1200                 if (i < 0) {
1201                         kfree(acm->country_codes);
1202                         acm->country_codes = NULL;
1203                         acm->country_code_size = 0;
1204                         goto skip_countries;
1205                 }
1206
1207                 i = device_create_file(&intf->dev,
1208                                                 &dev_attr_iCountryCodeRelDate);
1209                 if (i < 0) {
1210                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1211                         kfree(acm->country_codes);
1212                         acm->country_codes = NULL;
1213                         acm->country_code_size = 0;
1214                         goto skip_countries;
1215                 }
1216         }
1217
1218 skip_countries:
1219         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1220                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1221                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1222                          /* works around buggy devices */
1223                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1224         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1225         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1226
1227         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1228
1229         acm_set_control(acm, acm->ctrlout);
1230
1231         acm->line.dwDTERate = cpu_to_le32(9600);
1232         acm->line.bDataBits = 8;
1233         acm_set_line(acm, &acm->line);
1234
1235         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1236         usb_set_intfdata(data_interface, acm);
1237
1238         usb_get_intf(control_interface);
1239         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1240
1241         acm_table[minor] = acm;
1242
1243         return 0;
1244 alloc_fail7:
1245         for (i = 0; i < ACM_NW; i++)
1246                 usb_free_urb(acm->wb[i].urb);
1247 alloc_fail6:
1248         for (i = 0; i < num_rx_buf; i++)
1249                 usb_free_urb(acm->read_urbs[i]);
1250         acm_read_buffers_free(acm);
1251         usb_free_urb(acm->ctrlurb);
1252 alloc_fail5:
1253         acm_write_buffers_free(acm);
1254 alloc_fail4:
1255         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1256 alloc_fail2:
1257         kfree(acm);
1258 alloc_fail:
1259         return -ENOMEM;
1260 }
1261
1262 static void stop_data_traffic(struct acm *acm)
1263 {
1264         int i;
1265
1266         dev_dbg(&acm->control->dev, "%s\n", __func__);
1267
1268         usb_kill_urb(acm->ctrlurb);
1269         for (i = 0; i < ACM_NW; i++)
1270                 usb_kill_urb(acm->wb[i].urb);
1271         for (i = 0; i < acm->rx_buflimit; i++)
1272                 usb_kill_urb(acm->read_urbs[i]);
1273
1274         cancel_work_sync(&acm->work);
1275 }
1276
1277 static void acm_disconnect(struct usb_interface *intf)
1278 {
1279         struct acm *acm = usb_get_intfdata(intf);
1280         struct usb_device *usb_dev = interface_to_usbdev(intf);
1281         struct tty_struct *tty;
1282
1283         /* sibling interface is already cleaning up */
1284         if (!acm)
1285                 return;
1286
1287         mutex_lock(&open_mutex);
1288         if (acm->country_codes) {
1289                 device_remove_file(&acm->control->dev,
1290                                 &dev_attr_wCountryCodes);
1291                 device_remove_file(&acm->control->dev,
1292                                 &dev_attr_iCountryCodeRelDate);
1293         }
1294         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1295         acm->dev = NULL;
1296         usb_set_intfdata(acm->control, NULL);
1297         usb_set_intfdata(acm->data, NULL);
1298
1299         stop_data_traffic(acm);
1300
1301         acm_write_buffers_free(acm);
1302         usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1303                           acm->ctrl_dma);
1304         acm_read_buffers_free(acm);
1305
1306         if (!acm->combined_interfaces)
1307                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1308                                         acm->data : acm->control);
1309
1310         if (acm->port.count == 0) {
1311                 acm_tty_unregister(acm);
1312                 mutex_unlock(&open_mutex);
1313                 return;
1314         }
1315
1316         mutex_unlock(&open_mutex);
1317         tty = tty_port_tty_get(&acm->port);
1318         if (tty) {
1319                 tty_hangup(tty);
1320                 tty_kref_put(tty);
1321         }
1322 }
1323
1324 #ifdef CONFIG_PM
1325 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1326 {
1327         struct acm *acm = usb_get_intfdata(intf);
1328         int cnt;
1329
1330         if (PMSG_IS_AUTO(message)) {
1331                 int b;
1332
1333                 spin_lock_irq(&acm->write_lock);
1334                 b = acm->transmitting;
1335                 spin_unlock_irq(&acm->write_lock);
1336                 if (b)
1337                         return -EBUSY;
1338         }
1339
1340         spin_lock_irq(&acm->read_lock);
1341         spin_lock(&acm->write_lock);
1342         cnt = acm->susp_count++;
1343         spin_unlock(&acm->write_lock);
1344         spin_unlock_irq(&acm->read_lock);
1345
1346         if (cnt)
1347                 return 0;
1348         /*
1349         we treat opened interfaces differently,
1350         we must guard against open
1351         */
1352         mutex_lock(&acm->mutex);
1353
1354         if (acm->port.count)
1355                 stop_data_traffic(acm);
1356
1357         mutex_unlock(&acm->mutex);
1358         return 0;
1359 }
1360
1361 static int acm_resume(struct usb_interface *intf)
1362 {
1363         struct acm *acm = usb_get_intfdata(intf);
1364         struct acm_wb *wb;
1365         int rv = 0;
1366         int cnt;
1367
1368         spin_lock_irq(&acm->read_lock);
1369         acm->susp_count -= 1;
1370         cnt = acm->susp_count;
1371         spin_unlock_irq(&acm->read_lock);
1372
1373         if (cnt)
1374                 return 0;
1375
1376         mutex_lock(&acm->mutex);
1377         if (acm->port.count) {
1378                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1379
1380                 spin_lock_irq(&acm->write_lock);
1381                 if (acm->delayed_wb) {
1382                         wb = acm->delayed_wb;
1383                         acm->delayed_wb = NULL;
1384                         spin_unlock_irq(&acm->write_lock);
1385                         acm_start_wb(acm, wb);
1386                 } else {
1387                         spin_unlock_irq(&acm->write_lock);
1388                 }
1389
1390                 /*
1391                  * delayed error checking because we must
1392                  * do the write path at all cost
1393                  */
1394                 if (rv < 0)
1395                         goto err_out;
1396
1397                 rv = acm_submit_read_urbs(acm, GFP_NOIO);
1398         }
1399
1400 err_out:
1401         mutex_unlock(&acm->mutex);
1402         return rv;
1403 }
1404
1405 static int acm_reset_resume(struct usb_interface *intf)
1406 {
1407         struct acm *acm = usb_get_intfdata(intf);
1408         struct tty_struct *tty;
1409
1410         mutex_lock(&acm->mutex);
1411         if (acm->port.count) {
1412                 tty = tty_port_tty_get(&acm->port);
1413                 if (tty) {
1414                         tty_hangup(tty);
1415                         tty_kref_put(tty);
1416                 }
1417         }
1418         mutex_unlock(&acm->mutex);
1419         return acm_resume(intf);
1420 }
1421
1422 #endif /* CONFIG_PM */
1423
1424 #define NOKIA_PCSUITE_ACM_INFO(x) \
1425                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1426                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1427                 USB_CDC_ACM_PROTO_VENDOR)
1428
1429 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1430                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1431                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1432                 USB_CDC_ACM_PROTO_VENDOR)
1433
1434 /*
1435  * USB driver structure.
1436  */
1437
1438 static const struct usb_device_id acm_ids[] = {
1439         /* quirky and broken devices */
1440         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1441         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1442         },
1443         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1444         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1445         },
1446         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1447         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1448         },
1449         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1450         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1451         },
1452         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1453         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1454         },
1455         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1456         .driver_info = SINGLE_RX_URB,
1457         },
1458         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1459         .driver_info = SINGLE_RX_URB, /* firmware bug */
1460         },
1461         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1462         .driver_info = SINGLE_RX_URB, /* firmware bug */
1463         },
1464         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1465         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1466         },
1467         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1468         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1469         },
1470         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1471         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1472         },
1473         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1474         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1475         },
1476         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1477         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1478         },
1479         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1480         },
1481         /* Motorola H24 HSPA module: */
1482         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1483         { USB_DEVICE(0x22b8, 0x2d92) }, /* modem           + diagnostics        */
1484         { USB_DEVICE(0x22b8, 0x2d93) }, /* modem + AT port                      */
1485         { USB_DEVICE(0x22b8, 0x2d95) }, /* modem + AT port + diagnostics        */
1486         { USB_DEVICE(0x22b8, 0x2d96) }, /* modem                         + NMEA */
1487         { USB_DEVICE(0x22b8, 0x2d97) }, /* modem           + diagnostics + NMEA */
1488         { USB_DEVICE(0x22b8, 0x2d99) }, /* modem + AT port               + NMEA */
1489         { USB_DEVICE(0x22b8, 0x2d9a) }, /* modem + AT port + diagnostics + NMEA */
1490
1491         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1492         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1493                                            data interface instead of
1494                                            communications interface.
1495                                            Maybe we should define a new
1496                                            quirk for this. */
1497         },
1498         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1499         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1500         },
1501         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1502         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1503         },
1504
1505         /* Nokia S60 phones expose two ACM channels. The first is
1506          * a modem and is picked up by the standard AT-command
1507          * information below. The second is 'vendor-specific' but
1508          * is treated as a serial device at the S60 end, so we want
1509          * to expose it on Linux too. */
1510         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1511         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1512         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1513         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1514         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1515         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1516         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1517         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1518         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1519         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1520         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1521         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1522         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1523         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1524         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1525         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1526         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1527         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1528         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1529         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1530         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1531         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1532         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1533         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1534         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1535         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1536         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1537         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1538         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1539         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1540         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1541         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1542         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1543         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1544         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1545         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1546         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1547         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1548         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1549         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1550         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1551         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1552         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1553         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1554         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1555         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1556         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1557         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1558         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1559         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1560         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1561         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1562         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1563         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1564         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1565         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1566         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1567         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1568
1569         /* Support for Owen devices */
1570         { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1571
1572         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1573
1574         /* Support Lego NXT using pbLua firmware */
1575         { USB_DEVICE(0x0694, 0xff00),
1576         .driver_info = NOT_A_MODEM,
1577         },
1578
1579         /* Support for Droids MuIn LCD */
1580         { USB_DEVICE(0x04d8, 0x000b),
1581         .driver_info = NO_DATA_INTERFACE,
1582         },
1583
1584         /* control interfaces without any protocol set */
1585         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1586                 USB_CDC_PROTO_NONE) },
1587
1588         /* control interfaces with various AT-command sets */
1589         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1590                 USB_CDC_ACM_PROTO_AT_V25TER) },
1591         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1592                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1593         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1594                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1595         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1596                 USB_CDC_ACM_PROTO_AT_GSM) },
1597         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1598                 USB_CDC_ACM_PROTO_AT_3G) },
1599         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1600                 USB_CDC_ACM_PROTO_AT_CDMA) },
1601
1602         { }
1603 };
1604
1605 MODULE_DEVICE_TABLE(usb, acm_ids);
1606
1607 static struct usb_driver acm_driver = {
1608         .name =         "cdc_acm",
1609         .probe =        acm_probe,
1610         .disconnect =   acm_disconnect,
1611 #ifdef CONFIG_PM
1612         .suspend =      acm_suspend,
1613         .resume =       acm_resume,
1614         .reset_resume = acm_reset_resume,
1615 #endif
1616         .id_table =     acm_ids,
1617 #ifdef CONFIG_PM
1618         .supports_autosuspend = 1,
1619 #endif
1620 };
1621
1622 /*
1623  * TTY driver structures.
1624  */
1625
1626 static const struct tty_operations acm_ops = {
1627         .open =                 acm_tty_open,
1628         .close =                acm_tty_close,
1629         .hangup =               acm_tty_hangup,
1630         .write =                acm_tty_write,
1631         .write_room =           acm_tty_write_room,
1632         .ioctl =                acm_tty_ioctl,
1633         .throttle =             acm_tty_throttle,
1634         .unthrottle =           acm_tty_unthrottle,
1635         .chars_in_buffer =      acm_tty_chars_in_buffer,
1636         .break_ctl =            acm_tty_break_ctl,
1637         .set_termios =          acm_tty_set_termios,
1638         .tiocmget =             acm_tty_tiocmget,
1639         .tiocmset =             acm_tty_tiocmset,
1640 };
1641
1642 /*
1643  * Init / exit.
1644  */
1645
1646 static int __init acm_init(void)
1647 {
1648         int retval;
1649         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1650         if (!acm_tty_driver)
1651                 return -ENOMEM;
1652         acm_tty_driver->owner = THIS_MODULE,
1653         acm_tty_driver->driver_name = "acm",
1654         acm_tty_driver->name = "ttyACM",
1655         acm_tty_driver->major = ACM_TTY_MAJOR,
1656         acm_tty_driver->minor_start = 0,
1657         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1658         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1659         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1660         acm_tty_driver->init_termios = tty_std_termios;
1661         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1662                                                                 HUPCL | CLOCAL;
1663         tty_set_operations(acm_tty_driver, &acm_ops);
1664
1665         retval = tty_register_driver(acm_tty_driver);
1666         if (retval) {
1667                 put_tty_driver(acm_tty_driver);
1668                 return retval;
1669         }
1670
1671         retval = usb_register(&acm_driver);
1672         if (retval) {
1673                 tty_unregister_driver(acm_tty_driver);
1674                 put_tty_driver(acm_tty_driver);
1675                 return retval;
1676         }
1677
1678         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1679
1680         return 0;
1681 }
1682
1683 static void __exit acm_exit(void)
1684 {
1685         usb_deregister(&acm_driver);
1686         tty_unregister_driver(acm_tty_driver);
1687         put_tty_driver(acm_tty_driver);
1688 }
1689
1690 module_init(acm_init);
1691 module_exit(acm_exit);
1692
1693 MODULE_AUTHOR(DRIVER_AUTHOR);
1694 MODULE_DESCRIPTION(DRIVER_DESC);
1695 MODULE_LICENSE("GPL");
1696 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);