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