drivers/usb/class/cdc-acm.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * cdc-acm.c
   4  *
   5  * Copyright (c) 1999 Armin Fuerst      <fuerst@in.tum.de>
   6  * Copyright (c) 1999 Pavel Machek      <pavel@ucw.cz>
   7  * Copyright (c) 1999 Johannes Erdfelt  <johannes@erdfelt.com>
   8  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
   9  * Copyright (c) 2004 Oliver Neukum     <oliver@neukum.name>
  10  * Copyright (c) 2005 David Kubicek     <dave@awk.cz>
  11  * Copyright (c) 2011 Johan Hovold      <jhovold@gmail.com>
  12  *
  13  * USB Abstract Control Model driver for USB modems and ISDN adapters
  14  *
  15  * Sponsored by SuSE
  16  */
  17
  18 #undef DEBUG
  19 #undef VERBOSE_DEBUG
  20
  21 #include <linux/kernel.h>
  22 #include <linux/sched/signal.h>
  23 #include <linux/errno.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/log2.h>
  27 #include <linux/tty.h>
  28 #include <linux/serial.h>
  29 #include <linux/tty_driver.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/module.h>
  32 #include <linux/mutex.h>
  33 #include <linux/uaccess.h>
  34 #include <linux/usb.h>
  35 #include <linux/usb/cdc.h>
  36 #include <asm/byteorder.h>
  37 #include <asm/unaligned.h>
  38 #include <linux/idr.h>
  39 #include <linux/list.h>
  40
  41 #include "cdc-acm.h"
  42
  43
  44 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek, Johan Hovold"
  45 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  46
  47 static struct usb_driver acm_driver;
  48 static struct tty_driver *acm_tty_driver;
  49
  50 static DEFINE_IDR(acm_minors);
  51 static DEFINE_MUTEX(acm_minors_lock);
  52
  53 static void acm_tty_set_termios(struct tty_struct *tty,
  54                                 struct ktermios *termios_old);
  55
  56 /*
  57  * acm_minors accessors
  58  */
  59
  60 /*
  61  * Look up an ACM structure by minor. If found and not disconnected, increment
  62  * its refcount and return it with its mutex held.
  63  */
  64 static struct acm *acm_get_by_minor(unsigned int minor)
  65 {
  66         struct acm *acm;
  67
  68         mutex_lock(&acm_minors_lock);
  69         acm = idr_find(&acm_minors, minor);
  70         if (acm) {
  71                 mutex_lock(&acm->mutex);
  72                 if (acm->disconnected) {
  73                         mutex_unlock(&acm->mutex);
  74                         acm = NULL;
  75                 } else {
  76                         tty_port_get(&acm->port);
  77                         mutex_unlock(&acm->mutex);
  78                 }
  79         }
  80         mutex_unlock(&acm_minors_lock);
  81         return acm;
  82 }
  83
  84 /*
  85  * Try to find an available minor number and if found, associate it with 'acm'.
  86  */
  87 static int acm_alloc_minor(struct acm *acm)
  88 {
  89         int minor;
  90
  91         mutex_lock(&acm_minors_lock);
  92         minor = idr_alloc(&acm_minors, acm, 0, ACM_TTY_MINORS, GFP_KERNEL);
  93         mutex_unlock(&acm_minors_lock);
  94
  95         return minor;
  96 }
  97
  98 /* Release the minor number associated with 'acm'.  */
  99 static void acm_release_minor(struct acm *acm)
 100 {
 101         mutex_lock(&acm_minors_lock);
 102         idr_remove(&acm_minors, acm->minor);
 103         mutex_unlock(&acm_minors_lock);
 104 }
 105
 106 /*
 107  * Functions for ACM control messages.
 108  */
 109
 110 static int acm_ctrl_msg(struct acm *acm, int request, int value,
 111                                                         void *buf, int len)
 112 {
 113         int retval;
 114
 115         retval = usb_autopm_get_interface(acm->control);
 116         if (retval)
 117                 return retval;
 118
 119         retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
 120                 request, USB_RT_ACM, value,
 121                 acm->control->altsetting[0].desc.bInterfaceNumber,
 122                 buf, len, 5000);
 123
 124         dev_dbg(&acm->control->dev,
 125                 "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
 126                 __func__, request, value, len, retval);
 127
 128         usb_autopm_put_interface(acm->control);
 129
 130         return retval < 0 ? retval : 0;
 131 }
 132
 133 /* devices aren't required to support these requests.
 134  * the cdc acm descriptor tells whether they do...
 135  */
 136 static inline int acm_set_control(struct acm *acm, int control)
 137 {
 138         if (acm->quirks & QUIRK_CONTROL_LINE_STATE)
 139                 return -EOPNOTSUPP;
 140
 141         return acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE,
 142                         control, NULL, 0);
 143 }
 144
 145 #define acm_set_line(acm, line) \
 146         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 147 #define acm_send_break(acm, ms) \
 148         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 149
 150 static void acm_poison_urbs(struct acm *acm)
 151 {
 152         int i;
 153
 154         usb_poison_urb(acm->ctrlurb);
 155         for (i = 0; i < ACM_NW; i++)
 156                 usb_poison_urb(acm->wb[i].urb);
 157         for (i = 0; i < acm->rx_buflimit; i++)
 158                 usb_poison_urb(acm->read_urbs[i]);
 159 }
 160
 161 static void acm_unpoison_urbs(struct acm *acm)
 162 {
 163         int i;
 164
 165         for (i = 0; i < acm->rx_buflimit; i++)
 166                 usb_unpoison_urb(acm->read_urbs[i]);
 167         for (i = 0; i < ACM_NW; i++)
 168                 usb_unpoison_urb(acm->wb[i].urb);
 169         usb_unpoison_urb(acm->ctrlurb);
 170 }
 171
 172
 173 /*
 174  * Write buffer management.
 175  * All of these assume proper locks taken by the caller.
 176  */
 177
 178 static int acm_wb_alloc(struct acm *acm)
 179 {
 180         int i, wbn;
 181         struct acm_wb *wb;
 182
 183         wbn = 0;
 184         i = 0;
 185         for (;;) {
 186                 wb = &acm->wb[wbn];
 187                 if (!wb->use) {
 188                         wb->use = 1;
 189                         wb->len = 0;
 190                         return wbn;
 191                 }
 192                 wbn = (wbn + 1) % ACM_NW;
 193                 if (++i >= ACM_NW)
 194                         return -1;
 195         }
 196 }
 197
 198 static int acm_wb_is_avail(struct acm *acm)
 199 {
 200         int i, n;
 201         unsigned long flags;
 202
 203         n = ACM_NW;
 204         spin_lock_irqsave(&acm->write_lock, flags);
 205         for (i = 0; i < ACM_NW; i++)
 206                 n -= acm->wb[i].use;
 207         spin_unlock_irqrestore(&acm->write_lock, flags);
 208         return n;
 209 }
 210
 211 /*
 212  * Finish write. Caller must hold acm->write_lock
 213  */
 214 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 215 {
 216         wb->use = 0;
 217         acm->transmitting--;
 218         usb_autopm_put_interface_async(acm->control);
 219 }
 220
 221 /*
 222  * Poke write.
 223  *
 224  * the caller is responsible for locking
 225  */
 226
 227 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 228 {
 229         int rc;
 230
 231         acm->transmitting++;
 232
 233         wb->urb->transfer_buffer = wb->buf;
 234         wb->urb->transfer_dma = wb->dmah;
 235         wb->urb->transfer_buffer_length = wb->len;
 236         wb->urb->dev = acm->dev;
 237
 238         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 239         if (rc < 0) {
 240                 if (rc != -EPERM)
 241                         dev_err(&acm->data->dev,
 242                                 "%s - usb_submit_urb(write bulk) failed: %d\n",
 243                                 __func__, rc);
 244                 acm_write_done(acm, wb);
 245         }
 246         return rc;
 247 }
 248
 249 /*
 250  * attributes exported through sysfs
 251  */
 252 static ssize_t bmCapabilities_show
 253 (struct device *dev, struct device_attribute *attr, char *buf)
 254 {
 255         struct usb_interface *intf = to_usb_interface(dev);
 256         struct acm *acm = usb_get_intfdata(intf);
 257
 258         return sprintf(buf, "%d", acm->ctrl_caps);
 259 }
 260 static DEVICE_ATTR_RO(bmCapabilities);
 261
 262 static ssize_t wCountryCodes_show
 263 (struct device *dev, struct device_attribute *attr, char *buf)
 264 {
 265         struct usb_interface *intf = to_usb_interface(dev);
 266         struct acm *acm = usb_get_intfdata(intf);
 267
 268         memcpy(buf, acm->country_codes, acm->country_code_size);
 269         return acm->country_code_size;
 270 }
 271
 272 static DEVICE_ATTR_RO(wCountryCodes);
 273
 274 static ssize_t iCountryCodeRelDate_show
 275 (struct device *dev, struct device_attribute *attr, char *buf)
 276 {
 277         struct usb_interface *intf = to_usb_interface(dev);
 278         struct acm *acm = usb_get_intfdata(intf);
 279
 280         return sprintf(buf, "%d", acm->country_rel_date);
 281 }
 282
 283 static DEVICE_ATTR_RO(iCountryCodeRelDate);
 284 /*
 285  * Interrupt handlers for various ACM device responses
 286  */
 287
 288 static void acm_process_notification(struct acm *acm, unsigned char *buf)
 289 {
 290         int newctrl;
 291         int difference;
 292         unsigned long flags;
 293         struct usb_cdc_notification *dr = (struct usb_cdc_notification *)buf;
 294         unsigned char *data = buf + sizeof(struct usb_cdc_notification);
 295
 296         switch (dr->bNotificationType) {
 297         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 298                 dev_dbg(&acm->control->dev,
 299                         "%s - network connection: %d\n", __func__, dr->wValue);
 300                 break;
 301
 302         case USB_CDC_NOTIFY_SERIAL_STATE:
 303                 if (le16_to_cpu(dr->wLength) != 2) {
 304                         dev_dbg(&acm->control->dev,
 305                                 "%s - malformed serial state\n", __func__);
 306                         break;
 307                 }
 308
 309                 newctrl = get_unaligned_le16(data);
 310                 dev_dbg(&acm->control->dev,
 311                         "%s - serial state: 0x%x\n", __func__, newctrl);
 312
 313                 if (!acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 314                         dev_dbg(&acm->control->dev,
 315                                 "%s - calling hangup\n", __func__);
 316                         tty_port_tty_hangup(&acm->port, false);
 317                 }
 318
 319                 difference = acm->ctrlin ^ newctrl;
 320                 spin_lock_irqsave(&acm->read_lock, flags);
 321                 acm->ctrlin = newctrl;
 322                 acm->oldcount = acm->iocount;
 323
 324                 if (difference & ACM_CTRL_DSR)
 325                         acm->iocount.dsr++;
 326                 if (difference & ACM_CTRL_DCD)
 327                         acm->iocount.dcd++;
 328                 if (newctrl & ACM_CTRL_BRK) {
 329                         acm->iocount.brk++;
 330                         tty_insert_flip_char(&acm->port, 0, TTY_BREAK);
 331                 }
 332                 if (newctrl & ACM_CTRL_RI)
 333                         acm->iocount.rng++;
 334                 if (newctrl & ACM_CTRL_FRAMING)
 335                         acm->iocount.frame++;
 336                 if (newctrl & ACM_CTRL_PARITY)
 337                         acm->iocount.parity++;
 338                 if (newctrl & ACM_CTRL_OVERRUN)
 339                         acm->iocount.overrun++;
 340                 spin_unlock_irqrestore(&acm->read_lock, flags);
 341
 342                 if (newctrl & ACM_CTRL_BRK)
 343                         tty_flip_buffer_push(&acm->port);
 344
 345                 if (difference)
 346                         wake_up_all(&acm->wioctl);
 347
 348                 break;
 349
 350         default:
 351                 dev_dbg(&acm->control->dev,
 352                         "%s - unknown notification %d received: index %d len %d\n",
 353                         __func__,
 354                         dr->bNotificationType, dr->wIndex, dr->wLength);
 355         }
 356 }
 357
 358 /* control interface reports status changes with "interrupt" transfers */
 359 static void acm_ctrl_irq(struct urb *urb)
 360 {
 361         struct acm *acm = urb->context;
 362         struct usb_cdc_notification *dr = urb->transfer_buffer;
 363         unsigned int current_size = urb->actual_length;
 364         unsigned int expected_size, copy_size, alloc_size;
 365         int retval;
 366         int status = urb->status;
 367
 368         switch (status) {
 369         case 0:
 370                 /* success */
 371                 break;
 372         case -ECONNRESET:
 373         case -ENOENT:
 374         case -ESHUTDOWN:
 375                 /* this urb is terminated, clean up */
 376                 dev_dbg(&acm->control->dev,
 377                         "%s - urb shutting down with status: %d\n",
 378                         __func__, status);
 379                 return;
 380         default:
 381                 dev_dbg(&acm->control->dev,
 382                         "%s - nonzero urb status received: %d\n",
 383                         __func__, status);
 384                 goto exit;
 385         }
 386
 387         usb_mark_last_busy(acm->dev);
 388
 389         if (acm->nb_index)
 390                 dr = (struct usb_cdc_notification *)acm->notification_buffer;
 391
 392         /* size = notification-header + (optional) data */
 393         expected_size = sizeof(struct usb_cdc_notification) +
 394                                         le16_to_cpu(dr->wLength);
 395
 396         if (current_size < expected_size) {
 397                 /* notification is transmitted fragmented, reassemble */
 398                 if (acm->nb_size < expected_size) {
 399                         u8 *new_buffer;
 400                         alloc_size = roundup_pow_of_two(expected_size);
 401                         /* Final freeing is done on disconnect. */
 402                         new_buffer = krealloc(acm->notification_buffer,
 403                                               alloc_size, GFP_ATOMIC);
 404                         if (!new_buffer) {
 405                                 acm->nb_index = 0;
 406                                 goto exit;
 407                         }
 408
 409                         acm->notification_buffer = new_buffer;
 410                         acm->nb_size = alloc_size;
 411                         dr = (struct usb_cdc_notification *)acm->notification_buffer;
 412                 }
 413
 414                 copy_size = min(current_size,
 415                                 expected_size - acm->nb_index);
 416
 417                 memcpy(&acm->notification_buffer[acm->nb_index],
 418                        urb->transfer_buffer, copy_size);
 419                 acm->nb_index += copy_size;
 420                 current_size = acm->nb_index;
 421         }
 422
 423         if (current_size >= expected_size) {
 424                 /* notification complete */
 425                 acm_process_notification(acm, (unsigned char *)dr);
 426                 acm->nb_index = 0;
 427         }
 428
 429 exit:
 430         retval = usb_submit_urb(urb, GFP_ATOMIC);
 431         if (retval && retval != -EPERM && retval != -ENODEV)
 432                 dev_err(&acm->control->dev,
 433                         "%s - usb_submit_urb failed: %d\n", __func__, retval);
 434         else
 435                 dev_vdbg(&acm->control->dev,
 436                         "control resubmission terminated %d\n", retval);
 437 }
 438
 439 static int acm_submit_read_urb(struct acm *acm, int index, gfp_t mem_flags)
 440 {
 441         int res;
 442
 443         if (!test_and_clear_bit(index, &acm->read_urbs_free))
 444                 return 0;
 445
 446         res = usb_submit_urb(acm->read_urbs[index], mem_flags);
 447         if (res) {
 448                 if (res != -EPERM && res != -ENODEV) {
 449                         dev_err(&acm->data->dev,
 450                                 "urb %d failed submission with %d\n",
 451                                 index, res);
 452                 } else {
 453                         dev_vdbg(&acm->data->dev, "intended failure %d\n", res);
 454                 }
 455                 set_bit(index, &acm->read_urbs_free);
 456                 return res;
 457         } else {
 458                 dev_vdbg(&acm->data->dev, "submitted urb %d\n", index);
 459         }
 460
 461         return 0;
 462 }
 463
 464 static int acm_submit_read_urbs(struct acm *acm, gfp_t mem_flags)
 465 {
 466         int res;
 467         int i;
 468
 469         for (i = 0; i < acm->rx_buflimit; ++i) {
 470                 res = acm_submit_read_urb(acm, i, mem_flags);
 471                 if (res)
 472                         return res;
 473         }
 474
 475         return 0;
 476 }
 477
 478 static void acm_process_read_urb(struct acm *acm, struct urb *urb)
 479 {
 480         unsigned long flags;
 481
 482         if (!urb->actual_length)
 483                 return;
 484
 485         spin_lock_irqsave(&acm->read_lock, flags);
 486         tty_insert_flip_string(&acm->port, urb->transfer_buffer,
 487                         urb->actual_length);
 488         spin_unlock_irqrestore(&acm->read_lock, flags);
 489
 490         tty_flip_buffer_push(&acm->port);
 491 }
 492
 493 static void acm_read_bulk_callback(struct urb *urb)
 494 {
 495         struct acm_rb *rb = urb->context;
 496         struct acm *acm = rb->instance;
 497         unsigned long flags;
 498         int status = urb->status;
 499         bool stopped = false;
 500         bool stalled = false;
 501         bool cooldown = false;
 502
 503         dev_vdbg(&acm->data->dev, "got urb %d, len %d, status %d\n",
 504                 rb->index, urb->actual_length, status);
 505
 506         switch (status) {
 507         case 0:
 508                 usb_mark_last_busy(acm->dev);
 509                 acm_process_read_urb(acm, urb);
 510                 break;
 511         case -EPIPE:
 512                 set_bit(EVENT_RX_STALL, &acm->flags);
 513                 stalled = true;
 514                 break;
 515         case -ENOENT:
 516         case -ECONNRESET:
 517         case -ESHUTDOWN:
 518                 dev_dbg(&acm->data->dev,
 519                         "%s - urb shutting down with status: %d\n",
 520                         __func__, status);
 521                 stopped = true;
 522                 break;
 523         case -EOVERFLOW:
 524         case -EPROTO:
 525                 dev_dbg(&acm->data->dev,
 526                         "%s - cooling babbling device\n", __func__);
 527                 usb_mark_last_busy(acm->dev);
 528                 set_bit(rb->index, &acm->urbs_in_error_delay);
 529                 set_bit(ACM_ERROR_DELAY, &acm->flags);
 530                 cooldown = true;
 531                 break;
 532         default:
 533                 dev_dbg(&acm->data->dev,
 534                         "%s - nonzero urb status received: %d\n",
 535                         __func__, status);
 536                 break;
 537         }
 538
 539         /*
 540          * Make sure URB processing is done before marking as free to avoid
 541          * racing with unthrottle() on another CPU. Matches the barriers
 542          * implied by the test_and_clear_bit() in acm_submit_read_urb().
 543          */
 544         smp_mb__before_atomic();
 545         set_bit(rb->index, &acm->read_urbs_free);
 546         /*
 547          * Make sure URB is marked as free before checking the throttled flag
 548          * to avoid racing with unthrottle() on another CPU. Matches the
 549          * smp_mb() in unthrottle().
 550          */
 551         smp_mb__after_atomic();
 552
 553         if (stopped || stalled || cooldown) {
 554                 if (stalled)
 555                         schedule_delayed_work(&acm->dwork, 0);
 556                 else if (cooldown)
 557                         schedule_delayed_work(&acm->dwork, HZ / 2);
 558                 return;
 559         }
 560
 561         /* throttle device if requested by tty */
 562         spin_lock_irqsave(&acm->read_lock, flags);
 563         acm->throttled = acm->throttle_req;
 564         if (!acm->throttled) {
 565                 spin_unlock_irqrestore(&acm->read_lock, flags);
 566                 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
 567         } else {
 568                 spin_unlock_irqrestore(&acm->read_lock, flags);
 569         }
 570 }
 571
 572 /* data interface wrote those outgoing bytes */
 573 static void acm_write_bulk(struct urb *urb)
 574 {
 575         struct acm_wb *wb = urb->context;
 576         struct acm *acm = wb->instance;
 577         unsigned long flags;
 578         int status = urb->status;
 579
 580         if (status || (urb->actual_length != urb->transfer_buffer_length))
 581                 dev_vdbg(&acm->data->dev, "wrote len %d/%d, status %d\n",
 582                         urb->actual_length,
 583                         urb->transfer_buffer_length,
 584                         status);
 585
 586         spin_lock_irqsave(&acm->write_lock, flags);
 587         acm_write_done(acm, wb);
 588         spin_unlock_irqrestore(&acm->write_lock, flags);
 589         set_bit(EVENT_TTY_WAKEUP, &acm->flags);
 590         schedule_delayed_work(&acm->dwork, 0);
 591 }
 592
 593 static void acm_softint(struct work_struct *work)
 594 {
 595         int i;
 596         struct acm *acm = container_of(work, struct acm, dwork.work);
 597
 598         if (test_bit(EVENT_RX_STALL, &acm->flags)) {
 599                 smp_mb(); /* against acm_suspend() */
 600                 if (!acm->susp_count) {
 601                         for (i = 0; i < acm->rx_buflimit; i++)
 602                                 usb_kill_urb(acm->read_urbs[i]);
 603                         usb_clear_halt(acm->dev, acm->in);
 604                         acm_submit_read_urbs(acm, GFP_KERNEL);
 605                         clear_bit(EVENT_RX_STALL, &acm->flags);
 606                 }
 607         }
 608
 609         if (test_and_clear_bit(ACM_ERROR_DELAY, &acm->flags)) {
 610                 for (i = 0; i < acm->rx_buflimit; i++)
 611                         if (test_and_clear_bit(i, &acm->urbs_in_error_delay))
 612                                 acm_submit_read_urb(acm, i, GFP_KERNEL);
 613         }
 614
 615         if (test_and_clear_bit(EVENT_TTY_WAKEUP, &acm->flags))
 616                 tty_port_tty_wakeup(&acm->port);
 617 }
 618
 619 /*
 620  * TTY handlers
 621  */
 622
 623 static int acm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 624 {
 625         struct acm *acm;
 626         int retval;
 627
 628         acm = acm_get_by_minor(tty->index);
 629         if (!acm)
 630                 return -ENODEV;
 631
 632         retval = tty_standard_install(driver, tty);
 633         if (retval)
 634                 goto error_init_termios;
 635
 636         /*
 637          * Suppress initial echoing for some devices which might send data
 638          * immediately after acm driver has been installed.
 639          */
 640         if (acm->quirks & DISABLE_ECHO)
 641                 tty->termios.c_lflag &= ~ECHO;
 642
 643         tty->driver_data = acm;
 644
 645         return 0;
 646
 647 error_init_termios:
 648         tty_port_put(&acm->port);
 649         return retval;
 650 }
 651
 652 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 653 {
 654         struct acm *acm = tty->driver_data;
 655
 656         return tty_port_open(&acm->port, tty, filp);
 657 }
 658
 659 static void acm_port_dtr_rts(struct tty_port *port, int raise)
 660 {
 661         struct acm *acm = container_of(port, struct acm, port);
 662         int val;
 663         int res;
 664
 665         if (raise)
 666                 val = ACM_CTRL_DTR | ACM_CTRL_RTS;
 667         else
 668                 val = 0;
 669
 670         /* FIXME: add missing ctrlout locking throughout driver */
 671         acm->ctrlout = val;
 672
 673         res = acm_set_control(acm, val);
 674         if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
 675                 /* This is broken in too many devices to spam the logs */
 676                 dev_dbg(&acm->control->dev, "failed to set dtr/rts\n");
 677 }
 678
 679 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
 680 {
 681         struct acm *acm = container_of(port, struct acm, port);
 682         int retval = -ENODEV;
 683         int i;
 684
 685         mutex_lock(&acm->mutex);
 686         if (acm->disconnected)
 687                 goto disconnected;
 688
 689         retval = usb_autopm_get_interface(acm->control);
 690         if (retval)
 691                 goto error_get_interface;
 692
 693         /*
 694          * FIXME: Why do we need this? Allocating 64K of physically contiguous
 695          * memory is really nasty...
 696          */
 697         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 698         acm->control->needs_remote_wakeup = 1;
 699
 700         acm->ctrlurb->dev = acm->dev;
 701         retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
 702         if (retval) {
 703                 dev_err(&acm->control->dev,
 704                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
 705                 goto error_submit_urb;
 706         }
 707
 708         acm_tty_set_termios(tty, NULL);
 709
 710         /*
 711          * Unthrottle device in case the TTY was closed while throttled.
 712          */
 713         spin_lock_irq(&acm->read_lock);
 714         acm->throttled = 0;
 715         acm->throttle_req = 0;
 716         spin_unlock_irq(&acm->read_lock);
 717
 718         retval = acm_submit_read_urbs(acm, GFP_KERNEL);
 719         if (retval)
 720                 goto error_submit_read_urbs;
 721
 722         usb_autopm_put_interface(acm->control);
 723
 724         mutex_unlock(&acm->mutex);
 725
 726         return 0;
 727
 728 error_submit_read_urbs:
 729         for (i = 0; i < acm->rx_buflimit; i++)
 730                 usb_kill_urb(acm->read_urbs[i]);
 731         usb_kill_urb(acm->ctrlurb);
 732 error_submit_urb:
 733         usb_autopm_put_interface(acm->control);
 734 error_get_interface:
 735 disconnected:
 736         mutex_unlock(&acm->mutex);
 737
 738         return usb_translate_errors(retval);
 739 }
 740
 741 static void acm_port_destruct(struct tty_port *port)
 742 {
 743         struct acm *acm = container_of(port, struct acm, port);
 744
 745         if (acm->minor != ACM_MINOR_INVALID)
 746                 acm_release_minor(acm);
 747         usb_put_intf(acm->control);
 748         kfree(acm->country_codes);
 749         kfree(acm);
 750 }
 751
 752 static void acm_port_shutdown(struct tty_port *port)
 753 {
 754         struct acm *acm = container_of(port, struct acm, port);
 755         struct urb *urb;
 756         struct acm_wb *wb;
 757
 758         /*
 759          * Need to grab write_lock to prevent race with resume, but no need to
 760          * hold it due to the tty-port initialised flag.
 761          */
 762         acm_poison_urbs(acm);
 763         spin_lock_irq(&acm->write_lock);
 764         spin_unlock_irq(&acm->write_lock);
 765
 766         usb_autopm_get_interface_no_resume(acm->control);
 767         acm->control->needs_remote_wakeup = 0;
 768         usb_autopm_put_interface(acm->control);
 769
 770         for (;;) {
 771                 urb = usb_get_from_anchor(&acm->delayed);
 772                 if (!urb)
 773                         break;
 774                 wb = urb->context;
 775                 wb->use = 0;
 776                 usb_autopm_put_interface_async(acm->control);
 777         }
 778
 779         acm_unpoison_urbs(acm);
 780
 781 }
 782
 783 static void acm_tty_cleanup(struct tty_struct *tty)
 784 {
 785         struct acm *acm = tty->driver_data;
 786
 787         tty_port_put(&acm->port);
 788 }
 789
 790 static void acm_tty_hangup(struct tty_struct *tty)
 791 {
 792         struct acm *acm = tty->driver_data;
 793
 794         tty_port_hangup(&acm->port);
 795 }
 796
 797 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 798 {
 799         struct acm *acm = tty->driver_data;
 800
 801         tty_port_close(&acm->port, tty, filp);
 802 }
 803
 804 static int acm_tty_write(struct tty_struct *tty,
 805                                         const unsigned char *buf, int count)
 806 {
 807         struct acm *acm = tty->driver_data;
 808         int stat;
 809         unsigned long flags;
 810         int wbn;
 811         struct acm_wb *wb;
 812
 813         if (!count)
 814                 return 0;
 815
 816         dev_vdbg(&acm->data->dev, "%d bytes from tty layer\n", count);
 817
 818         spin_lock_irqsave(&acm->write_lock, flags);
 819         wbn = acm_wb_alloc(acm);
 820         if (wbn < 0) {
 821                 spin_unlock_irqrestore(&acm->write_lock, flags);
 822                 return 0;
 823         }
 824         wb = &acm->wb[wbn];
 825
 826         if (!acm->dev) {
 827                 wb->use = 0;
 828                 spin_unlock_irqrestore(&acm->write_lock, flags);
 829                 return -ENODEV;
 830         }
 831
 832         count = (count > acm->writesize) ? acm->writesize : count;
 833         dev_vdbg(&acm->data->dev, "writing %d bytes\n", count);
 834         memcpy(wb->buf, buf, count);
 835         wb->len = count;
 836
 837         stat = usb_autopm_get_interface_async(acm->control);
 838         if (stat) {
 839                 wb->use = 0;
 840                 spin_unlock_irqrestore(&acm->write_lock, flags);
 841                 return stat;
 842         }
 843
 844         if (acm->susp_count) {
 845                 usb_anchor_urb(wb->urb, &acm->delayed);
 846                 spin_unlock_irqrestore(&acm->write_lock, flags);
 847                 return count;
 848         }
 849
 850         stat = acm_start_wb(acm, wb);
 851         spin_unlock_irqrestore(&acm->write_lock, flags);
 852
 853         if (stat < 0)
 854                 return stat;
 855         return count;
 856 }
 857
 858 static int acm_tty_write_room(struct tty_struct *tty)
 859 {
 860         struct acm *acm = tty->driver_data;
 861         /*
 862          * Do not let the line discipline to know that we have a reserve,
 863          * or it might get too enthusiastic.
 864          */
 865         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 866 }
 867
 868 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 869 {
 870         struct acm *acm = tty->driver_data;
 871         /*
 872          * if the device was unplugged then any remaining characters fell out
 873          * of the connector ;)
 874          */
 875         if (acm->disconnected)
 876                 return 0;
 877         /*
 878          * This is inaccurate (overcounts), but it works.
 879          */
 880         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 881 }
 882
 883 static void acm_tty_throttle(struct tty_struct *tty)
 884 {
 885         struct acm *acm = tty->driver_data;
 886
 887         spin_lock_irq(&acm->read_lock);
 888         acm->throttle_req = 1;
 889         spin_unlock_irq(&acm->read_lock);
 890 }
 891
 892 static void acm_tty_unthrottle(struct tty_struct *tty)
 893 {
 894         struct acm *acm = tty->driver_data;
 895         unsigned int was_throttled;
 896
 897         spin_lock_irq(&acm->read_lock);
 898         was_throttled = acm->throttled;
 899         acm->throttled = 0;
 900         acm->throttle_req = 0;
 901         spin_unlock_irq(&acm->read_lock);
 902
 903         /* Matches the smp_mb__after_atomic() in acm_read_bulk_callback(). */
 904         smp_mb();
 905
 906         if (was_throttled)
 907                 acm_submit_read_urbs(acm, GFP_KERNEL);
 908 }
 909
 910 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 911 {
 912         struct acm *acm = tty->driver_data;
 913         int retval;
 914
 915         retval = acm_send_break(acm, state ? 0xffff : 0);
 916         if (retval < 0)
 917                 dev_dbg(&acm->control->dev,
 918                         "%s - send break failed\n", __func__);
 919         return retval;
 920 }
 921
 922 static int acm_tty_tiocmget(struct tty_struct *tty)
 923 {
 924         struct acm *acm = tty->driver_data;
 925
 926         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 927                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 928                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 929                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 930                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 931                TIOCM_CTS;
 932 }
 933
 934 static int acm_tty_tiocmset(struct tty_struct *tty,
 935                             unsigned int set, unsigned int clear)
 936 {
 937         struct acm *acm = tty->driver_data;
 938         unsigned int newctrl;
 939
 940         newctrl = acm->ctrlout;
 941         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 942                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 943         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 944                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 945
 946         newctrl = (newctrl & ~clear) | set;
 947
 948         if (acm->ctrlout == newctrl)
 949                 return 0;
 950         return acm_set_control(acm, acm->ctrlout = newctrl);
 951 }
 952
 953 static int get_serial_info(struct acm *acm, struct serial_struct __user *info)
 954 {
 955         struct serial_struct tmp;
 956
 957         memset(&tmp, 0, sizeof(tmp));
 958         tmp.xmit_fifo_size = acm->writesize;
 959         tmp.baud_base = le32_to_cpu(acm->line.dwDTERate);
 960         tmp.close_delay = jiffies_to_msecs(acm->port.close_delay) / 10;
 961         tmp.closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 962                                 ASYNC_CLOSING_WAIT_NONE :
 963                                 jiffies_to_msecs(acm->port.closing_wait) / 10;
 964
 965         if (copy_to_user(info, &tmp, sizeof(tmp)))
 966                 return -EFAULT;
 967         else
 968                 return 0;
 969 }
 970
 971 static int set_serial_info(struct acm *acm,
 972                                 struct serial_struct __user *newinfo)
 973 {
 974         struct serial_struct new_serial;
 975         unsigned int closing_wait, close_delay;
 976         unsigned int old_closing_wait, old_close_delay;
 977         int retval = 0;
 978
 979         if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
 980                 return -EFAULT;
 981
 982         close_delay = msecs_to_jiffies(new_serial.close_delay * 10);
 983         closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 984                         ASYNC_CLOSING_WAIT_NONE :
 985                         msecs_to_jiffies(new_serial.closing_wait * 10);
 986
 987         /* we must redo the rounding here, so that the values match */
 988         old_close_delay = jiffies_to_msecs(acm->port.close_delay) / 10;
 989         old_closing_wait = acm->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 990                                 ASYNC_CLOSING_WAIT_NONE :
 991                                 jiffies_to_msecs(acm->port.closing_wait) / 10;
 992
 993         mutex_lock(&acm->port.mutex);
 994
 995         if (!capable(CAP_SYS_ADMIN)) {
 996                 if ((new_serial.close_delay != old_close_delay) ||
 997                     (new_serial.closing_wait != old_closing_wait))
 998                         retval = -EPERM;
 999         } else {
1000                 acm->port.close_delay  = close_delay;
1001                 acm->port.closing_wait = closing_wait;
1002         }
1003
1004         mutex_unlock(&acm->port.mutex);
1005         return retval;
1006 }
1007
1008 static int wait_serial_change(struct acm *acm, unsigned long arg)
1009 {
1010         int rv = 0;
1011         DECLARE_WAITQUEUE(wait, current);
1012         struct async_icount old, new;
1013
1014         do {
1015                 spin_lock_irq(&acm->read_lock);
1016                 old = acm->oldcount;
1017                 new = acm->iocount;
1018                 acm->oldcount = new;
1019                 spin_unlock_irq(&acm->read_lock);
1020
1021                 if ((arg & TIOCM_DSR) &&
1022                         old.dsr != new.dsr)
1023                         break;
1024                 if ((arg & TIOCM_CD)  &&
1025                         old.dcd != new.dcd)
1026                         break;
1027                 if ((arg & TIOCM_RI) &&
1028                         old.rng != new.rng)
1029                         break;
1030
1031                 add_wait_queue(&acm->wioctl, &wait);
1032                 set_current_state(TASK_INTERRUPTIBLE);
1033                 schedule();
1034                 remove_wait_queue(&acm->wioctl, &wait);
1035                 if (acm->disconnected) {
1036                         if (arg & TIOCM_CD)
1037                                 break;
1038                         else
1039                                 rv = -ENODEV;
1040                 } else {
1041                         if (signal_pending(current))
1042                                 rv = -ERESTARTSYS;
1043                 }
1044         } while (!rv);
1045
1046
1047
1048         return rv;
1049 }
1050
1051 static int acm_tty_get_icount(struct tty_struct *tty,
1052                                         struct serial_icounter_struct *icount)
1053 {
1054         struct acm *acm = tty->driver_data;
1055
1056         icount->dsr = acm->iocount.dsr;
1057         icount->rng = acm->iocount.rng;
1058         icount->dcd = acm->iocount.dcd;
1059         icount->frame = acm->iocount.frame;
1060         icount->overrun = acm->iocount.overrun;
1061         icount->parity = acm->iocount.parity;
1062         icount->brk = acm->iocount.brk;
1063
1064         return 0;
1065 }
1066
1067 static int acm_tty_ioctl(struct tty_struct *tty,
1068                                         unsigned int cmd, unsigned long arg)
1069 {
1070         struct acm *acm = tty->driver_data;
1071         int rv = -ENOIOCTLCMD;
1072
1073         switch (cmd) {
1074         case TIOCGSERIAL: /* gets serial port data */
1075                 rv = get_serial_info(acm, (struct serial_struct __user *) arg);
1076                 break;
1077         case TIOCSSERIAL:
1078                 rv = set_serial_info(acm, (struct serial_struct __user *) arg);
1079                 break;
1080         case TIOCMIWAIT:
1081                 rv = usb_autopm_get_interface(acm->control);
1082                 if (rv < 0) {
1083                         rv = -EIO;
1084                         break;
1085                 }
1086                 rv = wait_serial_change(acm, arg);
1087                 usb_autopm_put_interface(acm->control);
1088                 break;
1089         }
1090
1091         return rv;
1092 }
1093
1094 static void acm_tty_set_termios(struct tty_struct *tty,
1095                                                 struct ktermios *termios_old)
1096 {
1097         struct acm *acm = tty->driver_data;
1098         struct ktermios *termios = &tty->termios;
1099         struct usb_cdc_line_coding newline;
1100         int newctrl = acm->ctrlout;
1101
1102         newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
1103         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
1104         newline.bParityType = termios->c_cflag & PARENB ?
1105                                 (termios->c_cflag & PARODD ? 1 : 2) +
1106                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
1107         switch (termios->c_cflag & CSIZE) {
1108         case CS5:
1109                 newline.bDataBits = 5;
1110                 break;
1111         case CS6:
1112                 newline.bDataBits = 6;
1113                 break;
1114         case CS7:
1115                 newline.bDataBits = 7;
1116                 break;
1117         case CS8:
1118         default:
1119                 newline.bDataBits = 8;
1120                 break;
1121         }
1122         /* FIXME: Needs to clear unsupported bits in the termios */
1123         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
1124
1125         if (C_BAUD(tty) == B0) {
1126                 newline.dwDTERate = acm->line.dwDTERate;
1127                 newctrl &= ~ACM_CTRL_DTR;
1128         } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
1129                 newctrl |=  ACM_CTRL_DTR;
1130         }
1131
1132         if (newctrl != acm->ctrlout)
1133                 acm_set_control(acm, acm->ctrlout = newctrl);
1134
1135         if (memcmp(&acm->line, &newline, sizeof newline)) {
1136                 memcpy(&acm->line, &newline, sizeof newline);
1137                 dev_dbg(&acm->control->dev, "%s - set line: %d %d %d %d\n",
1138                         __func__,
1139                         le32_to_cpu(newline.dwDTERate),
1140                         newline.bCharFormat, newline.bParityType,
1141                         newline.bDataBits);
1142                 acm_set_line(acm, &acm->line);
1143         }
1144 }
1145
1146 static const struct tty_port_operations acm_port_ops = {
1147         .dtr_rts = acm_port_dtr_rts,
1148         .shutdown = acm_port_shutdown,
1149         .activate = acm_port_activate,
1150         .destruct = acm_port_destruct,
1151 };
1152
1153 /*
1154  * USB probe and disconnect routines.
1155  */
1156
1157 /* Little helpers: write/read buffers free */
1158 static void acm_write_buffers_free(struct acm *acm)
1159 {
1160         int i;
1161         struct acm_wb *wb;
1162
1163         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
1164                 usb_free_coherent(acm->dev, acm->writesize, wb->buf, wb->dmah);
1165 }
1166
1167 static void acm_read_buffers_free(struct acm *acm)
1168 {
1169         int i;
1170
1171         for (i = 0; i < acm->rx_buflimit; i++)
1172                 usb_free_coherent(acm->dev, acm->readsize,
1173                           acm->read_buffers[i].base, acm->read_buffers[i].dma);
1174 }
1175
1176 /* Little helper: write buffers allocate */
1177 static int acm_write_buffers_alloc(struct acm *acm)
1178 {
1179         int i;
1180         struct acm_wb *wb;
1181
1182         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
1183                 wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL,
1184                     &wb->dmah);
1185                 if (!wb->buf) {
1186                         while (i != 0) {
1187                                 --i;
1188                                 --wb;
1189                                 usb_free_coherent(acm->dev, acm->writesize,
1190                                     wb->buf, wb->dmah);
1191                         }
1192                         return -ENOMEM;
1193                 }
1194         }
1195         return 0;
1196 }
1197
1198 static int acm_probe(struct usb_interface *intf,
1199                      const struct usb_device_id *id)
1200 {
1201         struct usb_cdc_union_desc *union_header = NULL;
1202         struct usb_cdc_call_mgmt_descriptor *cmgmd = NULL;
1203         unsigned char *buffer = intf->altsetting->extra;
1204         int buflen = intf->altsetting->extralen;
1205         struct usb_interface *control_interface;
1206         struct usb_interface *data_interface;
1207         struct usb_endpoint_descriptor *epctrl = NULL;
1208         struct usb_endpoint_descriptor *epread = NULL;
1209         struct usb_endpoint_descriptor *epwrite = NULL;
1210         struct usb_device *usb_dev = interface_to_usbdev(intf);
1211         struct usb_cdc_parsed_header h;
1212         struct acm *acm;
1213         int minor;
1214         int ctrlsize, readsize;
1215         u8 *buf;
1216         int call_intf_num = -1;
1217         int data_intf_num = -1;
1218         unsigned long quirks;
1219         int num_rx_buf;
1220         int i;
1221         int combined_interfaces = 0;
1222         struct device *tty_dev;
1223         int rv = -ENOMEM;
1224         int res;
1225
1226         /* normal quirks */
1227         quirks = (unsigned long)id->driver_info;
1228
1229         if (quirks == IGNORE_DEVICE)
1230                 return -ENODEV;
1231
1232         memset(&h, 0x00, sizeof(struct usb_cdc_parsed_header));
1233
1234         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
1235
1236         /* handle quirks deadly to normal probing*/
1237         if (quirks == NO_UNION_NORMAL) {
1238                 data_interface = usb_ifnum_to_if(usb_dev, 1);
1239                 control_interface = usb_ifnum_to_if(usb_dev, 0);
1240                 /* we would crash */
1241                 if (!data_interface || !control_interface)
1242                         return -ENODEV;
1243                 goto skip_normal_probe;
1244         }
1245
1246         /* normal probing*/
1247         if (!buffer) {
1248                 dev_err(&intf->dev, "Weird descriptor references\n");
1249                 return -EINVAL;
1250         }
1251
1252         if (!intf->cur_altsetting)
1253                 return -EINVAL;
1254
1255         if (!buflen) {
1256                 if (intf->cur_altsetting->endpoint &&
1257                                 intf->cur_altsetting->endpoint->extralen &&
1258                                 intf->cur_altsetting->endpoint->extra) {
1259                         dev_dbg(&intf->dev,
1260                                 "Seeking extra descriptors on endpoint\n");
1261                         buflen = intf->cur_altsetting->endpoint->extralen;
1262                         buffer = intf->cur_altsetting->endpoint->extra;
1263                 } else {
1264                         dev_err(&intf->dev,
1265                                 "Zero length descriptor references\n");
1266                         return -EINVAL;
1267                 }
1268         }
1269
1270         cdc_parse_cdc_header(&h, intf, buffer, buflen);
1271         union_header = h.usb_cdc_union_desc;
1272         cmgmd = h.usb_cdc_call_mgmt_descriptor;
1273         if (cmgmd)
1274                 call_intf_num = cmgmd->bDataInterface;
1275
1276         if (!union_header) {
1277                 if (call_intf_num > 0) {
1278                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1279                         /* quirks for Droids MuIn LCD */
1280                         if (quirks & NO_DATA_INTERFACE) {
1281                                 data_interface = usb_ifnum_to_if(usb_dev, 0);
1282                         } else {
1283                                 data_intf_num = call_intf_num;
1284                                 data_interface = usb_ifnum_to_if(usb_dev, data_intf_num);
1285                         }
1286                         control_interface = intf;
1287                 } else {
1288                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1289                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1290                                 return -ENODEV;
1291                         } else {
1292                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1293                                 combined_interfaces = 1;
1294                                 control_interface = data_interface = intf;
1295                                 goto look_for_collapsed_interface;
1296                         }
1297                 }
1298         } else {
1299                 int class = -1;
1300
1301                 data_intf_num = union_header->bSlaveInterface0;
1302                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1303                 data_interface = usb_ifnum_to_if(usb_dev, data_intf_num);
1304
1305                 if (control_interface)
1306                         class = control_interface->cur_altsetting->desc.bInterfaceClass;
1307
1308                 if (class != USB_CLASS_COMM && class != USB_CLASS_CDC_DATA) {
1309                         dev_dbg(&intf->dev, "Broken union descriptor, assuming single interface\n");
1310                         combined_interfaces = 1;
1311                         control_interface = data_interface = intf;
1312                         goto look_for_collapsed_interface;
1313                 }
1314         }
1315
1316         if (!control_interface || !data_interface) {
1317                 dev_dbg(&intf->dev, "no interfaces\n");
1318                 return -ENODEV;
1319         }
1320         if (!data_interface->cur_altsetting || !control_interface->cur_altsetting)
1321                 return -ENODEV;
1322
1323         if (data_intf_num != call_intf_num)
1324                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1325
1326         if (control_interface == data_interface) {
1327                 /* some broken devices designed for windows work this way */
1328                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1329                 combined_interfaces = 1;
1330                 /* a popular other OS doesn't use it */
1331                 quirks |= NO_CAP_LINE;
1332                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1333                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1334                         return -EINVAL;
1335                 }
1336 look_for_collapsed_interface:
1337                 res = usb_find_common_endpoints(data_interface->cur_altsetting,
1338                                 &epread, &epwrite, &epctrl, NULL);
1339                 if (res)
1340                         return res;
1341
1342                 goto made_compressed_probe;
1343         }
1344
1345 skip_normal_probe:
1346
1347         /*workaround for switched interfaces */
1348         if (data_interface->cur_altsetting->desc.bInterfaceClass
1349                                                 != CDC_DATA_INTERFACE_TYPE) {
1350                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1351                                                 == CDC_DATA_INTERFACE_TYPE) {
1352                         dev_dbg(&intf->dev,
1353                                 "Your device has switched interfaces.\n");
1354                         swap(control_interface, data_interface);
1355                 } else {
1356                         return -EINVAL;
1357                 }
1358         }
1359
1360         /* Accept probe requests only for the control interface */
1361         if (!combined_interfaces && intf != control_interface)
1362                 return -ENODEV;
1363
1364         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1365                 /* valid in this context */
1366                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1367                 return -EBUSY;
1368         }
1369
1370
1371         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2 ||
1372             control_interface->cur_altsetting->desc.bNumEndpoints == 0)
1373                 return -EINVAL;
1374
1375         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1376         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1377         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1378
1379
1380         /* workaround for switched endpoints */
1381         if (!usb_endpoint_dir_in(epread)) {
1382                 /* descriptors are swapped */
1383                 dev_dbg(&intf->dev,
1384                         "The data interface has switched endpoints\n");
1385                 swap(epread, epwrite);
1386         }
1387 made_compressed_probe:
1388         dev_dbg(&intf->dev, "interfaces are valid\n");
1389
1390         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1391         if (acm == NULL)
1392                 goto alloc_fail;
1393
1394         tty_port_init(&acm->port);
1395         acm->port.ops = &acm_port_ops;
1396
1397         ctrlsize = usb_endpoint_maxp(epctrl);
1398         readsize = usb_endpoint_maxp(epread) *
1399                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1400         acm->combined_interfaces = combined_interfaces;
1401         acm->writesize = usb_endpoint_maxp(epwrite) * 20;
1402         acm->control = control_interface;
1403         acm->data = data_interface;
1404
1405         usb_get_intf(acm->control); /* undone in destruct() */
1406
1407         minor = acm_alloc_minor(acm);
1408         if (minor < 0) {
1409                 acm->minor = ACM_MINOR_INVALID;
1410                 goto alloc_fail1;
1411         }
1412
1413         acm->minor = minor;
1414         acm->dev = usb_dev;
1415         if (h.usb_cdc_acm_descriptor)
1416                 acm->ctrl_caps = h.usb_cdc_acm_descriptor->bmCapabilities;
1417         if (quirks & NO_CAP_LINE)
1418                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1419         acm->ctrlsize = ctrlsize;
1420         acm->readsize = readsize;
1421         acm->rx_buflimit = num_rx_buf;
1422         INIT_DELAYED_WORK(&acm->dwork, acm_softint);
1423         init_waitqueue_head(&acm->wioctl);
1424         spin_lock_init(&acm->write_lock);
1425         spin_lock_init(&acm->read_lock);
1426         mutex_init(&acm->mutex);
1427         if (usb_endpoint_xfer_int(epread)) {
1428                 acm->bInterval = epread->bInterval;
1429                 acm->in = usb_rcvintpipe(usb_dev, epread->bEndpointAddress);
1430         } else {
1431                 acm->in = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1432         }
1433         if (usb_endpoint_xfer_int(epwrite))
1434                 acm->out = usb_sndintpipe(usb_dev, epwrite->bEndpointAddress);
1435         else
1436                 acm->out = usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress);
1437         init_usb_anchor(&acm->delayed);
1438         acm->quirks = quirks;
1439
1440         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1441         if (!buf)
1442                 goto alloc_fail1;
1443         acm->ctrl_buffer = buf;
1444
1445         if (acm_write_buffers_alloc(acm) < 0)
1446                 goto alloc_fail2;
1447
1448         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1449         if (!acm->ctrlurb)
1450                 goto alloc_fail3;
1451
1452         for (i = 0; i < num_rx_buf; i++) {
1453                 struct acm_rb *rb = &(acm->read_buffers[i]);
1454                 struct urb *urb;
1455
1456                 rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
1457                                                                 &rb->dma);
1458                 if (!rb->base)
1459                         goto alloc_fail4;
1460                 rb->index = i;
1461                 rb->instance = acm;
1462
1463                 urb = usb_alloc_urb(0, GFP_KERNEL);
1464                 if (!urb)
1465                         goto alloc_fail4;
1466
1467                 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1468                 urb->transfer_dma = rb->dma;
1469                 if (usb_endpoint_xfer_int(epread))
1470                         usb_fill_int_urb(urb, acm->dev, acm->in, rb->base,
1471                                          acm->readsize,
1472                                          acm_read_bulk_callback, rb,
1473                                          acm->bInterval);
1474                 else
1475                         usb_fill_bulk_urb(urb, acm->dev, acm->in, rb->base,
1476                                           acm->readsize,
1477                                           acm_read_bulk_callback, rb);
1478
1479                 acm->read_urbs[i] = urb;
1480                 __set_bit(i, &acm->read_urbs_free);
1481         }
1482         for (i = 0; i < ACM_NW; i++) {
1483                 struct acm_wb *snd = &(acm->wb[i]);
1484
1485                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1486                 if (snd->urb == NULL)
1487                         goto alloc_fail5;
1488
1489                 if (usb_endpoint_xfer_int(epwrite))
1490                         usb_fill_int_urb(snd->urb, usb_dev, acm->out,
1491                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1492                 else
1493                         usb_fill_bulk_urb(snd->urb, usb_dev, acm->out,
1494                                 NULL, acm->writesize, acm_write_bulk, snd);
1495                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1496                 if (quirks & SEND_ZERO_PACKET)
1497                         snd->urb->transfer_flags |= URB_ZERO_PACKET;
1498                 snd->instance = acm;
1499         }
1500
1501         usb_set_intfdata(intf, acm);
1502
1503         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1504         if (i < 0)
1505                 goto alloc_fail5;
1506
1507         if (h.usb_cdc_country_functional_desc) { /* export the country data */
1508                 struct usb_cdc_country_functional_desc * cfd =
1509                                         h.usb_cdc_country_functional_desc;
1510
1511                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1512                 if (!acm->country_codes)
1513                         goto skip_countries;
1514                 acm->country_code_size = cfd->bLength - 4;
1515                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1516                                                         cfd->bLength - 4);
1517                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1518
1519                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1520                 if (i < 0) {
1521                         kfree(acm->country_codes);
1522                         acm->country_codes = NULL;
1523                         acm->country_code_size = 0;
1524                         goto skip_countries;
1525                 }
1526
1527                 i = device_create_file(&intf->dev,
1528                                                 &dev_attr_iCountryCodeRelDate);
1529                 if (i < 0) {
1530                         device_remove_file(&intf->dev, &dev_attr_wCountryCodes);
1531                         kfree(acm->country_codes);
1532                         acm->country_codes = NULL;
1533                         acm->country_code_size = 0;
1534                         goto skip_countries;
1535                 }
1536         }
1537
1538 skip_countries:
1539         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1540                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1541                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1542                          /* works around buggy devices */
1543                          epctrl->bInterval ? epctrl->bInterval : 16);
1544         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1545         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1546         acm->notification_buffer = NULL;
1547         acm->nb_index = 0;
1548         acm->nb_size = 0;
1549
1550         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1551
1552         acm->line.dwDTERate = cpu_to_le32(9600);
1553         acm->line.bDataBits = 8;
1554         acm_set_line(acm, &acm->line);
1555
1556         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1557         usb_set_intfdata(data_interface, acm);
1558
1559         tty_dev = tty_port_register_device(&acm->port, acm_tty_driver, minor,
1560                         &control_interface->dev);
1561         if (IS_ERR(tty_dev)) {
1562                 rv = PTR_ERR(tty_dev);
1563                 goto alloc_fail6;
1564         }
1565
1566         if (quirks & CLEAR_HALT_CONDITIONS) {
1567                 usb_clear_halt(usb_dev, acm->in);
1568                 usb_clear_halt(usb_dev, acm->out);
1569         }
1570
1571         return 0;
1572 alloc_fail6:
1573         if (!acm->combined_interfaces) {
1574                 /* Clear driver data so that disconnect() returns early. */
1575                 usb_set_intfdata(data_interface, NULL);
1576                 usb_driver_release_interface(&acm_driver, data_interface);
1577         }
1578         if (acm->country_codes) {
1579                 device_remove_file(&acm->control->dev,
1580                                 &dev_attr_wCountryCodes);
1581                 device_remove_file(&acm->control->dev,
1582                                 &dev_attr_iCountryCodeRelDate);
1583         }
1584         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1585 alloc_fail5:
1586         usb_set_intfdata(intf, NULL);
1587         for (i = 0; i < ACM_NW; i++)
1588                 usb_free_urb(acm->wb[i].urb);
1589 alloc_fail4:
1590         for (i = 0; i < num_rx_buf; i++)
1591                 usb_free_urb(acm->read_urbs[i]);
1592         acm_read_buffers_free(acm);
1593         usb_free_urb(acm->ctrlurb);
1594 alloc_fail3:
1595         acm_write_buffers_free(acm);
1596 alloc_fail2:
1597         usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1598 alloc_fail1:
1599         tty_port_put(&acm->port);
1600 alloc_fail:
1601         return rv;
1602 }
1603
1604 static void acm_disconnect(struct usb_interface *intf)
1605 {
1606         struct acm *acm = usb_get_intfdata(intf);
1607         struct tty_struct *tty;
1608         int i;
1609
1610         /* sibling interface is already cleaning up */
1611         if (!acm)
1612                 return;
1613
1614         acm->disconnected = true;
1615         /*
1616          * there is a circular dependency. acm_softint() can resubmit
1617          * the URBs in error handling so we need to block any
1618          * submission right away
1619          */
1620         acm_poison_urbs(acm);
1621         mutex_lock(&acm->mutex);
1622         if (acm->country_codes) {
1623                 device_remove_file(&acm->control->dev,
1624                                 &dev_attr_wCountryCodes);
1625                 device_remove_file(&acm->control->dev,
1626                                 &dev_attr_iCountryCodeRelDate);
1627         }
1628         wake_up_all(&acm->wioctl);
1629         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1630         usb_set_intfdata(acm->control, NULL);
1631         usb_set_intfdata(acm->data, NULL);
1632         mutex_unlock(&acm->mutex);
1633
1634         tty = tty_port_tty_get(&acm->port);
1635         if (tty) {
1636                 tty_vhangup(tty);
1637                 tty_kref_put(tty);
1638         }
1639
1640         cancel_delayed_work_sync(&acm->dwork);
1641
1642         tty_unregister_device(acm_tty_driver, acm->minor);
1643
1644         usb_free_urb(acm->ctrlurb);
1645         for (i = 0; i < ACM_NW; i++)
1646                 usb_free_urb(acm->wb[i].urb);
1647         for (i = 0; i < acm->rx_buflimit; i++)
1648                 usb_free_urb(acm->read_urbs[i]);
1649         acm_write_buffers_free(acm);
1650         usb_free_coherent(acm->dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1651         acm_read_buffers_free(acm);
1652
1653         kfree(acm->notification_buffer);
1654
1655         if (!acm->combined_interfaces)
1656                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1657                                         acm->data : acm->control);
1658
1659         tty_port_put(&acm->port);
1660 }
1661
1662 #ifdef CONFIG_PM
1663 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1664 {
1665         struct acm *acm = usb_get_intfdata(intf);
1666         int cnt;
1667
1668         spin_lock_irq(&acm->write_lock);
1669         if (PMSG_IS_AUTO(message)) {
1670                 if (acm->transmitting) {
1671                         spin_unlock_irq(&acm->write_lock);
1672                         return -EBUSY;
1673                 }
1674         }
1675         cnt = acm->susp_count++;
1676         spin_unlock_irq(&acm->write_lock);
1677
1678         if (cnt)
1679                 return 0;
1680
1681         acm_poison_urbs(acm);
1682         cancel_delayed_work_sync(&acm->dwork);
1683         acm->urbs_in_error_delay = 0;
1684
1685         return 0;
1686 }
1687
1688 static int acm_resume(struct usb_interface *intf)
1689 {
1690         struct acm *acm = usb_get_intfdata(intf);
1691         struct urb *urb;
1692         int rv = 0;
1693
1694         spin_lock_irq(&acm->write_lock);
1695
1696         if (--acm->susp_count)
1697                 goto out;
1698
1699         acm_unpoison_urbs(acm);
1700
1701         if (tty_port_initialized(&acm->port)) {
1702                 rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
1703
1704                 for (;;) {
1705                         urb = usb_get_from_anchor(&acm->delayed);
1706                         if (!urb)
1707                                 break;
1708
1709                         acm_start_wb(acm, urb->context);
1710                 }
1711
1712                 /*
1713                  * delayed error checking because we must
1714                  * do the write path at all cost
1715                  */
1716                 if (rv < 0)
1717                         goto out;
1718
1719                 rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
1720         }
1721 out:
1722         spin_unlock_irq(&acm->write_lock);
1723
1724         return rv;
1725 }
1726
1727 static int acm_reset_resume(struct usb_interface *intf)
1728 {
1729         struct acm *acm = usb_get_intfdata(intf);
1730
1731         if (tty_port_initialized(&acm->port))
1732                 tty_port_tty_hangup(&acm->port, false);
1733
1734         return acm_resume(intf);
1735 }
1736
1737 #endif /* CONFIG_PM */
1738
1739 static int acm_pre_reset(struct usb_interface *intf)
1740 {
1741         struct acm *acm = usb_get_intfdata(intf);
1742
1743         clear_bit(EVENT_RX_STALL, &acm->flags);
1744         acm->nb_index = 0; /* pending control transfers are lost */
1745
1746         return 0;
1747 }
1748
1749 #define NOKIA_PCSUITE_ACM_INFO(x) \
1750                 USB_DEVICE_AND_INTERFACE_INFO(0x0421, x, \
1751                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1752                 USB_CDC_ACM_PROTO_VENDOR)
1753
1754 #define SAMSUNG_PCSUITE_ACM_INFO(x) \
1755                 USB_DEVICE_AND_INTERFACE_INFO(0x04e7, x, \
1756                 USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, \
1757                 USB_CDC_ACM_PROTO_VENDOR)
1758
1759 /*
1760  * USB driver structure.
1761  */
1762
1763 static const struct usb_device_id acm_ids[] = {
1764         /* quirky and broken devices */
1765         { USB_DEVICE(0x0424, 0x274e), /* Microchip Technology, Inc. (formerly SMSC) */
1766           .driver_info = DISABLE_ECHO, }, /* DISABLE ECHO in termios flag */
1767         { USB_DEVICE(0x076d, 0x0006), /* Denso Cradle CU-321 */
1768         .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1769         { USB_DEVICE(0x17ef, 0x7000), /* Lenovo USB modem */
1770         .driver_info = NO_UNION_NORMAL, },/* has no union descriptor */
1771         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1772         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1773         },
1774         { USB_DEVICE(0x045b, 0x023c),   /* Renesas USB Download mode */
1775         .driver_info = DISABLE_ECHO,    /* Don't echo banner */
1776         },
1777         { USB_DEVICE(0x045b, 0x0248),   /* Renesas USB Download mode */
1778         .driver_info = DISABLE_ECHO,    /* Don't echo banner */
1779         },
1780         { USB_DEVICE(0x045b, 0x024D),   /* Renesas USB Download mode */
1781         .driver_info = DISABLE_ECHO,    /* Don't echo banner */
1782         },
1783         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1784         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1785         },
1786         { USB_DEVICE(0x0e8d, 0x2000), /* MediaTek Inc Preloader */
1787         .driver_info = DISABLE_ECHO, /* DISABLE ECHO in termios flag */
1788         },
1789         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1790         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1791         },
1792         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1793         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1794         },
1795         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1796         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1797         },
1798         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1799         .driver_info = SINGLE_RX_URB,
1800         },
1801         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1802         .driver_info = SINGLE_RX_URB, /* firmware bug */
1803         },
1804         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1805         .driver_info = SINGLE_RX_URB, /* firmware bug */
1806         },
1807         { USB_DEVICE(0x11ca, 0x0201), /* VeriFone Mx870 Gadget Serial */
1808         .driver_info = SINGLE_RX_URB,
1809         },
1810         { USB_DEVICE(0x1965, 0x0018), /* Uniden UBC125XLT */
1811         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1812         },
1813         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1814         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1815         },
1816         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1817         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1818         },
1819         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1820         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1821         },
1822         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1823         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1824         },
1825         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1826         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1827         },
1828         { USB_DEVICE(0x0572, 0x1349), /* Hiro (Conexant) USB MODEM H50228 */
1829         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1830         },
1831         { USB_DEVICE(0x20df, 0x0001), /* Simtec Electronics Entropy Key */
1832         .driver_info = QUIRK_CONTROL_LINE_STATE, },
1833         { USB_DEVICE(0x2184, 0x001c) }, /* GW Instek AFG-2225 */
1834         { USB_DEVICE(0x2184, 0x0036) }, /* GW Instek AFG-125 */
1835         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1836         },
1837         /* Motorola H24 HSPA module: */
1838         { USB_DEVICE(0x22b8, 0x2d91) }, /* modem                                */
1839         { USB_DEVICE(0x22b8, 0x2d92),   /* modem           + diagnostics        */
1840         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1841         },
1842         { USB_DEVICE(0x22b8, 0x2d93),   /* modem + AT port                      */
1843         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1844         },
1845         { USB_DEVICE(0x22b8, 0x2d95),   /* modem + AT port + diagnostics        */
1846         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1847         },
1848         { USB_DEVICE(0x22b8, 0x2d96),   /* modem                         + NMEA */
1849         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1850         },
1851         { USB_DEVICE(0x22b8, 0x2d97),   /* modem           + diagnostics + NMEA */
1852         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1853         },
1854         { USB_DEVICE(0x22b8, 0x2d99),   /* modem + AT port               + NMEA */
1855         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1856         },
1857         { USB_DEVICE(0x22b8, 0x2d9a),   /* modem + AT port + diagnostics + NMEA */
1858         .driver_info = NO_UNION_NORMAL, /* handle only modem interface          */
1859         },
1860
1861         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1862         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1863                                            data interface instead of
1864                                            communications interface.
1865                                            Maybe we should define a new
1866                                            quirk for this. */
1867         },
1868         { USB_DEVICE(0x0572, 0x1340), /* Conexant CX93010-2x UCMxx */
1869         .driver_info = NO_UNION_NORMAL,
1870         },
1871         { USB_DEVICE(0x05f9, 0x4002), /* PSC Scanning, Magellan 800i */
1872         .driver_info = NO_UNION_NORMAL,
1873         },
1874         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1875         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1876         },
1877         { USB_DEVICE(0x1576, 0x03b1), /* Maretron USB100 */
1878         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1879         },
1880         { USB_DEVICE(0xfff0, 0x0100), /* DATECS FP-2000 */
1881         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1882         },
1883         { USB_DEVICE(0x09d8, 0x0320), /* Elatec GmbH TWN3 */
1884         .driver_info = NO_UNION_NORMAL, /* has misplaced union descriptor */
1885         },
1886         { USB_DEVICE(0x0c26, 0x0020), /* Icom ICF3400 Serie */
1887         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1888         },
1889         { USB_DEVICE(0x0ca6, 0xa050), /* Castles VEGA3000 */
1890         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1891         },
1892
1893         { USB_DEVICE(0x2912, 0x0001), /* ATOL FPrint */
1894         .driver_info = CLEAR_HALT_CONDITIONS,
1895         },
1896
1897         /* Nokia S60 phones expose two ACM channels. The first is
1898          * a modem and is picked up by the standard AT-command
1899          * information below. The second is 'vendor-specific' but
1900          * is treated as a serial device at the S60 end, so we want
1901          * to expose it on Linux too. */
1902         { NOKIA_PCSUITE_ACM_INFO(0x042D), }, /* Nokia 3250 */
1903         { NOKIA_PCSUITE_ACM_INFO(0x04D8), }, /* Nokia 5500 Sport */
1904         { NOKIA_PCSUITE_ACM_INFO(0x04C9), }, /* Nokia E50 */
1905         { NOKIA_PCSUITE_ACM_INFO(0x0419), }, /* Nokia E60 */
1906         { NOKIA_PCSUITE_ACM_INFO(0x044D), }, /* Nokia E61 */
1907         { NOKIA_PCSUITE_ACM_INFO(0x0001), }, /* Nokia E61i */
1908         { NOKIA_PCSUITE_ACM_INFO(0x0475), }, /* Nokia E62 */
1909         { NOKIA_PCSUITE_ACM_INFO(0x0508), }, /* Nokia E65 */
1910         { NOKIA_PCSUITE_ACM_INFO(0x0418), }, /* Nokia E70 */
1911         { NOKIA_PCSUITE_ACM_INFO(0x0425), }, /* Nokia N71 */
1912         { NOKIA_PCSUITE_ACM_INFO(0x0486), }, /* Nokia N73 */
1913         { NOKIA_PCSUITE_ACM_INFO(0x04DF), }, /* Nokia N75 */
1914         { NOKIA_PCSUITE_ACM_INFO(0x000e), }, /* Nokia N77 */
1915         { NOKIA_PCSUITE_ACM_INFO(0x0445), }, /* Nokia N80 */
1916         { NOKIA_PCSUITE_ACM_INFO(0x042F), }, /* Nokia N91 & N91 8GB */
1917         { NOKIA_PCSUITE_ACM_INFO(0x048E), }, /* Nokia N92 */
1918         { NOKIA_PCSUITE_ACM_INFO(0x0420), }, /* Nokia N93 */
1919         { NOKIA_PCSUITE_ACM_INFO(0x04E6), }, /* Nokia N93i  */
1920         { NOKIA_PCSUITE_ACM_INFO(0x04B2), }, /* Nokia 5700 XpressMusic */
1921         { NOKIA_PCSUITE_ACM_INFO(0x0134), }, /* Nokia 6110 Navigator (China) */
1922         { NOKIA_PCSUITE_ACM_INFO(0x046E), }, /* Nokia 6110 Navigator */
1923         { NOKIA_PCSUITE_ACM_INFO(0x002f), }, /* Nokia 6120 classic &  */
1924         { NOKIA_PCSUITE_ACM_INFO(0x0088), }, /* Nokia 6121 classic */
1925         { NOKIA_PCSUITE_ACM_INFO(0x00fc), }, /* Nokia 6124 classic */
1926         { NOKIA_PCSUITE_ACM_INFO(0x0042), }, /* Nokia E51 */
1927         { NOKIA_PCSUITE_ACM_INFO(0x00b0), }, /* Nokia E66 */
1928         { NOKIA_PCSUITE_ACM_INFO(0x00ab), }, /* Nokia E71 */
1929         { NOKIA_PCSUITE_ACM_INFO(0x0481), }, /* Nokia N76 */
1930         { NOKIA_PCSUITE_ACM_INFO(0x0007), }, /* Nokia N81 & N81 8GB */
1931         { NOKIA_PCSUITE_ACM_INFO(0x0071), }, /* Nokia N82 */
1932         { NOKIA_PCSUITE_ACM_INFO(0x04F0), }, /* Nokia N95 & N95-3 NAM */
1933         { NOKIA_PCSUITE_ACM_INFO(0x0070), }, /* Nokia N95 8GB  */
1934         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1935         { NOKIA_PCSUITE_ACM_INFO(0x0099), }, /* Nokia 6210 Navigator, RM-367 */
1936         { NOKIA_PCSUITE_ACM_INFO(0x0128), }, /* Nokia 6210 Navigator, RM-419 */
1937         { NOKIA_PCSUITE_ACM_INFO(0x008f), }, /* Nokia 6220 Classic */
1938         { NOKIA_PCSUITE_ACM_INFO(0x00a0), }, /* Nokia 6650 */
1939         { NOKIA_PCSUITE_ACM_INFO(0x007b), }, /* Nokia N78 */
1940         { NOKIA_PCSUITE_ACM_INFO(0x0094), }, /* Nokia N85 */
1941         { NOKIA_PCSUITE_ACM_INFO(0x003a), }, /* Nokia N96 & N96-3  */
1942         { NOKIA_PCSUITE_ACM_INFO(0x00e9), }, /* Nokia 5320 XpressMusic */
1943         { NOKIA_PCSUITE_ACM_INFO(0x0108), }, /* Nokia 5320 XpressMusic 2G */
1944         { NOKIA_PCSUITE_ACM_INFO(0x01f5), }, /* Nokia N97, RM-505 */
1945         { NOKIA_PCSUITE_ACM_INFO(0x02e3), }, /* Nokia 5230, RM-588 */
1946         { NOKIA_PCSUITE_ACM_INFO(0x0178), }, /* Nokia E63 */
1947         { NOKIA_PCSUITE_ACM_INFO(0x010e), }, /* Nokia E75 */
1948         { NOKIA_PCSUITE_ACM_INFO(0x02d9), }, /* Nokia 6760 Slide */
1949         { NOKIA_PCSUITE_ACM_INFO(0x01d0), }, /* Nokia E52 */
1950         { NOKIA_PCSUITE_ACM_INFO(0x0223), }, /* Nokia E72 */
1951         { NOKIA_PCSUITE_ACM_INFO(0x0275), }, /* Nokia X6 */
1952         { NOKIA_PCSUITE_ACM_INFO(0x026c), }, /* Nokia N97 Mini */
1953         { NOKIA_PCSUITE_ACM_INFO(0x0154), }, /* Nokia 5800 XpressMusic */
1954         { NOKIA_PCSUITE_ACM_INFO(0x04ce), }, /* Nokia E90 */
1955         { NOKIA_PCSUITE_ACM_INFO(0x01d4), }, /* Nokia E55 */
1956         { NOKIA_PCSUITE_ACM_INFO(0x0302), }, /* Nokia N8 */
1957         { NOKIA_PCSUITE_ACM_INFO(0x0335), }, /* Nokia E7 */
1958         { NOKIA_PCSUITE_ACM_INFO(0x03cd), }, /* Nokia C7 */
1959         { SAMSUNG_PCSUITE_ACM_INFO(0x6651), }, /* Samsung GTi8510 (INNOV8) */
1960
1961         /* Support for Owen devices */
1962         { USB_DEVICE(0x03eb, 0x0030), }, /* Owen SI30 */
1963
1964         /* NOTE: non-Nokia COMM/ACM/0xff is likely MSFT RNDIS... NOT a modem! */
1965
1966         /* Support for Droids MuIn LCD */
1967         { USB_DEVICE(0x04d8, 0x000b),
1968         .driver_info = NO_DATA_INTERFACE,
1969         },
1970
1971 #if IS_ENABLED(CONFIG_INPUT_IMS_PCU)
1972         { USB_DEVICE(0x04d8, 0x0082),   /* Application mode */
1973         .driver_info = IGNORE_DEVICE,
1974         },
1975         { USB_DEVICE(0x04d8, 0x0083),   /* Bootloader mode */
1976         .driver_info = IGNORE_DEVICE,
1977         },
1978
1979         { USB_DEVICE(0x04d8, 0xf58b),
1980         .driver_info = IGNORE_DEVICE,
1981         },
1982 #endif
1983
1984         /*Samsung phone in firmware update mode */
1985         { USB_DEVICE(0x04e8, 0x685d),
1986         .driver_info = IGNORE_DEVICE,
1987         },
1988
1989         /* Exclude Infineon Flash Loader utility */
1990         { USB_DEVICE(0x058b, 0x0041),
1991         .driver_info = IGNORE_DEVICE,
1992         },
1993
1994         /* Exclude ETAS ES58x */
1995         { USB_DEVICE(0x108c, 0x0159), /* ES581.4 */
1996         .driver_info = IGNORE_DEVICE,
1997         },
1998         { USB_DEVICE(0x108c, 0x0168), /* ES582.1 */
1999         .driver_info = IGNORE_DEVICE,
2000         },
2001         { USB_DEVICE(0x108c, 0x0169), /* ES584.1 */
2002         .driver_info = IGNORE_DEVICE,
2003         },
2004
2005         { USB_DEVICE(0x1bc7, 0x0021), /* Telit 3G ACM only composition */
2006         .driver_info = SEND_ZERO_PACKET,
2007         },
2008         { USB_DEVICE(0x1bc7, 0x0023), /* Telit 3G ACM + ECM composition */
2009         .driver_info = SEND_ZERO_PACKET,
2010         },
2011
2012         /* Exclude Goodix Fingerprint Reader */
2013         { USB_DEVICE(0x27c6, 0x5395),
2014         .driver_info = IGNORE_DEVICE,
2015         },
2016
2017         /* Exclude Heimann Sensor GmbH USB appset demo */
2018         { USB_DEVICE(0x32a7, 0x0000),
2019         .driver_info = IGNORE_DEVICE,
2020         },
2021
2022         /* control interfaces without any protocol set */
2023         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2024                 USB_CDC_PROTO_NONE) },
2025
2026         /* control interfaces with various AT-command sets */
2027         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2028                 USB_CDC_ACM_PROTO_AT_V25TER) },
2029         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2030                 USB_CDC_ACM_PROTO_AT_PCCA101) },
2031         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2032                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
2033         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2034                 USB_CDC_ACM_PROTO_AT_GSM) },
2035         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2036                 USB_CDC_ACM_PROTO_AT_3G) },
2037         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
2038                 USB_CDC_ACM_PROTO_AT_CDMA) },
2039
2040         { USB_DEVICE(0x1519, 0x0452), /* Intel 7260 modem */
2041         .driver_info = SEND_ZERO_PACKET,
2042         },
2043
2044         { }
2045 };
2046
2047 MODULE_DEVICE_TABLE(usb, acm_ids);
2048
2049 static struct usb_driver acm_driver = {
2050         .name =         "cdc_acm",
2051         .probe =        acm_probe,
2052         .disconnect =   acm_disconnect,
2053 #ifdef CONFIG_PM
2054         .suspend =      acm_suspend,
2055         .resume =       acm_resume,
2056         .reset_resume = acm_reset_resume,
2057 #endif
2058         .pre_reset =    acm_pre_reset,
2059         .id_table =     acm_ids,
2060 #ifdef CONFIG_PM
2061         .supports_autosuspend = 1,
2062 #endif
2063         .disable_hub_initiated_lpm = 1,
2064 };
2065
2066 /*
2067  * TTY driver structures.
2068  */
2069
2070 static const struct tty_operations acm_ops = {
2071         .install =              acm_tty_install,
2072         .open =                 acm_tty_open,
2073         .close =                acm_tty_close,
2074         .cleanup =              acm_tty_cleanup,
2075         .hangup =               acm_tty_hangup,
2076         .write =                acm_tty_write,
2077         .write_room =           acm_tty_write_room,
2078         .ioctl =                acm_tty_ioctl,
2079         .throttle =             acm_tty_throttle,
2080         .unthrottle =           acm_tty_unthrottle,
2081         .chars_in_buffer =      acm_tty_chars_in_buffer,
2082         .break_ctl =            acm_tty_break_ctl,
2083         .set_termios =          acm_tty_set_termios,
2084         .tiocmget =             acm_tty_tiocmget,
2085         .tiocmset =             acm_tty_tiocmset,
2086         .get_icount =           acm_tty_get_icount,
2087 };
2088
2089 /*
2090  * Init / exit.
2091  */
2092
2093 static int __init acm_init(void)
2094 {
2095         int retval;
2096         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
2097         if (!acm_tty_driver)
2098                 return -ENOMEM;
2099         acm_tty_driver->driver_name = "acm",
2100         acm_tty_driver->name = "ttyACM",
2101         acm_tty_driver->major = ACM_TTY_MAJOR,
2102         acm_tty_driver->minor_start = 0,
2103         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
2104         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
2105         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2106         acm_tty_driver->init_termios = tty_std_termios;
2107         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
2108                                                                 HUPCL | CLOCAL;
2109         tty_set_operations(acm_tty_driver, &acm_ops);
2110
2111         retval = tty_register_driver(acm_tty_driver);
2112         if (retval) {
2113                 put_tty_driver(acm_tty_driver);
2114                 return retval;
2115         }
2116
2117         retval = usb_register(&acm_driver);
2118         if (retval) {
2119                 tty_unregister_driver(acm_tty_driver);
2120                 put_tty_driver(acm_tty_driver);
2121                 return retval;
2122         }
2123
2124         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
2125
2126         return 0;
2127 }
2128
2129 static void __exit acm_exit(void)
2130 {
2131         usb_deregister(&acm_driver);
2132         tty_unregister_driver(acm_tty_driver);
2133         put_tty_driver(acm_tty_driver);
2134         idr_destroy(&acm_minors);
2135 }
2136
2137 module_init(acm_init);
2138 module_exit(acm_exit);
2139
2140 MODULE_AUTHOR(DRIVER_AUTHOR);
2141 MODULE_DESCRIPTION(DRIVER_DESC);
2142 MODULE_LICENSE("GPL");
2143 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);