git.oblomov.eu Git - linux-2.6/blob - drivers/usb/class/cdc-acm.c

   1 /*
   2  * cdc-acm.c
   3  *
   4  * Copyright (c) 1999 Armin Fuerst      <fuerst@in.tum.de>
   5  * Copyright (c) 1999 Pavel Machek      <pavel@suse.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  *
  11  * USB Abstract Control Model driver for USB modems and ISDN adapters
  12  *
  13  * Sponsored by SuSE
  14  *
  15  * ChangeLog:
  16  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  17  *      v0.10 - some more cleanups
  18  *      v0.11 - fixed flow control, read error doesn't stop reads
  19  *      v0.12 - added TIOCM ioctls, added break handling, made struct acm
  20  *              kmalloced
  21  *      v0.13 - added termios, added hangup
  22  *      v0.14 - sized down struct acm
  23  *      v0.15 - fixed flow control again - characters could be lost
  24  *      v0.16 - added code for modems with swapped data and control interfaces
  25  *      v0.17 - added new style probing
  26  *      v0.18 - fixed new style probing for devices with more configurations
  27  *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  28  *      v0.20 - switched to probing on interface (rather than device) class
  29  *      v0.21 - revert to probing on device for devices with multiple configs
  30  *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  31  *              config we want, sysadmin changes bConfigurationValue in sysfs.
  32  *      v0.23 - use softirq for rx processing, as needed by tty layer
  33  *      v0.24 - change probe method to evaluate CDC union descriptor
  34  *      v0.25 - downstream tasks paralelized to maximize throughput
  35  *      v0.26 - multiple write urbs, writesize increased
  36  */
  37
  38 /*
  39  * This program is free software; you can redistribute it and/or modify
  40  * it under the terms of the GNU General Public License as published by
  41  * the Free Software Foundation; either version 2 of the License, or
  42  * (at your option) any later version.
  43  *
  44  * This program is distributed in the hope that it will be useful,
  45  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  46  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  47  * GNU General Public License for more details.
  48  *
  49  * You should have received a copy of the GNU General Public License
  50  * along with this program; if not, write to the Free Software
  51  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  52  */
  53
  54 #undef DEBUG
  55 #undef VERBOSE_DEBUG
  56
  57 #include <linux/kernel.h>
  58 #include <linux/errno.h>
  59 #include <linux/init.h>
  60 #include <linux/slab.h>
  61 #include <linux/tty.h>
  62 #include <linux/tty_driver.h>
  63 #include <linux/tty_flip.h>
  64 #include <linux/module.h>
  65 #include <linux/mutex.h>
  66 #include <linux/uaccess.h>
  67 #include <linux/usb.h>
  68 #include <linux/usb/cdc.h>
  69 #include <asm/byteorder.h>
  70 #include <asm/unaligned.h>
  71 #include <linux/list.h>
  72
  73 #include "cdc-acm.h"
  74
  75
  76 #define ACM_CLOSE_TIMEOUT       15      /* seconds to let writes drain */
  77
  78 /*
  79  * Version Information
  80  */
  81 #define DRIVER_VERSION "v0.26"
  82 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  83 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  84
  85 static struct usb_driver acm_driver;
  86 static struct tty_driver *acm_tty_driver;
  87 static struct acm *acm_table[ACM_TTY_MINORS];
  88
  89 static DEFINE_MUTEX(open_mutex);
  90
  91 #define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
  92
  93 static const struct tty_port_operations acm_port_ops = {
  94 };
  95
  96 #ifdef VERBOSE_DEBUG
  97 #define verbose 1
  98 #else
  99 #define verbose 0
 100 #endif
 101
 102 /*
 103  * Functions for ACM control messages.
 104  */
 105
 106 static int acm_ctrl_msg(struct acm *acm, int request, int value,
 107                                                         void *buf, int len)
 108 {
 109         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
 110                 request, USB_RT_ACM, value,
 111                 acm->control->altsetting[0].desc.bInterfaceNumber,
 112                 buf, len, 5000);
 113         dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
 114                                                 request, value, len, retval);
 115         return retval < 0 ? retval : 0;
 116 }
 117
 118 /* devices aren't required to support these requests.
 119  * the cdc acm descriptor tells whether they do...
 120  */
 121 #define acm_set_control(acm, control) \
 122         acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 123 #define acm_set_line(acm, line) \
 124         acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 125 #define acm_send_break(acm, ms) \
 126         acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 127
 128 /*
 129  * Write buffer management.
 130  * All of these assume proper locks taken by the caller.
 131  */
 132
 133 static int acm_wb_alloc(struct acm *acm)
 134 {
 135         int i, wbn;
 136         struct acm_wb *wb;
 137
 138         wbn = 0;
 139         i = 0;
 140         for (;;) {
 141                 wb = &acm->wb[wbn];
 142                 if (!wb->use) {
 143                         wb->use = 1;
 144                         return wbn;
 145                 }
 146                 wbn = (wbn + 1) % ACM_NW;
 147                 if (++i >= ACM_NW)
 148                         return -1;
 149         }
 150 }
 151
 152 static int acm_wb_is_avail(struct acm *acm)
 153 {
 154         int i, n;
 155         unsigned long flags;
 156
 157         n = ACM_NW;
 158         spin_lock_irqsave(&acm->write_lock, flags);
 159         for (i = 0; i < ACM_NW; i++)
 160                 n -= acm->wb[i].use;
 161         spin_unlock_irqrestore(&acm->write_lock, flags);
 162         return n;
 163 }
 164
 165 /*
 166  * Finish write. Caller must hold acm->write_lock
 167  */
 168 static void acm_write_done(struct acm *acm, struct acm_wb *wb)
 169 {
 170         wb->use = 0;
 171         acm->transmitting--;
 172 }
 173
 174 /*
 175  * Poke write.
 176  *
 177  * the caller is responsible for locking
 178  */
 179
 180 static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
 181 {
 182         int rc;
 183
 184         acm->transmitting++;
 185
 186         wb->urb->transfer_buffer = wb->buf;
 187         wb->urb->transfer_dma = wb->dmah;
 188         wb->urb->transfer_buffer_length = wb->len;
 189         wb->urb->dev = acm->dev;
 190
 191         rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
 192         if (rc < 0) {
 193                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
 194                 acm_write_done(acm, wb);
 195         }
 196         return rc;
 197 }
 198
 199 static int acm_write_start(struct acm *acm, int wbn)
 200 {
 201         unsigned long flags;
 202         struct acm_wb *wb = &acm->wb[wbn];
 203         int rc;
 204
 205         spin_lock_irqsave(&acm->write_lock, flags);
 206         if (!acm->dev) {
 207                 wb->use = 0;
 208                 spin_unlock_irqrestore(&acm->write_lock, flags);
 209                 return -ENODEV;
 210         }
 211
 212         dbg("%s susp_count: %d", __func__, acm->susp_count);
 213         if (acm->susp_count) {
 214                 acm->delayed_wb = wb;
 215                 schedule_work(&acm->waker);
 216                 spin_unlock_irqrestore(&acm->write_lock, flags);
 217                 return 0;       /* A white lie */
 218         }
 219         usb_mark_last_busy(acm->dev);
 220
 221         rc = acm_start_wb(acm, wb);
 222         spin_unlock_irqrestore(&acm->write_lock, flags);
 223
 224         return rc;
 225
 226 }
 227 /*
 228  * attributes exported through sysfs
 229  */
 230 static ssize_t show_caps
 231 (struct device *dev, struct device_attribute *attr, char *buf)
 232 {
 233         struct usb_interface *intf = to_usb_interface(dev);
 234         struct acm *acm = usb_get_intfdata(intf);
 235
 236         return sprintf(buf, "%d", acm->ctrl_caps);
 237 }
 238 static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
 239
 240 static ssize_t show_country_codes
 241 (struct device *dev, struct device_attribute *attr, char *buf)
 242 {
 243         struct usb_interface *intf = to_usb_interface(dev);
 244         struct acm *acm = usb_get_intfdata(intf);
 245
 246         memcpy(buf, acm->country_codes, acm->country_code_size);
 247         return acm->country_code_size;
 248 }
 249
 250 static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
 251
 252 static ssize_t show_country_rel_date
 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->country_rel_date);
 259 }
 260
 261 static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
 262 /*
 263  * Interrupt handlers for various ACM device responses
 264  */
 265
 266 /* control interface reports status changes with "interrupt" transfers */
 267 static void acm_ctrl_irq(struct urb *urb)
 268 {
 269         struct acm *acm = urb->context;
 270         struct usb_cdc_notification *dr = urb->transfer_buffer;
 271         struct tty_struct *tty;
 272         unsigned char *data;
 273         int newctrl;
 274         int retval;
 275         int status = urb->status;
 276
 277         switch (status) {
 278         case 0:
 279                 /* success */
 280                 break;
 281         case -ECONNRESET:
 282         case -ENOENT:
 283         case -ESHUTDOWN:
 284                 /* this urb is terminated, clean up */
 285                 dbg("%s - urb shutting down with status: %d", __func__, status);
 286                 return;
 287         default:
 288                 dbg("%s - nonzero urb status received: %d", __func__, status);
 289                 goto exit;
 290         }
 291
 292         if (!ACM_READY(acm))
 293                 goto exit;
 294
 295         data = (unsigned char *)(dr + 1);
 296         switch (dr->bNotificationType) {
 297         case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 298                 dbg("%s network", dr->wValue ?
 299                                         "connected to" : "disconnected from");
 300                 break;
 301
 302         case USB_CDC_NOTIFY_SERIAL_STATE:
 303                 tty = tty_port_tty_get(&acm->port);
 304                 newctrl = get_unaligned_le16(data);
 305
 306                 if (tty) {
 307                         if (!acm->clocal &&
 308                                 (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 309                                 dbg("calling hangup");
 310                                 tty_hangup(tty);
 311                         }
 312                         tty_kref_put(tty);
 313                 }
 314
 315                 acm->ctrlin = newctrl;
 316
 317                 dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 318                         acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
 319                         acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 320                         acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
 321                         acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 322                         acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
 323                         acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 324                         acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 325                         break;
 326
 327         default:
 328                 dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 329                         dr->bNotificationType, dr->wIndex,
 330                         dr->wLength, data[0], data[1]);
 331                 break;
 332         }
 333 exit:
 334         usb_mark_last_busy(acm->dev);
 335         retval = usb_submit_urb(urb, GFP_ATOMIC);
 336         if (retval)
 337                 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
 338                         "result %d", __func__, retval);
 339 }
 340
 341 /* data interface returns incoming bytes, or we got unthrottled */
 342 static void acm_read_bulk(struct urb *urb)
 343 {
 344         struct acm_rb *buf;
 345         struct acm_ru *rcv = urb->context;
 346         struct acm *acm = rcv->instance;
 347         int status = urb->status;
 348
 349         dbg("Entering acm_read_bulk with status %d", status);
 350
 351         if (!ACM_READY(acm)) {
 352                 dev_dbg(&acm->data->dev, "Aborting, acm not ready");
 353                 return;
 354         }
 355         usb_mark_last_busy(acm->dev);
 356
 357         if (status)
 358                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
 359
 360         buf = rcv->buffer;
 361         buf->size = urb->actual_length;
 362
 363         if (likely(status == 0)) {
 364                 spin_lock(&acm->read_lock);
 365                 acm->processing++;
 366                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 367                 list_add_tail(&buf->list, &acm->filled_read_bufs);
 368                 spin_unlock(&acm->read_lock);
 369         } else {
 370                 /* we drop the buffer due to an error */
 371                 spin_lock(&acm->read_lock);
 372                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
 373                 list_add(&buf->list, &acm->spare_read_bufs);
 374                 spin_unlock(&acm->read_lock);
 375                 /* nevertheless the tasklet must be kicked unconditionally
 376                 so the queue cannot dry up */
 377         }
 378         if (likely(!acm->susp_count))
 379                 tasklet_schedule(&acm->urb_task);
 380 }
 381
 382 static void acm_rx_tasklet(unsigned long _acm)
 383 {
 384         struct acm *acm = (void *)_acm;
 385         struct acm_rb *buf;
 386         struct tty_struct *tty;
 387         struct acm_ru *rcv;
 388         unsigned long flags;
 389         unsigned char throttled;
 390         struct usb_host_endpoint *ep;
 391
 392         dbg("Entering acm_rx_tasklet");
 393
 394         if (!ACM_READY(acm)) {
 395                 dbg("acm_rx_tasklet: ACM not ready");
 396                 return;
 397         }
 398
 399         spin_lock_irqsave(&acm->throttle_lock, flags);
 400         throttled = acm->throttle;
 401         spin_unlock_irqrestore(&acm->throttle_lock, flags);
 402         if (throttled) {
 403                 dbg("acm_rx_tasklet: throttled");
 404                 return;
 405         }
 406
 407         tty = tty_port_tty_get(&acm->port);
 408
 409 next_buffer:
 410         spin_lock_irqsave(&acm->read_lock, flags);
 411         if (list_empty(&acm->filled_read_bufs)) {
 412                 spin_unlock_irqrestore(&acm->read_lock, flags);
 413                 goto urbs;
 414         }
 415         buf = list_entry(acm->filled_read_bufs.next,
 416                          struct acm_rb, list);
 417         list_del(&buf->list);
 418         spin_unlock_irqrestore(&acm->read_lock, flags);
 419
 420         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 421
 422         if (tty) {
 423                 spin_lock_irqsave(&acm->throttle_lock, flags);
 424                 throttled = acm->throttle;
 425                 spin_unlock_irqrestore(&acm->throttle_lock, flags);
 426                 if (!throttled) {
 427                         tty_buffer_request_room(tty, buf->size);
 428                         tty_insert_flip_string(tty, buf->base, buf->size);
 429                         tty_flip_buffer_push(tty);
 430                 } else {
 431                         tty_kref_put(tty);
 432                         dbg("Throttling noticed");
 433                         spin_lock_irqsave(&acm->read_lock, flags);
 434                         list_add(&buf->list, &acm->filled_read_bufs);
 435                         spin_unlock_irqrestore(&acm->read_lock, flags);
 436                         return;
 437                 }
 438         }
 439
 440         spin_lock_irqsave(&acm->read_lock, flags);
 441         list_add(&buf->list, &acm->spare_read_bufs);
 442         spin_unlock_irqrestore(&acm->read_lock, flags);
 443         goto next_buffer;
 444
 445 urbs:
 446         tty_kref_put(tty);
 447
 448         while (!list_empty(&acm->spare_read_bufs)) {
 449                 spin_lock_irqsave(&acm->read_lock, flags);
 450                 if (list_empty(&acm->spare_read_urbs)) {
 451                         acm->processing = 0;
 452                         spin_unlock_irqrestore(&acm->read_lock, flags);
 453                         return;
 454                 }
 455                 rcv = list_entry(acm->spare_read_urbs.next,
 456                                  struct acm_ru, list);
 457                 list_del(&rcv->list);
 458                 spin_unlock_irqrestore(&acm->read_lock, flags);
 459
 460                 buf = list_entry(acm->spare_read_bufs.next,
 461                                  struct acm_rb, list);
 462                 list_del(&buf->list);
 463
 464                 rcv->buffer = buf;
 465
 466                 ep = (usb_pipein(acm->rx_endpoint) ? acm->dev->ep_in : acm->dev->ep_out)
 467                                 [usb_pipeendpoint(acm->rx_endpoint)];
 468                 if (usb_endpoint_xfer_int(&ep->desc))
 469                         usb_fill_int_urb(rcv->urb, acm->dev,
 470                                          acm->rx_endpoint,
 471                                          buf->base,
 472                                          acm->readsize,
 473                                          acm_read_bulk, rcv, ep->desc.bInterval);
 474                 else
 475                         usb_fill_bulk_urb(rcv->urb, acm->dev,
 476                                           acm->rx_endpoint,
 477                                           buf->base,
 478                                           acm->readsize,
 479                                           acm_read_bulk, rcv);
 480                 rcv->urb->transfer_dma = buf->dma;
 481                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 482
 483                 /* This shouldn't kill the driver as unsuccessful URBs are
 484                    returned to the free-urbs-pool and resubmited ASAP */
 485                 spin_lock_irqsave(&acm->read_lock, flags);
 486                 if (acm->susp_count ||
 487                                 usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 488                         list_add(&buf->list, &acm->spare_read_bufs);
 489                         list_add(&rcv->list, &acm->spare_read_urbs);
 490                         acm->processing = 0;
 491                         spin_unlock_irqrestore(&acm->read_lock, flags);
 492                         return;
 493                 } else {
 494                         spin_unlock_irqrestore(&acm->read_lock, flags);
 495                         dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 496                 }
 497         }
 498         spin_lock_irqsave(&acm->read_lock, flags);
 499         acm->processing = 0;
 500         spin_unlock_irqrestore(&acm->read_lock, flags);
 501 }
 502
 503 /* data interface wrote those outgoing bytes */
 504 static void acm_write_bulk(struct urb *urb)
 505 {
 506         struct acm_wb *wb = urb->context;
 507         struct acm *acm = wb->instance;
 508         unsigned long flags;
 509
 510         if (verbose || urb->status
 511                         || (urb->actual_length != urb->transfer_buffer_length))
 512                 dev_dbg(&acm->data->dev, "tx %d/%d bytes -- > %d\n",
 513                         urb->actual_length,
 514                         urb->transfer_buffer_length,
 515                         urb->status);
 516
 517         spin_lock_irqsave(&acm->write_lock, flags);
 518         acm_write_done(acm, wb);
 519         spin_unlock_irqrestore(&acm->write_lock, flags);
 520         if (ACM_READY(acm))
 521                 schedule_work(&acm->work);
 522         else
 523                 wake_up_interruptible(&acm->drain_wait);
 524 }
 525
 526 static void acm_softint(struct work_struct *work)
 527 {
 528         struct acm *acm = container_of(work, struct acm, work);
 529         struct tty_struct *tty;
 530
 531         dev_vdbg(&acm->data->dev, "tx work\n");
 532         if (!ACM_READY(acm))
 533                 return;
 534         tty = tty_port_tty_get(&acm->port);
 535         tty_wakeup(tty);
 536         tty_kref_put(tty);
 537 }
 538
 539 static void acm_waker(struct work_struct *waker)
 540 {
 541         struct acm *acm = container_of(waker, struct acm, waker);
 542         int rv;
 543
 544         rv = usb_autopm_get_interface(acm->control);
 545         if (rv < 0) {
 546                 dev_err(&acm->dev->dev, "Autopm failure in %s\n", __func__);
 547                 return;
 548         }
 549         if (acm->delayed_wb) {
 550                 acm_start_wb(acm, acm->delayed_wb);
 551                 acm->delayed_wb = NULL;
 552         }
 553         usb_autopm_put_interface(acm->control);
 554 }
 555
 556 /*
 557  * TTY handlers
 558  */
 559
 560 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 561 {
 562         struct acm *acm;
 563         int rv = -ENODEV;
 564         int i;
 565         dbg("Entering acm_tty_open.");
 566
 567         mutex_lock(&open_mutex);
 568
 569         acm = acm_table[tty->index];
 570         if (!acm || !acm->dev)
 571                 goto err_out;
 572         else
 573                 rv = 0;
 574
 575         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
 576
 577         tty->driver_data = acm;
 578         tty_port_tty_set(&acm->port, tty);
 579
 580         if (usb_autopm_get_interface(acm->control) < 0)
 581                 goto early_bail;
 582         else
 583                 acm->control->needs_remote_wakeup = 1;
 584
 585         mutex_lock(&acm->mutex);
 586         if (acm->port.count++) {
 587                 usb_autopm_put_interface(acm->control);
 588                 goto done;
 589         }
 590
 591         acm->ctrlurb->dev = acm->dev;
 592         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 593                 dbg("usb_submit_urb(ctrl irq) failed");
 594                 goto bail_out;
 595         }
 596
 597         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
 598             (acm->ctrl_caps & USB_CDC_CAP_LINE))
 599                 goto full_bailout;
 600
 601         usb_autopm_put_interface(acm->control);
 602
 603         INIT_LIST_HEAD(&acm->spare_read_urbs);
 604         INIT_LIST_HEAD(&acm->spare_read_bufs);
 605         INIT_LIST_HEAD(&acm->filled_read_bufs);
 606
 607         for (i = 0; i < acm->rx_buflimit; i++)
 608                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 609         for (i = 0; i < acm->rx_buflimit; i++)
 610                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 611
 612         acm->throttle = 0;
 613
 614         tasklet_schedule(&acm->urb_task);
 615         rv = tty_port_block_til_ready(&acm->port, tty, filp);
 616 done:
 617         mutex_unlock(&acm->mutex);
 618 err_out:
 619         mutex_unlock(&open_mutex);
 620         return rv;
 621
 622 full_bailout:
 623         usb_kill_urb(acm->ctrlurb);
 624 bail_out:
 625         usb_autopm_put_interface(acm->control);
 626         acm->port.count--;
 627         mutex_unlock(&acm->mutex);
 628 early_bail:
 629         mutex_unlock(&open_mutex);
 630         tty_port_tty_set(&acm->port, NULL);
 631         return -EIO;
 632 }
 633
 634 static void acm_tty_unregister(struct acm *acm)
 635 {
 636         int i, nr;
 637
 638         nr = acm->rx_buflimit;
 639         tty_unregister_device(acm_tty_driver, acm->minor);
 640         usb_put_intf(acm->control);
 641         acm_table[acm->minor] = NULL;
 642         usb_free_urb(acm->ctrlurb);
 643         for (i = 0; i < ACM_NW; i++)
 644                 usb_free_urb(acm->wb[i].urb);
 645         for (i = 0; i < nr; i++)
 646                 usb_free_urb(acm->ru[i].urb);
 647         kfree(acm->country_codes);
 648         kfree(acm);
 649 }
 650
 651 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
 652
 653 static void acm_port_down(struct acm *acm, int drain)
 654 {
 655         int i, nr = acm->rx_buflimit;
 656         mutex_lock(&open_mutex);
 657         if (acm->dev) {
 658                 usb_autopm_get_interface(acm->control);
 659                 acm_set_control(acm, acm->ctrlout = 0);
 660                 /* try letting the last writes drain naturally */
 661                 if (drain) {
 662                         wait_event_interruptible_timeout(acm->drain_wait,
 663                                 (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,
 664                                         ACM_CLOSE_TIMEOUT * HZ);
 665                 }
 666                 usb_kill_urb(acm->ctrlurb);
 667                 for (i = 0; i < ACM_NW; i++)
 668                         usb_kill_urb(acm->wb[i].urb);
 669                 for (i = 0; i < nr; i++)
 670                         usb_kill_urb(acm->ru[i].urb);
 671                 acm->control->needs_remote_wakeup = 0;
 672                 usb_autopm_put_interface(acm->control);
 673         }
 674         mutex_unlock(&open_mutex);
 675 }
 676
 677 static void acm_tty_hangup(struct tty_struct *tty)
 678 {
 679         struct acm *acm = tty->driver_data;
 680         tty_port_hangup(&acm->port);
 681         acm_port_down(acm, 0);
 682 }
 683
 684 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 685 {
 686         struct acm *acm = tty->driver_data;
 687
 688         /* Perform the closing process and see if we need to do the hardware
 689            shutdown */
 690         if (!acm || tty_port_close_start(&acm->port, tty, filp) == 0)
 691                 return;
 692         acm_port_down(acm, 0);
 693         tty_port_close_end(&acm->port, tty);
 694         mutex_lock(&open_mutex);
 695         tty_port_tty_set(&acm->port, NULL);
 696         if (!acm->dev)
 697                 acm_tty_unregister(acm);
 698         mutex_unlock(&open_mutex);
 699 }
 700
 701 static int acm_tty_write(struct tty_struct *tty,
 702                                         const unsigned char *buf, int count)
 703 {
 704         struct acm *acm = tty->driver_data;
 705         int stat;
 706         unsigned long flags;
 707         int wbn;
 708         struct acm_wb *wb;
 709
 710         dbg("Entering acm_tty_write to write %d bytes,", count);
 711
 712         if (!ACM_READY(acm))
 713                 return -EINVAL;
 714         if (!count)
 715                 return 0;
 716
 717         spin_lock_irqsave(&acm->write_lock, flags);
 718         wbn = acm_wb_alloc(acm);
 719         if (wbn < 0) {
 720                 spin_unlock_irqrestore(&acm->write_lock, flags);
 721                 return 0;
 722         }
 723         wb = &acm->wb[wbn];
 724
 725         count = (count > acm->writesize) ? acm->writesize : count;
 726         dbg("Get %d bytes...", count);
 727         memcpy(wb->buf, buf, count);
 728         wb->len = count;
 729         spin_unlock_irqrestore(&acm->write_lock, flags);
 730
 731         stat = acm_write_start(acm, wbn);
 732         if (stat < 0)
 733                 return stat;
 734         return count;
 735 }
 736
 737 static int acm_tty_write_room(struct tty_struct *tty)
 738 {
 739         struct acm *acm = tty->driver_data;
 740         if (!ACM_READY(acm))
 741                 return -EINVAL;
 742         /*
 743          * Do not let the line discipline to know that we have a reserve,
 744          * or it might get too enthusiastic.
 745          */
 746         return acm_wb_is_avail(acm) ? acm->writesize : 0;
 747 }
 748
 749 static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 750 {
 751         struct acm *acm = tty->driver_data;
 752         if (!ACM_READY(acm))
 753                 return 0;
 754         /*
 755          * This is inaccurate (overcounts), but it works.
 756          */
 757         return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 758 }
 759
 760 static void acm_tty_throttle(struct tty_struct *tty)
 761 {
 762         struct acm *acm = tty->driver_data;
 763         if (!ACM_READY(acm))
 764                 return;
 765         spin_lock_bh(&acm->throttle_lock);
 766         acm->throttle = 1;
 767         spin_unlock_bh(&acm->throttle_lock);
 768 }
 769
 770 static void acm_tty_unthrottle(struct tty_struct *tty)
 771 {
 772         struct acm *acm = tty->driver_data;
 773         if (!ACM_READY(acm))
 774                 return;
 775         spin_lock_bh(&acm->throttle_lock);
 776         acm->throttle = 0;
 777         spin_unlock_bh(&acm->throttle_lock);
 778         tasklet_schedule(&acm->urb_task);
 779 }
 780
 781 static int acm_tty_break_ctl(struct tty_struct *tty, int state)
 782 {
 783         struct acm *acm = tty->driver_data;
 784         int retval;
 785         if (!ACM_READY(acm))
 786                 return -EINVAL;
 787         retval = acm_send_break(acm, state ? 0xffff : 0);
 788         if (retval < 0)
 789                 dbg("send break failed");
 790         return retval;
 791 }
 792
 793 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 794 {
 795         struct acm *acm = tty->driver_data;
 796
 797         if (!ACM_READY(acm))
 798                 return -EINVAL;
 799
 800         return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 801                (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 802                (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 803                (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 804                (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 805                TIOCM_CTS;
 806 }
 807
 808 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 809                             unsigned int set, unsigned int clear)
 810 {
 811         struct acm *acm = tty->driver_data;
 812         unsigned int newctrl;
 813
 814         if (!ACM_READY(acm))
 815                 return -EINVAL;
 816
 817         newctrl = acm->ctrlout;
 818         set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 819                                         (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 820         clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
 821                                         (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 822
 823         newctrl = (newctrl & ~clear) | set;
 824
 825         if (acm->ctrlout == newctrl)
 826                 return 0;
 827         return acm_set_control(acm, acm->ctrlout = newctrl);
 828 }
 829
 830 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
 831                                         unsigned int cmd, unsigned long arg)
 832 {
 833         struct acm *acm = tty->driver_data;
 834
 835         if (!ACM_READY(acm))
 836                 return -EINVAL;
 837
 838         return -ENOIOCTLCMD;
 839 }
 840
 841 static const __u32 acm_tty_speed[] = {
 842         0, 50, 75, 110, 134, 150, 200, 300, 600,
 843         1200, 1800, 2400, 4800, 9600, 19200, 38400,
 844         57600, 115200, 230400, 460800, 500000, 576000,
 845         921600, 1000000, 1152000, 1500000, 2000000,
 846         2500000, 3000000, 3500000, 4000000
 847 };
 848
 849 static const __u8 acm_tty_size[] = {
 850         5, 6, 7, 8
 851 };
 852
 853 static void acm_tty_set_termios(struct tty_struct *tty,
 854                                                 struct ktermios *termios_old)
 855 {
 856         struct acm *acm = tty->driver_data;
 857         struct ktermios *termios = tty->termios;
 858         struct usb_cdc_line_coding newline;
 859         int newctrl = acm->ctrlout;
 860
 861         if (!ACM_READY(acm))
 862                 return;
 863
 864         /* FIXME: Needs to support the tty_baud interface */
 865         /* FIXME: Broken on sparc */
 866         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 867                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 868         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 869         newline.bParityType = termios->c_cflag & PARENB ?
 870                                 (termios->c_cflag & PARODD ? 1 : 2) +
 871                                 (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 872         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 873         /* FIXME: Needs to clear unsupported bits in the termios */
 874         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 875
 876         if (!newline.dwDTERate) {
 877                 newline.dwDTERate = acm->line.dwDTERate;
 878                 newctrl &= ~ACM_CTRL_DTR;
 879         } else
 880                 newctrl |=  ACM_CTRL_DTR;
 881
 882         if (newctrl != acm->ctrlout)
 883                 acm_set_control(acm, acm->ctrlout = newctrl);
 884
 885         if (memcmp(&acm->line, &newline, sizeof newline)) {
 886                 memcpy(&acm->line, &newline, sizeof newline);
 887                 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 888                         newline.bCharFormat, newline.bParityType,
 889                         newline.bDataBits);
 890                 acm_set_line(acm, &acm->line);
 891         }
 892 }
 893
 894 /*
 895  * USB probe and disconnect routines.
 896  */
 897
 898 /* Little helpers: write/read buffers free */
 899 static void acm_write_buffers_free(struct acm *acm)
 900 {
 901         int i;
 902         struct acm_wb *wb;
 903         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 904
 905         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
 906                 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
 907 }
 908
 909 static void acm_read_buffers_free(struct acm *acm)
 910 {
 911         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 912         int i, n = acm->rx_buflimit;
 913
 914         for (i = 0; i < n; i++)
 915                 usb_buffer_free(usb_dev, acm->readsize,
 916                                         acm->rb[i].base, acm->rb[i].dma);
 917 }
 918
 919 /* Little helper: write buffers allocate */
 920 static int acm_write_buffers_alloc(struct acm *acm)
 921 {
 922         int i;
 923         struct acm_wb *wb;
 924
 925         for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 926                 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 927                     &wb->dmah);
 928                 if (!wb->buf) {
 929                         while (i != 0) {
 930                                 --i;
 931                                 --wb;
 932                                 usb_buffer_free(acm->dev, acm->writesize,
 933                                     wb->buf, wb->dmah);
 934                         }
 935                         return -ENOMEM;
 936                 }
 937         }
 938         return 0;
 939 }
 940
 941 static int acm_probe(struct usb_interface *intf,
 942                      const struct usb_device_id *id)
 943 {
 944         struct usb_cdc_union_desc *union_header = NULL;
 945         struct usb_cdc_country_functional_desc *cfd = NULL;
 946         unsigned char *buffer = intf->altsetting->extra;
 947         int buflen = intf->altsetting->extralen;
 948         struct usb_interface *control_interface;
 949         struct usb_interface *data_interface;
 950         struct usb_endpoint_descriptor *epctrl = NULL;
 951         struct usb_endpoint_descriptor *epread = NULL;
 952         struct usb_endpoint_descriptor *epwrite = NULL;
 953         struct usb_device *usb_dev = interface_to_usbdev(intf);
 954         struct acm *acm;
 955         int minor;
 956         int ctrlsize, readsize;
 957         u8 *buf;
 958         u8 ac_management_function = 0;
 959         u8 call_management_function = 0;
 960         int call_interface_num = -1;
 961         int data_interface_num;
 962         unsigned long quirks;
 963         int num_rx_buf;
 964         int i;
 965         int combined_interfaces = 0;
 966
 967         /* normal quirks */
 968         quirks = (unsigned long)id->driver_info;
 969         num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 970
 971         /* handle quirks deadly to normal probing*/
 972         if (quirks == NO_UNION_NORMAL) {
 973                 data_interface = usb_ifnum_to_if(usb_dev, 1);
 974                 control_interface = usb_ifnum_to_if(usb_dev, 0);
 975                 goto skip_normal_probe;
 976         }
 977
 978         /* normal probing*/
 979         if (!buffer) {
 980                 dev_err(&intf->dev, "Weird descriptor references\n");
 981                 return -EINVAL;
 982         }
 983
 984         if (!buflen) {
 985                 if (intf->cur_altsetting->endpoint->extralen &&
 986                                 intf->cur_altsetting->endpoint->extra) {
 987                         dev_dbg(&intf->dev,
 988                                 "Seeking extra descriptors on endpoint\n");
 989                         buflen = intf->cur_altsetting->endpoint->extralen;
 990                         buffer = intf->cur_altsetting->endpoint->extra;
 991                 } else {
 992                         dev_err(&intf->dev,
 993                                 "Zero length descriptor references\n");
 994                         return -EINVAL;
 995                 }
 996         }
 997
 998         while (buflen > 0) {
 999                 if (buffer[1] != USB_DT_CS_INTERFACE) {
1000                         dev_err(&intf->dev, "skipping garbage\n");
1001                         goto next_desc;
1002                 }
1003
1004                 switch (buffer[2]) {
1005                 case USB_CDC_UNION_TYPE: /* we've found it */
1006                         if (union_header) {
1007                                 dev_err(&intf->dev, "More than one "
1008                                         "union descriptor, skipping ...\n");
1009                                 goto next_desc;
1010                         }
1011                         union_header = (struct usb_cdc_union_desc *)buffer;
1012                         break;
1013                 case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
1014                         cfd = (struct usb_cdc_country_functional_desc *)buffer;
1015                         break;
1016                 case USB_CDC_HEADER_TYPE: /* maybe check version */
1017                         break; /* for now we ignore it */
1018                 case USB_CDC_ACM_TYPE:
1019                         ac_management_function = buffer[3];
1020                         break;
1021                 case USB_CDC_CALL_MANAGEMENT_TYPE:
1022                         call_management_function = buffer[3];
1023                         call_interface_num = buffer[4];
1024                         if ((call_management_function & 3) != 3)
1025                                 dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
1026                         break;
1027                 default:
1028                         /* there are LOTS more CDC descriptors that
1029                          * could legitimately be found here.
1030                          */
1031                         dev_dbg(&intf->dev, "Ignoring descriptor: "
1032                                         "type %02x, length %d\n",
1033                                         buffer[2], buffer[0]);
1034                         break;
1035                 }
1036 next_desc:
1037                 buflen -= buffer[0];
1038                 buffer += buffer[0];
1039         }
1040
1041         if (!union_header) {
1042                 if (call_interface_num > 0) {
1043                         dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
1044                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
1045                         control_interface = intf;
1046                 } else {
1047                         if (intf->cur_altsetting->desc.bNumEndpoints != 3) {
1048                                 dev_dbg(&intf->dev,"No union descriptor, giving up\n");
1049                                 return -ENODEV;
1050                         } else {
1051                                 dev_warn(&intf->dev,"No union descriptor, testing for castrated device\n");
1052                                 combined_interfaces = 1;
1053                                 control_interface = data_interface = intf;
1054                                 goto look_for_collapsed_interface;
1055                         }
1056                 }
1057         } else {
1058                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
1059                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
1060                 if (!control_interface || !data_interface) {
1061                         dev_dbg(&intf->dev, "no interfaces\n");
1062                         return -ENODEV;
1063                 }
1064         }
1065
1066         if (data_interface_num != call_interface_num)
1067                 dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
1068
1069         if (control_interface == data_interface) {
1070                 /* some broken devices designed for windows work this way */
1071                 dev_warn(&intf->dev,"Control and data interfaces are not separated!\n");
1072                 combined_interfaces = 1;
1073                 /* a popular other OS doesn't use it */
1074                 quirks |= NO_CAP_LINE;
1075                 if (data_interface->cur_altsetting->desc.bNumEndpoints != 3) {
1076                         dev_err(&intf->dev, "This needs exactly 3 endpoints\n");
1077                         return -EINVAL;
1078                 }
1079 look_for_collapsed_interface:
1080                 for (i = 0; i < 3; i++) {
1081                         struct usb_endpoint_descriptor *ep;
1082                         ep = &data_interface->cur_altsetting->endpoint[i].desc;
1083
1084                         if (usb_endpoint_is_int_in(ep))
1085                                 epctrl = ep;
1086                         else if (usb_endpoint_is_bulk_out(ep))
1087                                 epwrite = ep;
1088                         else if (usb_endpoint_is_bulk_in(ep))
1089                                 epread = ep;
1090                         else
1091                                 return -EINVAL;
1092                 }
1093                 if (!epctrl || !epread || !epwrite)
1094                         return -ENODEV;
1095                 else
1096                         goto made_compressed_probe;
1097         }
1098
1099 skip_normal_probe:
1100
1101         /*workaround for switched interfaces */
1102         if (data_interface->cur_altsetting->desc.bInterfaceClass
1103                                                 != CDC_DATA_INTERFACE_TYPE) {
1104                 if (control_interface->cur_altsetting->desc.bInterfaceClass
1105                                                 == CDC_DATA_INTERFACE_TYPE) {
1106                         struct usb_interface *t;
1107                         dev_dbg(&intf->dev,
1108                                 "Your device has switched interfaces.\n");
1109                         t = control_interface;
1110                         control_interface = data_interface;
1111                         data_interface = t;
1112                 } else {
1113                         return -EINVAL;
1114                 }
1115         }
1116
1117         /* Accept probe requests only for the control interface */
1118         if (!combined_interfaces && intf != control_interface)
1119                 return -ENODEV;
1120
1121         if (!combined_interfaces && usb_interface_claimed(data_interface)) {
1122                 /* valid in this context */
1123                 dev_dbg(&intf->dev, "The data interface isn't available\n");
1124                 return -EBUSY;
1125         }
1126
1127
1128         if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
1129                 return -EINVAL;
1130
1131         epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
1132         epread = &data_interface->cur_altsetting->endpoint[0].desc;
1133         epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
1134
1135
1136         /* workaround for switched endpoints */
1137         if (!usb_endpoint_dir_in(epread)) {
1138                 /* descriptors are swapped */
1139                 struct usb_endpoint_descriptor *t;
1140                 dev_dbg(&intf->dev,
1141                         "The data interface has switched endpoints\n");
1142                 t = epread;
1143                 epread = epwrite;
1144                 epwrite = t;
1145         }
1146 made_compressed_probe:
1147         dbg("interfaces are valid");
1148         for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
1149
1150         if (minor == ACM_TTY_MINORS) {
1151                 dev_err(&intf->dev, "no more free acm devices\n");
1152                 return -ENODEV;
1153         }
1154
1155         acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
1156         if (acm == NULL) {
1157                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
1158                 goto alloc_fail;
1159         }
1160
1161         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
1162         readsize = le16_to_cpu(epread->wMaxPacketSize) *
1163                                 (quirks == SINGLE_RX_URB ? 1 : 2);
1164         acm->combined_interfaces = combined_interfaces;
1165         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
1166         acm->control = control_interface;
1167         acm->data = data_interface;
1168         acm->minor = minor;
1169         acm->dev = usb_dev;
1170         acm->ctrl_caps = ac_management_function;
1171         if (quirks & NO_CAP_LINE)
1172                 acm->ctrl_caps &= ~USB_CDC_CAP_LINE;
1173         acm->ctrlsize = ctrlsize;
1174         acm->readsize = readsize;
1175         acm->rx_buflimit = num_rx_buf;
1176         acm->urb_task.func = acm_rx_tasklet;
1177         acm->urb_task.data = (unsigned long) acm;
1178         INIT_WORK(&acm->work, acm_softint);
1179         INIT_WORK(&acm->waker, acm_waker);
1180         init_waitqueue_head(&acm->drain_wait);
1181         spin_lock_init(&acm->throttle_lock);
1182         spin_lock_init(&acm->write_lock);
1183         spin_lock_init(&acm->read_lock);
1184         mutex_init(&acm->mutex);
1185         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
1186         tty_port_init(&acm->port);
1187         acm->port.ops = &acm_port_ops;
1188
1189         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
1190         if (!buf) {
1191                 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
1192                 goto alloc_fail2;
1193         }
1194         acm->ctrl_buffer = buf;
1195
1196         if (acm_write_buffers_alloc(acm) < 0) {
1197                 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
1198                 goto alloc_fail4;
1199         }
1200
1201         acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
1202         if (!acm->ctrlurb) {
1203                 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
1204                 goto alloc_fail5;
1205         }
1206         for (i = 0; i < num_rx_buf; i++) {
1207                 struct acm_ru *rcv = &(acm->ru[i]);
1208
1209                 rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
1210                 if (rcv->urb == NULL) {
1211                         dev_dbg(&intf->dev,
1212                                 "out of memory (read urbs usb_alloc_urb)\n");
1213                         goto alloc_fail7;
1214                 }
1215
1216                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1217                 rcv->instance = acm;
1218         }
1219         for (i = 0; i < num_rx_buf; i++) {
1220                 struct acm_rb *rb = &(acm->rb[i]);
1221
1222                 rb->base = usb_buffer_alloc(acm->dev, readsize,
1223                                 GFP_KERNEL, &rb->dma);
1224                 if (!rb->base) {
1225                         dev_dbg(&intf->dev,
1226                                 "out of memory (read bufs usb_buffer_alloc)\n");
1227                         goto alloc_fail7;
1228                 }
1229         }
1230         for (i = 0; i < ACM_NW; i++) {
1231                 struct acm_wb *snd = &(acm->wb[i]);
1232
1233                 snd->urb = usb_alloc_urb(0, GFP_KERNEL);
1234                 if (snd->urb == NULL) {
1235                         dev_dbg(&intf->dev,
1236                                 "out of memory (write urbs usb_alloc_urb)");
1237                         goto alloc_fail7;
1238                 }
1239
1240                 if (usb_endpoint_xfer_int(epwrite))
1241                         usb_fill_int_urb(snd->urb, usb_dev,
1242                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1243                                 NULL, acm->writesize, acm_write_bulk, snd, epwrite->bInterval);
1244                 else
1245                         usb_fill_bulk_urb(snd->urb, usb_dev,
1246                                 usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
1247                                 NULL, acm->writesize, acm_write_bulk, snd);
1248                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1249                 snd->instance = acm;
1250         }
1251
1252         usb_set_intfdata(intf, acm);
1253
1254         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
1255         if (i < 0)
1256                 goto alloc_fail8;
1257
1258         if (cfd) { /* export the country data */
1259                 acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
1260                 if (!acm->country_codes)
1261                         goto skip_countries;
1262                 acm->country_code_size = cfd->bLength - 4;
1263                 memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
1264                                                         cfd->bLength - 4);
1265                 acm->country_rel_date = cfd->iCountryCodeRelDate;
1266
1267                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
1268                 if (i < 0) {
1269                         kfree(acm->country_codes);
1270                         goto skip_countries;
1271                 }
1272
1273                 i = device_create_file(&intf->dev,
1274                                                 &dev_attr_iCountryCodeRelDate);
1275                 if (i < 0) {
1276                         kfree(acm->country_codes);
1277                         goto skip_countries;
1278                 }
1279         }
1280
1281 skip_countries:
1282         usb_fill_int_urb(acm->ctrlurb, usb_dev,
1283                          usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
1284                          acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
1285                          /* works around buggy devices */
1286                          epctrl->bInterval ? epctrl->bInterval : 0xff);
1287         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1288         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
1289
1290         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
1291
1292         acm_set_control(acm, acm->ctrlout);
1293
1294         acm->line.dwDTERate = cpu_to_le32(9600);
1295         acm->line.bDataBits = 8;
1296         acm_set_line(acm, &acm->line);
1297
1298         usb_driver_claim_interface(&acm_driver, data_interface, acm);
1299         usb_set_intfdata(data_interface, acm);
1300
1301         usb_get_intf(control_interface);
1302         tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1303
1304         acm_table[minor] = acm;
1305
1306         return 0;
1307 alloc_fail8:
1308         for (i = 0; i < ACM_NW; i++)
1309                 usb_free_urb(acm->wb[i].urb);
1310 alloc_fail7:
1311         acm_read_buffers_free(acm);
1312         for (i = 0; i < num_rx_buf; i++)
1313                 usb_free_urb(acm->ru[i].urb);
1314         usb_free_urb(acm->ctrlurb);
1315 alloc_fail5:
1316         acm_write_buffers_free(acm);
1317 alloc_fail4:
1318         usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1319 alloc_fail2:
1320         kfree(acm);
1321 alloc_fail:
1322         return -ENOMEM;
1323 }
1324
1325 static void stop_data_traffic(struct acm *acm)
1326 {
1327         int i;
1328         dbg("Entering stop_data_traffic");
1329
1330         tasklet_disable(&acm->urb_task);
1331
1332         usb_kill_urb(acm->ctrlurb);
1333         for (i = 0; i < ACM_NW; i++)
1334                 usb_kill_urb(acm->wb[i].urb);
1335         for (i = 0; i < acm->rx_buflimit; i++)
1336                 usb_kill_urb(acm->ru[i].urb);
1337
1338         tasklet_enable(&acm->urb_task);
1339
1340         cancel_work_sync(&acm->work);
1341         cancel_work_sync(&acm->waker);
1342 }
1343
1344 static void acm_disconnect(struct usb_interface *intf)
1345 {
1346         struct acm *acm = usb_get_intfdata(intf);
1347         struct usb_device *usb_dev = interface_to_usbdev(intf);
1348         struct tty_struct *tty;
1349
1350         /* sibling interface is already cleaning up */
1351         if (!acm)
1352                 return;
1353
1354         mutex_lock(&open_mutex);
1355         if (acm->country_codes) {
1356                 device_remove_file(&acm->control->dev,
1357                                 &dev_attr_wCountryCodes);
1358                 device_remove_file(&acm->control->dev,
1359                                 &dev_attr_iCountryCodeRelDate);
1360         }
1361         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
1362         acm->dev = NULL;
1363         usb_set_intfdata(acm->control, NULL);
1364         usb_set_intfdata(acm->data, NULL);
1365
1366         stop_data_traffic(acm);
1367
1368         acm_write_buffers_free(acm);
1369         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
1370                                                                 acm->ctrl_dma);
1371         acm_read_buffers_free(acm);
1372
1373         if (!acm->combined_interfaces)
1374                 usb_driver_release_interface(&acm_driver, intf == acm->control ?
1375                                         acm->data : acm->control);
1376
1377         if (acm->port.count == 0) {
1378                 acm_tty_unregister(acm);
1379                 mutex_unlock(&open_mutex);
1380                 return;
1381         }
1382
1383         mutex_unlock(&open_mutex);
1384         tty = tty_port_tty_get(&acm->port);
1385         if (tty) {
1386                 tty_hangup(tty);
1387                 tty_kref_put(tty);
1388         }
1389 }
1390
1391 #ifdef CONFIG_PM
1392 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
1393 {
1394         struct acm *acm = usb_get_intfdata(intf);
1395         int cnt;
1396
1397         if (message.event & PM_EVENT_AUTO) {
1398                 int b;
1399
1400                 spin_lock_irq(&acm->read_lock);
1401                 spin_lock(&acm->write_lock);
1402                 b = acm->processing + acm->transmitting;
1403                 spin_unlock(&acm->write_lock);
1404                 spin_unlock_irq(&acm->read_lock);
1405                 if (b)
1406                         return -EBUSY;
1407         }
1408
1409         spin_lock_irq(&acm->read_lock);
1410         spin_lock(&acm->write_lock);
1411         cnt = acm->susp_count++;
1412         spin_unlock(&acm->write_lock);
1413         spin_unlock_irq(&acm->read_lock);
1414
1415         if (cnt)
1416                 return 0;
1417         /*
1418         we treat opened interfaces differently,
1419         we must guard against open
1420         */
1421         mutex_lock(&acm->mutex);
1422
1423         if (acm->port.count)
1424                 stop_data_traffic(acm);
1425
1426         mutex_unlock(&acm->mutex);
1427         return 0;
1428 }
1429
1430 static int acm_resume(struct usb_interface *intf)
1431 {
1432         struct acm *acm = usb_get_intfdata(intf);
1433         int rv = 0;
1434         int cnt;
1435
1436         spin_lock_irq(&acm->read_lock);
1437         acm->susp_count -= 1;
1438         cnt = acm->susp_count;
1439         spin_unlock_irq(&acm->read_lock);
1440
1441         if (cnt)
1442                 return 0;
1443
1444         mutex_lock(&acm->mutex);
1445         if (acm->port.count) {
1446                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
1447                 if (rv < 0)
1448                         goto err_out;
1449
1450                 tasklet_schedule(&acm->urb_task);
1451         }
1452
1453 err_out:
1454         mutex_unlock(&acm->mutex);
1455         return rv;
1456 }
1457
1458 #endif /* CONFIG_PM */
1459 /*
1460  * USB driver structure.
1461  */
1462
1463 static struct usb_device_id acm_ids[] = {
1464         /* quirky and broken devices */
1465         { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1466         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1467         },
1468         { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
1469         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1470         },
1471         { USB_DEVICE(0x0e8d, 0x3329), /* MediaTek Inc GPS */
1472         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1473         },
1474         { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1475         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1476         },
1477         { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
1478         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1479         },
1480         { USB_DEVICE(0x0ace, 0x1602), /* ZyDAS 56K USB MODEM */
1481         .driver_info = SINGLE_RX_URB,
1482         },
1483         { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1484         .driver_info = SINGLE_RX_URB, /* firmware bug */
1485         },
1486         { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1487         .driver_info = SINGLE_RX_URB, /* firmware bug */
1488         },
1489         { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
1490         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1491         },
1492         { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
1493         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1494         },
1495         { USB_DEVICE(0x0572, 0x1321), /* Conexant USB MODEM CX93010 */
1496         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1497         },
1498         { USB_DEVICE(0x0572, 0x1324), /* Conexant USB MODEM RD02-D400 */
1499         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1500         },
1501         { USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
1502         .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1503         },
1504         { USB_DEVICE(0x22b8, 0x6425), /* Motorola MOTOMAGX phones */
1505         },
1506         { USB_DEVICE(0x0572, 0x1329), /* Hummingbird huc56s (Conexant) */
1507         .driver_info = NO_UNION_NORMAL, /* union descriptor misplaced on
1508                                            data interface instead of
1509                                            communications interface.
1510                                            Maybe we should define a new
1511                                            quirk for this. */
1512         },
1513         { USB_DEVICE(0x1bbb, 0x0003), /* Alcatel OT-I650 */
1514         .driver_info = NO_UNION_NORMAL, /* reports zero length descriptor */
1515         },
1516
1517         /* control interfaces with various AT-command sets */
1518         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1519                 USB_CDC_ACM_PROTO_AT_V25TER) },
1520         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1521                 USB_CDC_ACM_PROTO_AT_PCCA101) },
1522         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1523                 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1524         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1525                 USB_CDC_ACM_PROTO_AT_GSM) },
1526         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1527                 USB_CDC_ACM_PROTO_AT_3G) },
1528         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1529                 USB_CDC_ACM_PROTO_AT_CDMA) },
1530
1531         /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1532         { }
1533 };
1534
1535 MODULE_DEVICE_TABLE(usb, acm_ids);
1536
1537 static struct usb_driver acm_driver = {
1538         .name =         "cdc_acm",
1539         .probe =        acm_probe,
1540         .disconnect =   acm_disconnect,
1541 #ifdef CONFIG_PM
1542         .suspend =      acm_suspend,
1543         .resume =       acm_resume,
1544 #endif
1545         .id_table =     acm_ids,
1546 #ifdef CONFIG_PM
1547         .supports_autosuspend = 1,
1548 #endif
1549 };
1550
1551 /*
1552  * TTY driver structures.
1553  */
1554
1555 static const struct tty_operations acm_ops = {
1556         .open =                 acm_tty_open,
1557         .close =                acm_tty_close,
1558         .hangup =               acm_tty_hangup,
1559         .write =                acm_tty_write,
1560         .write_room =           acm_tty_write_room,
1561         .ioctl =                acm_tty_ioctl,
1562         .throttle =             acm_tty_throttle,
1563         .unthrottle =           acm_tty_unthrottle,
1564         .chars_in_buffer =      acm_tty_chars_in_buffer,
1565         .break_ctl =            acm_tty_break_ctl,
1566         .set_termios =          acm_tty_set_termios,
1567         .tiocmget =             acm_tty_tiocmget,
1568         .tiocmset =             acm_tty_tiocmset,
1569 };
1570
1571 /*
1572  * Init / exit.
1573  */
1574
1575 static int __init acm_init(void)
1576 {
1577         int retval;
1578         acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1579         if (!acm_tty_driver)
1580                 return -ENOMEM;
1581         acm_tty_driver->owner = THIS_MODULE,
1582         acm_tty_driver->driver_name = "acm",
1583         acm_tty_driver->name = "ttyACM",
1584         acm_tty_driver->major = ACM_TTY_MAJOR,
1585         acm_tty_driver->minor_start = 0,
1586         acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1587         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1588         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1589         acm_tty_driver->init_termios = tty_std_termios;
1590         acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1591                                                                 HUPCL | CLOCAL;
1592         tty_set_operations(acm_tty_driver, &acm_ops);
1593
1594         retval = tty_register_driver(acm_tty_driver);
1595         if (retval) {
1596                 put_tty_driver(acm_tty_driver);
1597                 return retval;
1598         }
1599
1600         retval = usb_register(&acm_driver);
1601         if (retval) {
1602                 tty_unregister_driver(acm_tty_driver);
1603                 put_tty_driver(acm_tty_driver);
1604                 return retval;
1605         }
1606
1607         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1608                DRIVER_DESC "\n");
1609
1610         return 0;
1611 }
1612
1613 static void __exit acm_exit(void)
1614 {
1615         usb_deregister(&acm_driver);
1616         tty_unregister_driver(acm_tty_driver);
1617         put_tty_driver(acm_tty_driver);
1618 }
1619
1620 module_init(acm_init);
1621 module_exit(acm_exit);
1622
1623 MODULE_AUTHOR(DRIVER_AUTHOR);
1624 MODULE_DESCRIPTION(DRIVER_DESC);
1625 MODULE_LICENSE("GPL");
1626 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);