linux/drivers/usb/class/cdc-acm.c
<<
>>
Prefs
   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 kmalloced
  20 *      v0.13 - added termios, added hangup
  21 *      v0.14 - sized down struct acm
  22 *      v0.15 - fixed flow control again - characters could be lost
  23 *      v0.16 - added code for modems with swapped data and control interfaces
  24 *      v0.17 - added new style probing
  25 *      v0.18 - fixed new style probing for devices with more configurations
  26 *      v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  27 *      v0.20 - switched to probing on interface (rather than device) class
  28 *      v0.21 - revert to probing on device for devices with multiple configs
  29 *      v0.22 - probe only the control interface. if usbcore doesn't choose the
  30 *              config we want, sysadmin changes bConfigurationValue in sysfs.
  31 *      v0.23 - use softirq for rx processing, as needed by tty layer
  32 *      v0.24 - change probe method to evaluate CDC union descriptor
  33 *      v0.25 - downstream tasks paralelized to maximize throughput
  34 */
  35
  36/*
  37 * This program is free software; you can redistribute it and/or modify
  38 * it under the terms of the GNU General Public License as published by
  39 * the Free Software Foundation; either version 2 of the License, or
  40 * (at your option) any later version.
  41 *
  42 * This program is distributed in the hope that it will be useful,
  43 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  44 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  45 * GNU General Public License for more details.
  46 *
  47 * You should have received a copy of the GNU General Public License
  48 * along with this program; if not, write to the Free Software
  49 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  50 */
  51
  52#undef DEBUG
  53
  54#include <linux/kernel.h>
  55#include <linux/errno.h>
  56#include <linux/init.h>
  57#include <linux/slab.h>
  58#include <linux/tty.h>
  59#include <linux/tty_driver.h>
  60#include <linux/tty_flip.h>
  61#include <linux/module.h>
  62#include <linux/smp_lock.h>
  63#include <linux/mutex.h>
  64#include <asm/uaccess.h>
  65#include <linux/usb.h>
  66#include <linux/usb/cdc.h>
  67#include <asm/byteorder.h>
  68#include <asm/unaligned.h>
  69#include <linux/list.h>
  70
  71#include "cdc-acm.h"
  72
  73/*
  74 * Version Information
  75 */
  76#define DRIVER_VERSION "v0.25"
  77#define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  78#define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  79
  80static struct usb_driver acm_driver;
  81static struct tty_driver *acm_tty_driver;
  82static struct acm *acm_table[ACM_TTY_MINORS];
  83
  84static DEFINE_MUTEX(open_mutex);
  85
  86#define ACM_READY(acm)  (acm && acm->dev && acm->used)
  87
  88/*
  89 * Functions for ACM control messages.
  90 */
  91
  92static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
  93{
  94        int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  95                request, USB_RT_ACM, value,
  96                acm->control->altsetting[0].desc.bInterfaceNumber,
  97                buf, len, 5000);
  98        dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
  99        return retval < 0 ? retval : 0;
 100}
 101
 102/* devices aren't required to support these requests.
 103 * the cdc acm descriptor tells whether they do...
 104 */
 105#define acm_set_control(acm, control) \
 106        acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
 107#define acm_set_line(acm, line) \
 108        acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
 109#define acm_send_break(acm, ms) \
 110        acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
 111
 112/*
 113 * Write buffer management.
 114 * All of these assume proper locks taken by the caller.
 115 */
 116
 117static int acm_wb_alloc(struct acm *acm)
 118{
 119        int i, wbn;
 120        struct acm_wb *wb;
 121
 122        wbn = acm->write_current;
 123        i = 0;
 124        for (;;) {
 125                wb = &acm->wb[wbn];
 126                if (!wb->use) {
 127                        wb->use = 1;
 128                        return wbn;
 129                }
 130                wbn = (wbn + 1) % ACM_NW;
 131                if (++i >= ACM_NW)
 132                        return -1;
 133        }
 134}
 135
 136static void acm_wb_free(struct acm *acm, int wbn)
 137{
 138        acm->wb[wbn].use = 0;
 139}
 140
 141static int acm_wb_is_avail(struct acm *acm)
 142{
 143        int i, n;
 144
 145        n = ACM_NW;
 146        for (i = 0; i < ACM_NW; i++) {
 147                n -= acm->wb[i].use;
 148        }
 149        return n;
 150}
 151
 152static inline int acm_wb_is_used(struct acm *acm, int wbn)
 153{
 154        return acm->wb[wbn].use;
 155}
 156
 157/*
 158 * Finish write.
 159 */
 160static void acm_write_done(struct acm *acm)
 161{
 162        unsigned long flags;
 163        int wbn;
 164
 165        spin_lock_irqsave(&acm->write_lock, flags);
 166        acm->write_ready = 1;
 167        wbn = acm->write_current;
 168        acm_wb_free(acm, wbn);
 169        acm->write_current = (wbn + 1) % ACM_NW;
 170        spin_unlock_irqrestore(&acm->write_lock, flags);
 171}
 172
 173/*
 174 * Poke write.
 175 */
 176static int acm_write_start(struct acm *acm)
 177{
 178        unsigned long flags;
 179        int wbn;
 180        struct acm_wb *wb;
 181        int rc;
 182
 183        spin_lock_irqsave(&acm->write_lock, flags);
 184        if (!acm->dev) {
 185                spin_unlock_irqrestore(&acm->write_lock, flags);
 186                return -ENODEV;
 187        }
 188
 189        if (!acm->write_ready) {
 190                spin_unlock_irqrestore(&acm->write_lock, flags);
 191                return 0;       /* A white lie */
 192        }
 193
 194        wbn = acm->write_current;
 195        if (!acm_wb_is_used(acm, wbn)) {
 196                spin_unlock_irqrestore(&acm->write_lock, flags);
 197                return 0;
 198        }
 199        wb = &acm->wb[wbn];
 200
 201        acm->write_ready = 0;
 202        spin_unlock_irqrestore(&acm->write_lock, flags);
 203
 204        acm->writeurb->transfer_buffer = wb->buf;
 205        acm->writeurb->transfer_dma = wb->dmah;
 206        acm->writeurb->transfer_buffer_length = wb->len;
 207        acm->writeurb->dev = acm->dev;
 208
 209        if ((rc = usb_submit_urb(acm->writeurb, GFP_ATOMIC)) < 0) {
 210                dbg("usb_submit_urb(write bulk) failed: %d", rc);
 211                acm_write_done(acm);
 212        }
 213        return rc;
 214}
 215
 216/*
 217 * Interrupt handlers for various ACM device responses
 218 */
 219
 220/* control interface reports status changes with "interrupt" transfers */
 221static void acm_ctrl_irq(struct urb *urb, struct pt_regs *regs)
 222{
 223        struct acm *acm = urb->context;
 224        struct usb_cdc_notification *dr = urb->transfer_buffer;
 225        unsigned char *data;
 226        int newctrl;
 227        int status;
 228
 229        switch (urb->status) {
 230        case 0:
 231                /* success */
 232                break;
 233        case -ECONNRESET:
 234        case -ENOENT:
 235        case -ESHUTDOWN:
 236                /* this urb is terminated, clean up */
 237                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
 238                return;
 239        default:
 240                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
 241                goto exit;
 242        }
 243
 244        if (!ACM_READY(acm))
 245                goto exit;
 246
 247        data = (unsigned char *)(dr + 1);
 248        switch (dr->bNotificationType) {
 249
 250                case USB_CDC_NOTIFY_NETWORK_CONNECTION:
 251
 252                        dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
 253                        break;
 254
 255                case USB_CDC_NOTIFY_SERIAL_STATE:
 256
 257                        newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
 258
 259                        if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
 260                                dbg("calling hangup");
 261                                tty_hangup(acm->tty);
 262                        }
 263
 264                        acm->ctrlin = newctrl;
 265
 266                        dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
 267                                acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
 268                                acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
 269                                acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
 270                                acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
 271
 272                        break;
 273
 274                default:
 275                        dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
 276                                dr->bNotificationType, dr->wIndex,
 277                                dr->wLength, data[0], data[1]);
 278                        break;
 279        }
 280exit:
 281        status = usb_submit_urb (urb, GFP_ATOMIC);
 282        if (status)
 283                err ("%s - usb_submit_urb failed with result %d",
 284                     __FUNCTION__, status);
 285}
 286
 287/* data interface returns incoming bytes, or we got unthrottled */
 288static void acm_read_bulk(struct urb *urb, struct pt_regs *regs)
 289{
 290        struct acm_rb *buf;
 291        struct acm_ru *rcv = urb->context;
 292        struct acm *acm = rcv->instance;
 293        int status = urb->status;
 294        dbg("Entering acm_read_bulk with status %d", urb->status);
 295
 296        if (!ACM_READY(acm))
 297                return;
 298
 299        if (status)
 300                dev_dbg(&acm->data->dev, "bulk rx status %d", status);
 301
 302        buf = rcv->buffer;
 303        buf->size = urb->actual_length;
 304
 305        if (likely(status == 0)) {
 306                spin_lock(&acm->read_lock);
 307                list_add_tail(&rcv->list, &acm->spare_read_urbs);
 308                list_add_tail(&buf->list, &acm->filled_read_bufs);
 309                spin_unlock(&acm->read_lock);
 310        } else {
 311                /* we drop the buffer due to an error */
 312                spin_lock(&acm->read_lock);
 313                list_add_tail(&rcv->list, &acm->spare_read_urbs);
 314                list_add(&buf->list, &acm->spare_read_bufs);
 315                spin_unlock(&acm->read_lock);
 316                /* nevertheless the tasklet must be kicked unconditionally
 317                so the queue cannot dry up */
 318        }
 319        tasklet_schedule(&acm->urb_task);
 320}
 321
 322static void acm_rx_tasklet(unsigned long _acm)
 323{
 324        struct acm *acm = (void *)_acm;
 325        struct acm_rb *buf;
 326        struct tty_struct *tty = acm->tty;
 327        struct acm_ru *rcv;
 328        //unsigned long flags;
 329        int i = 0;
 330        dbg("Entering acm_rx_tasklet");
 331
 332        if (!ACM_READY(acm) || acm->throttle)
 333                return;
 334
 335next_buffer:
 336        spin_lock(&acm->read_lock);
 337        if (list_empty(&acm->filled_read_bufs)) {
 338                spin_unlock(&acm->read_lock);
 339                goto urbs;
 340        }
 341        buf = list_entry(acm->filled_read_bufs.next,
 342                         struct acm_rb, list);
 343        list_del(&buf->list);
 344        spin_unlock(&acm->read_lock);
 345
 346        dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 347
 348        tty_buffer_request_room(tty, buf->size);
 349        if (!acm->throttle)
 350                tty_insert_flip_string(tty, buf->base, buf->size);
 351        tty_flip_buffer_push(tty);
 352
 353        spin_lock(&acm->throttle_lock);
 354        if (acm->throttle) {
 355                dbg("Throtteling noticed");
 356                memmove(buf->base, buf->base + i, buf->size - i);
 357                buf->size -= i;
 358                spin_unlock(&acm->throttle_lock);
 359                spin_lock(&acm->read_lock);
 360                list_add(&buf->list, &acm->filled_read_bufs);
 361                spin_unlock(&acm->read_lock);
 362                return;
 363        }
 364        spin_unlock(&acm->throttle_lock);
 365
 366        spin_lock(&acm->read_lock);
 367        list_add(&buf->list, &acm->spare_read_bufs);
 368        spin_unlock(&acm->read_lock);
 369        goto next_buffer;
 370
 371urbs:
 372        while (!list_empty(&acm->spare_read_bufs)) {
 373                spin_lock(&acm->read_lock);
 374                if (list_empty(&acm->spare_read_urbs)) {
 375                        spin_unlock(&acm->read_lock);
 376                        return;
 377                }
 378                rcv = list_entry(acm->spare_read_urbs.next,
 379                                 struct acm_ru, list);
 380                list_del(&rcv->list);
 381                spin_unlock(&acm->read_lock);
 382
 383                buf = list_entry(acm->spare_read_bufs.next,
 384                                 struct acm_rb, list);
 385                list_del(&buf->list);
 386
 387                rcv->buffer = buf;
 388
 389                usb_fill_bulk_urb(rcv->urb, acm->dev,
 390                                  acm->rx_endpoint,
 391                                  buf->base,
 392                                  acm->readsize,
 393                                  acm_read_bulk, rcv);
 394                rcv->urb->transfer_dma = buf->dma;
 395                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 396
 397                dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
 398
 399                /* This shouldn't kill the driver as unsuccessful URBs are returned to the
 400                   free-urbs-pool and resubmited ASAP */
 401                if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
 402                        list_add(&buf->list, &acm->spare_read_bufs);
 403                        spin_lock(&acm->read_lock);
 404                        list_add(&rcv->list, &acm->spare_read_urbs);
 405                        spin_unlock(&acm->read_lock);
 406                        return;
 407                }
 408        }
 409}
 410
 411/* data interface wrote those outgoing bytes */
 412static void acm_write_bulk(struct urb *urb, struct pt_regs *regs)
 413{
 414        struct acm *acm = (struct acm *)urb->context;
 415
 416        dbg("Entering acm_write_bulk with status %d", urb->status);
 417
 418        acm_write_done(acm);
 419        acm_write_start(acm);
 420        if (ACM_READY(acm))
 421                schedule_work(&acm->work);
 422}
 423
 424static void acm_softint(void *private)
 425{
 426        struct acm *acm = private;
 427        dbg("Entering acm_softint.");
 428        
 429        if (!ACM_READY(acm))
 430                return;
 431        tty_wakeup(acm->tty);
 432}
 433
 434/*
 435 * TTY handlers
 436 */
 437
 438static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 439{
 440        struct acm *acm;
 441        int rv = -EINVAL;
 442        int i;
 443        dbg("Entering acm_tty_open.");
 444
 445        mutex_lock(&open_mutex);
 446
 447        acm = acm_table[tty->index];
 448        if (!acm || !acm->dev)
 449                goto err_out;
 450        else
 451                rv = 0;
 452
 453        tty->driver_data = acm;
 454        acm->tty = tty;
 455
 456        /* force low_latency on so that our tty_push actually forces the data through,
 457           otherwise it is scheduled, and with high data rates data can get lost. */
 458        tty->low_latency = 1;
 459
 460        if (acm->used++) {
 461                goto done;
 462        }
 463
 464        acm->ctrlurb->dev = acm->dev;
 465        if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
 466                dbg("usb_submit_urb(ctrl irq) failed");
 467                goto bail_out;
 468        }
 469
 470        if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS))
 471                goto full_bailout;
 472
 473        INIT_LIST_HEAD(&acm->spare_read_urbs);
 474        INIT_LIST_HEAD(&acm->spare_read_bufs);
 475        INIT_LIST_HEAD(&acm->filled_read_bufs);
 476        for (i = 0; i < acm->rx_buflimit; i++) {
 477                list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
 478        }
 479        for (i = 0; i < acm->rx_buflimit; i++) {
 480                list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
 481        }
 482
 483        tasklet_schedule(&acm->urb_task);
 484
 485done:
 486err_out:
 487        mutex_unlock(&open_mutex);
 488        return rv;
 489
 490full_bailout:
 491        usb_kill_urb(acm->ctrlurb);
 492bail_out:
 493        acm->used--;
 494        mutex_unlock(&open_mutex);
 495        return -EIO;
 496}
 497
 498static void acm_tty_unregister(struct acm *acm)
 499{
 500        int i,nr;
 501
 502        nr = acm->rx_buflimit;
 503        tty_unregister_device(acm_tty_driver, acm->minor);
 504        usb_put_intf(acm->control);
 505        acm_table[acm->minor] = NULL;
 506        usb_free_urb(acm->ctrlurb);
 507        usb_free_urb(acm->writeurb);
 508        for (i = 0; i < nr; i++)
 509                usb_free_urb(acm->ru[i].urb);
 510        kfree(acm);
 511}
 512
 513static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 514{
 515        struct acm *acm = tty->driver_data;
 516        int i,nr;
 517
 518        if (!acm || !acm->used)
 519                return;
 520
 521        nr = acm->rx_buflimit;
 522        mutex_lock(&open_mutex);
 523        if (!--acm->used) {
 524                if (acm->dev) {
 525                        acm_set_control(acm, acm->ctrlout = 0);
 526                        usb_kill_urb(acm->ctrlurb);
 527                        usb_kill_urb(acm->writeurb);
 528                        for (i = 0; i < nr; i++)
 529                                usb_kill_urb(acm->ru[i].urb);
 530                } else
 531                        acm_tty_unregister(acm);
 532        }
 533        mutex_unlock(&open_mutex);
 534}
 535
 536static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
 537{
 538        struct acm *acm = tty->driver_data;
 539        int stat;
 540        unsigned long flags;
 541        int wbn;
 542        struct acm_wb *wb;
 543
 544        dbg("Entering acm_tty_write to write %d bytes,", count);
 545
 546        if (!ACM_READY(acm))
 547                return -EINVAL;
 548        if (!count)
 549                return 0;
 550
 551        spin_lock_irqsave(&acm->write_lock, flags);
 552        if ((wbn = acm_wb_alloc(acm)) < 0) {
 553                spin_unlock_irqrestore(&acm->write_lock, flags);
 554                acm_write_start(acm);
 555                return 0;
 556        }
 557        wb = &acm->wb[wbn];
 558
 559        count = (count > acm->writesize) ? acm->writesize : count;
 560        dbg("Get %d bytes...", count);
 561        memcpy(wb->buf, buf, count);
 562        wb->len = count;
 563        spin_unlock_irqrestore(&acm->write_lock, flags);
 564
 565        if ((stat = acm_write_start(acm)) < 0)
 566                return stat;
 567        return count;
 568}
 569
 570static int acm_tty_write_room(struct tty_struct *tty)
 571{
 572        struct acm *acm = tty->driver_data;
 573        if (!ACM_READY(acm))
 574                return -EINVAL;
 575        /*
 576         * Do not let the line discipline to know that we have a reserve,
 577         * or it might get too enthusiastic.
 578         */
 579        return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0;
 580}
 581
 582static int acm_tty_chars_in_buffer(struct tty_struct *tty)
 583{
 584        struct acm *acm = tty->driver_data;
 585        if (!ACM_READY(acm))
 586                return -EINVAL;
 587        /*
 588         * This is inaccurate (overcounts), but it works.
 589         */
 590        return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
 591}
 592
 593static void acm_tty_throttle(struct tty_struct *tty)
 594{
 595        struct acm *acm = tty->driver_data;
 596        if (!ACM_READY(acm))
 597                return;
 598        spin_lock_bh(&acm->throttle_lock);
 599        acm->throttle = 1;
 600        spin_unlock_bh(&acm->throttle_lock);
 601}
 602
 603static void acm_tty_unthrottle(struct tty_struct *tty)
 604{
 605        struct acm *acm = tty->driver_data;
 606        if (!ACM_READY(acm))
 607                return;
 608        spin_lock_bh(&acm->throttle_lock);
 609        acm->throttle = 0;
 610        spin_unlock_bh(&acm->throttle_lock);
 611        tasklet_schedule(&acm->urb_task);
 612}
 613
 614static void acm_tty_break_ctl(struct tty_struct *tty, int state)
 615{
 616        struct acm *acm = tty->driver_data;
 617        if (!ACM_READY(acm))
 618                return;
 619        if (acm_send_break(acm, state ? 0xffff : 0))
 620                dbg("send break failed");
 621}
 622
 623static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
 624{
 625        struct acm *acm = tty->driver_data;
 626
 627        if (!ACM_READY(acm))
 628                return -EINVAL;
 629
 630        return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
 631               (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
 632               (acm->ctrlin  & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
 633               (acm->ctrlin  & ACM_CTRL_RI  ? TIOCM_RI  : 0) |
 634               (acm->ctrlin  & ACM_CTRL_DCD ? TIOCM_CD  : 0) |
 635               TIOCM_CTS;
 636}
 637
 638static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
 639                            unsigned int set, unsigned int clear)
 640{
 641        struct acm *acm = tty->driver_data;
 642        unsigned int newctrl;
 643
 644        if (!ACM_READY(acm))
 645                return -EINVAL;
 646
 647        newctrl = acm->ctrlout;
 648        set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 649        clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 650
 651        newctrl = (newctrl & ~clear) | set;
 652
 653        if (acm->ctrlout == newctrl)
 654                return 0;
 655        return acm_set_control(acm, acm->ctrlout = newctrl);
 656}
 657
 658static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 659{
 660        struct acm *acm = tty->driver_data;
 661
 662        if (!ACM_READY(acm))
 663                return -EINVAL;
 664
 665        return -ENOIOCTLCMD;
 666}
 667
 668static const __u32 acm_tty_speed[] = {
 669        0, 50, 75, 110, 134, 150, 200, 300, 600,
 670        1200, 1800, 2400, 4800, 9600, 19200, 38400,
 671        57600, 115200, 230400, 460800, 500000, 576000,
 672        921600, 1000000, 1152000, 1500000, 2000000,
 673        2500000, 3000000, 3500000, 4000000
 674};
 675
 676static const __u8 acm_tty_size[] = {
 677        5, 6, 7, 8
 678};
 679
 680static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
 681{
 682        struct acm *acm = tty->driver_data;
 683        struct termios *termios = tty->termios;
 684        struct usb_cdc_line_coding newline;
 685        int newctrl = acm->ctrlout;
 686
 687        if (!ACM_READY(acm))
 688                return;
 689
 690        newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
 691                (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
 692        newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
 693        newline.bParityType = termios->c_cflag & PARENB ?
 694                (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
 695        newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
 696
 697        acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 698
 699        if (!newline.dwDTERate) {
 700                newline.dwDTERate = acm->line.dwDTERate;
 701                newctrl &= ~ACM_CTRL_DTR;
 702        } else  newctrl |=  ACM_CTRL_DTR;
 703
 704        if (newctrl != acm->ctrlout)
 705                acm_set_control(acm, acm->ctrlout = newctrl);
 706
 707        if (memcmp(&acm->line, &newline, sizeof newline)) {
 708                memcpy(&acm->line, &newline, sizeof newline);
 709                dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
 710                        newline.bCharFormat, newline.bParityType,
 711                        newline.bDataBits);
 712                acm_set_line(acm, &acm->line);
 713        }
 714}
 715
 716/*
 717 * USB probe and disconnect routines.
 718 */
 719
 720/* Little helper: write buffers free */
 721static void acm_write_buffers_free(struct acm *acm)
 722{
 723        int i;
 724        struct acm_wb *wb;
 725
 726        for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 727                usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
 728        }
 729}
 730
 731/* Little helper: write buffers allocate */
 732static int acm_write_buffers_alloc(struct acm *acm)
 733{
 734        int i;
 735        struct acm_wb *wb;
 736
 737        for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
 738                wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
 739                    &wb->dmah);
 740                if (!wb->buf) {
 741                        while (i != 0) {
 742                                --i;
 743                                --wb;
 744                                usb_buffer_free(acm->dev, acm->writesize,
 745                                    wb->buf, wb->dmah);
 746                        }
 747                        return -ENOMEM;
 748                }
 749        }
 750        return 0;
 751}
 752
 753static int acm_probe (struct usb_interface *intf,
 754                      const struct usb_device_id *id)
 755{
 756        struct usb_cdc_union_desc *union_header = NULL;
 757        char *buffer = intf->altsetting->extra;
 758        int buflen = intf->altsetting->extralen;
 759        struct usb_interface *control_interface;
 760        struct usb_interface *data_interface;
 761        struct usb_endpoint_descriptor *epctrl;
 762        struct usb_endpoint_descriptor *epread;
 763        struct usb_endpoint_descriptor *epwrite;
 764        struct usb_device *usb_dev = interface_to_usbdev(intf);
 765        struct acm *acm;
 766        int minor;
 767        int ctrlsize,readsize;
 768        u8 *buf;
 769        u8 ac_management_function = 0;
 770        u8 call_management_function = 0;
 771        int call_interface_num = -1;
 772        int data_interface_num;
 773        unsigned long quirks;
 774        int num_rx_buf;
 775        int i;
 776
 777        /* normal quirks */
 778        quirks = (unsigned long)id->driver_info;
 779        num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
 780
 781        /* handle quirks deadly to normal probing*/
 782        if (quirks == NO_UNION_NORMAL) {
 783                data_interface = usb_ifnum_to_if(usb_dev, 1);
 784                control_interface = usb_ifnum_to_if(usb_dev, 0);
 785                goto skip_normal_probe;
 786        }
 787        
 788        /* normal probing*/
 789        if (!buffer) {
 790                err("Wierd descriptor references\n");
 791                return -EINVAL;
 792        }
 793
 794        if (!buflen) {
 795                if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
 796                        dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint");
 797                        buflen = intf->cur_altsetting->endpoint->extralen;
 798                        buffer = intf->cur_altsetting->endpoint->extra;
 799                } else {
 800                        err("Zero length descriptor references\n");
 801                        return -EINVAL;
 802                }
 803        }
 804
 805        while (buflen > 0) {
 806                if (buffer [1] != USB_DT_CS_INTERFACE) {
 807                        err("skipping garbage\n");
 808                        goto next_desc;
 809                }
 810
 811                switch (buffer [2]) {
 812                        case USB_CDC_UNION_TYPE: /* we've found it */
 813                                if (union_header) {
 814                                        err("More than one union descriptor, skipping ...");
 815                                        goto next_desc;
 816                                }
 817                                union_header = (struct usb_cdc_union_desc *)
 818                                                        buffer;
 819                                break;
 820                        case USB_CDC_COUNTRY_TYPE: /* maybe somehow export */
 821                                break; /* for now we ignore it */
 822                        case USB_CDC_HEADER_TYPE: /* maybe check version */ 
 823                                break; /* for now we ignore it */ 
 824                        case USB_CDC_ACM_TYPE:
 825                                ac_management_function = buffer[3];
 826                                break;
 827                        case USB_CDC_CALL_MANAGEMENT_TYPE:
 828                                call_management_function = buffer[3];
 829                                call_interface_num = buffer[4];
 830                                if ((call_management_function & 3) != 3)
 831                                        err("This device cannot do calls on its own. It is no modem.");
 832                                break;
 833                                
 834                        default:
 835                                err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
 836                                break;
 837                        }
 838next_desc:
 839                buflen -= buffer[0];
 840                buffer += buffer[0];
 841        }
 842
 843        if (!union_header) {
 844                if (call_interface_num > 0) {
 845                        dev_dbg(&intf->dev,"No union descriptor, using call management descriptor");
 846                        data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
 847                        control_interface = intf;
 848                } else {
 849                        dev_dbg(&intf->dev,"No union descriptor, giving up");
 850                        return -ENODEV;
 851                }
 852        } else {
 853                control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
 854                data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
 855                if (!control_interface || !data_interface) {
 856                        dev_dbg(&intf->dev,"no interfaces");
 857                        return -ENODEV;
 858                }
 859        }
 860        
 861        if (data_interface_num != call_interface_num)
 862                dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.");
 863
 864skip_normal_probe:
 865
 866        /*workaround for switched interfaces */
 867        if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
 868                if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
 869                        struct usb_interface *t;
 870                        dev_dbg(&intf->dev,"Your device has switched interfaces.");
 871
 872                        t = control_interface;
 873                        control_interface = data_interface;
 874                        data_interface = t;
 875                } else {
 876                        return -EINVAL;
 877                }
 878        }
 879        
 880        if (usb_interface_claimed(data_interface)) { /* valid in this context */
 881                dev_dbg(&intf->dev,"The data interface isn't available");
 882                return -EBUSY;
 883        }
 884
 885
 886        if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
 887                return -EINVAL;
 888
 889        epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
 890        epread = &data_interface->cur_altsetting->endpoint[0].desc;
 891        epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
 892
 893
 894        /* workaround for switched endpoints */
 895        if ((epread->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) {
 896                /* descriptors are swapped */
 897                struct usb_endpoint_descriptor *t;
 898                dev_dbg(&intf->dev,"The data interface has switched endpoints");
 899                
 900                t = epread;
 901                epread = epwrite;
 902                epwrite = t;
 903        }
 904        dbg("interfaces are valid");
 905        for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
 906
 907        if (minor == ACM_TTY_MINORS) {
 908                err("no more free acm devices");
 909                return -ENODEV;
 910        }
 911
 912        if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
 913                dev_dbg(&intf->dev, "out of memory (acm kzalloc)");
 914                goto alloc_fail;
 915        }
 916
 917        ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
 918        readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
 919        acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize);
 920        acm->control = control_interface;
 921        acm->data = data_interface;
 922        acm->minor = minor;
 923        acm->dev = usb_dev;
 924        acm->ctrl_caps = ac_management_function;
 925        acm->ctrlsize = ctrlsize;
 926        acm->readsize = readsize;
 927        acm->rx_buflimit = num_rx_buf;
 928        acm->urb_task.func = acm_rx_tasklet;
 929        acm->urb_task.data = (unsigned long) acm;
 930        INIT_WORK(&acm->work, acm_softint, acm);
 931        spin_lock_init(&acm->throttle_lock);
 932        spin_lock_init(&acm->write_lock);
 933        spin_lock_init(&acm->read_lock);
 934        acm->write_ready = 1;
 935        acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
 936
 937        buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
 938        if (!buf) {
 939                dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)");
 940                goto alloc_fail2;
 941        }
 942        acm->ctrl_buffer = buf;
 943
 944        if (acm_write_buffers_alloc(acm) < 0) {
 945                dev_dbg(&intf->dev, "out of memory (write buffer alloc)");
 946                goto alloc_fail4;
 947        }
 948
 949        acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
 950        if (!acm->ctrlurb) {
 951                dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)");
 952                goto alloc_fail5;
 953        }
 954        for (i = 0; i < num_rx_buf; i++) {
 955                struct acm_ru *rcv = &(acm->ru[i]);
 956
 957                if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
 958                        dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)");
 959                        goto alloc_fail7;
 960                }
 961
 962                rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 963                rcv->instance = acm;
 964        }
 965        for (i = 0; i < num_rx_buf; i++) {
 966                struct acm_rb *buf = &(acm->rb[i]);
 967
 968                if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) {
 969                        dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)");
 970                        goto alloc_fail7;
 971                }
 972        }
 973        acm->writeurb = usb_alloc_urb(0, GFP_KERNEL);
 974        if (!acm->writeurb) {
 975                dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)");
 976                goto alloc_fail7;
 977        }
 978
 979        usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
 980                         acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
 981        acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 982        acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 983
 984        usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
 985                          NULL, acm->writesize, acm_write_bulk, acm);
 986        acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP;
 987
 988        dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 989
 990        acm_set_control(acm, acm->ctrlout);
 991
 992        acm->line.dwDTERate = cpu_to_le32(9600);
 993        acm->line.bDataBits = 8;
 994        acm_set_line(acm, &acm->line);
 995
 996        usb_driver_claim_interface(&acm_driver, data_interface, acm);
 997
 998        usb_get_intf(control_interface);
 999        tty_register_device(acm_tty_driver, minor, &control_interface->dev);
