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