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