1000
1001        acm_table[minor] = acm;
1002        usb_set_intfdata (intf, acm);
1003        return 0;
1004
1005alloc_fail7:
1006        for (i = 0; i < num_rx_buf; i++)
1007                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1008        for (i = 0; i < num_rx_buf; i++)
1009                usb_free_urb(acm->ru[i].urb);
1010        usb_free_urb(acm->ctrlurb);
1011alloc_fail5:
1012        acm_write_buffers_free(acm);
1013alloc_fail4:
1014        usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1015alloc_fail2:
1016        kfree(acm);
1017alloc_fail:
1018        return -ENOMEM;
1019}
1020
1021static void acm_disconnect(struct usb_interface *intf)
1022{
1023        struct acm *acm = usb_get_intfdata (intf);
1024        struct usb_device *usb_dev = interface_to_usbdev(intf);
1025        int i;
1026
1027        if (!acm || !acm->dev) {
1028                dbg("disconnect on nonexisting interface");
1029                return;
1030        }
1031
1032        mutex_lock(&open_mutex);
1033        if (!usb_get_intfdata(intf)) {
1034                mutex_unlock(&open_mutex);
1035                return;
1036        }
1037        acm->dev = NULL;
1038        usb_set_intfdata(acm->control, NULL);
1039        usb_set_intfdata(acm->data, NULL);
1040
1041        tasklet_disable(&acm->urb_task);
1042
1043        usb_kill_urb(acm->ctrlurb);
1044        usb_kill_urb(acm->writeurb);
1045        for (i = 0; i < acm->rx_buflimit; i++)
1046                usb_kill_urb(acm->ru[i].urb);
1047
1048        INIT_LIST_HEAD(&acm->filled_read_bufs);
1049        INIT_LIST_HEAD(&acm->spare_read_bufs);
1050
1051        tasklet_enable(&acm->urb_task);
1052
1053        flush_scheduled_work(); /* wait for acm_softint */
1054
1055        acm_write_buffers_free(acm);
1056        usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
1057        for (i = 0; i < acm->rx_buflimit; i++)
1058                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
1059
1060        usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
1061
1062        if (!acm->used) {
1063                acm_tty_unregister(acm);
1064                mutex_unlock(&open_mutex);
1065                return;
1066        }
1067
1068        mutex_unlock(&open_mutex);
1069
1070        if (acm->tty)
1071                tty_hangup(acm->tty);
1072}
1073
1074/*
1075 * USB driver structure.
1076 */
1077
1078static struct usb_device_id acm_ids[] = {
1079        /* quirky and broken devices */
1080        { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
1081        .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1082        },
1083        { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
1084        .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
1085        },
1086        { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
1087        .driver_info = SINGLE_RX_URB, /* firmware bug */
1088        },
1089        { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
1090        .driver_info = SINGLE_RX_URB, /* firmware bug */
1091        },
1092        /* control interfaces with various AT-command sets */
1093        { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1094                USB_CDC_ACM_PROTO_AT_V25TER) },
1095        { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1096                USB_CDC_ACM_PROTO_AT_PCCA101) },
1097        { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1098                USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
1099        { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1100                USB_CDC_ACM_PROTO_AT_GSM) },
1101        { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1102                USB_CDC_ACM_PROTO_AT_3G ) },
1103        { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
1104                USB_CDC_ACM_PROTO_AT_CDMA) },
1105
1106        /* NOTE:  COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
1107        { }
1108};
1109
1110MODULE_DEVICE_TABLE (usb, acm_ids);
1111
1112static struct usb_driver acm_driver = {
1113        .name =         "cdc_acm",
1114        .probe =        acm_probe,
1115        .disconnect =   acm_disconnect,
1116        .id_table =     acm_ids,
1117};
1118
1119/*
1120 * TTY driver structures.
1121 */
1122
1123static struct tty_operations acm_ops = {
1124        .open =                 acm_tty_open,
1125        .close =                acm_tty_close,
1126        .write =                acm_tty_write,
1127        .write_room =           acm_tty_write_room,
1128        .ioctl =                acm_tty_ioctl,
1129        .throttle =             acm_tty_throttle,
1130        .unthrottle =           acm_tty_unthrottle,
1131        .chars_in_buffer =      acm_tty_chars_in_buffer,
1132        .break_ctl =            acm_tty_break_ctl,
1133        .set_termios =          acm_tty_set_termios,
1134        .tiocmget =             acm_tty_tiocmget,
1135        .tiocmset =             acm_tty_tiocmset,
1136};
1137
1138/*
1139 * Init / exit.
1140 */
1141
1142static int __init acm_init(void)
1143{
1144        int retval;
1145        acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
1146        if (!acm_tty_driver)
1147                return -ENOMEM;
1148        acm_tty_driver->owner = THIS_MODULE,
1149        acm_tty_driver->driver_name = "acm",
1150        acm_tty_driver->name = "ttyACM",
1151        acm_tty_driver->major = ACM_TTY_MAJOR,
1152        acm_tty_driver->minor_start = 0,
1153        acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
1154        acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
1155        acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1156        acm_tty_driver->init_termios = tty_std_termios;
1157        acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1158        tty_set_operations(acm_tty_driver, &acm_ops);
1159
1160        retval = tty_register_driver(acm_tty_driver);
1161        if (retval) {
1162                put_tty_driver(acm_tty_driver);
1163                return retval;
1164        }
1165
1166        retval = usb_register(&acm_driver);
1167        if (retval) {
1168                tty_unregister_driver(acm_tty_driver);
1169                put_tty_driver(acm_tty_driver);
1170                return retval;
1171        }
1172
1173        info(DRIVER_VERSION ":" DRIVER_DESC);
1174
1175        return 0;
1176}
1177
1178static void __exit acm_exit(void)
1179{
1180        usb_deregister(&acm_driver);
1181        tty_unregister_driver(acm_tty_driver);
1182        put_tty_driver(acm_tty_driver);
1183}
1184
1185module_init(acm_init);
1186module_exit(acm_exit);
1187
1188MODULE_AUTHOR( DRIVER_AUTHOR );
1189MODULE_DESCRIPTION( DRIVER_DESC );
1190MODULE_LICENSE("GPL");
1191
1192
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.