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 <asm/uaccess.h> 64 #include <linux/usb.h> 65 #include <linux/usb_cdc.h> 66 #include <asm/byteorder.h> 67 #include <asm/unaligned.h> 68 #include <linux/list.h> 69 70 #include "cdc-acm.h" 71 72 /* 73 * Version Information 74 */ 75 #define DRIVER_VERSION "v0.25" 76 #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek" 77 #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters" 78 79 static struct usb_driver acm_driver; 80 static struct tty_driver *acm_tty_driver; 81 static struct acm *acm_table[ACM_TTY_MINORS]; 82 83 static DECLARE_MUTEX(open_sem); 84 85 #define ACM_READY(acm) (acm && acm->dev && acm->used) 86 87 /* 88 * Functions for ACM control messages. 89 */ 90 91 static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len) 92 { 93 int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0), 94 request, USB_RT_ACM, value, 95 acm->control->altsetting[0].desc.bInterfaceNumber, 96 buf, len, 5000); 97 dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval); 98 return retval < 0 ? retval : 0; 99 } 100 101 /* devices aren't required to support these requests. 102 * the cdc acm descriptor tells whether they do... 103 */ 104 #define acm_set_control(acm, control) \ 105 acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0) 106 #define acm_set_line(acm, line) \ 107 acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line)) 108 #define acm_send_break(acm, ms) \ 109 acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0) 110 111 /* 112 * Write buffer management. 113 * All of these assume proper locks taken by the caller. 114 */ 115 116 static int acm_wb_alloc(struct acm *acm) 117 { 118 int i, wbn; 119 struct acm_wb *wb; 120 121 wbn = acm->write_current; 122 i = 0; 123 for (;;) { 124 wb = &acm->wb[wbn]; 125 if (!wb->use) { 126 wb->use = 1; 127 return wbn; 128 } 129 wbn = (wbn + 1) % ACM_NWB; 130 if (++i >= ACM_NWB) 131 return -1; 132 } 133 } 134 135 static void acm_wb_free(struct acm *acm, int wbn) 136 { 137 acm->wb[wbn].use = 0; 138 } 139 140 static int acm_wb_is_avail(struct acm *acm) 141 { 142 int i, n; 143 144 n = 0; 145 for (i = 0; i < ACM_NWB; i++) { 146 if (!acm->wb[i].use) 147 n++; 148 } 149 return n; 150 } 151 152 static 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 */ 160 static 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_NWB; 170 spin_unlock_irqrestore(&acm->write_lock, flags); 171 } 172 173 /* 174 * Poke write. 175 */ 176 static 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 */ 221 static 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 } 280 exit: 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 */ 288 static 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 dbg("Entering acm_read_bulk with status %d\n", urb->status); 294 295 if (!ACM_READY(acm)) 296 return; 297 298 if (urb->status) 299 dev_dbg(&acm->data->dev, "bulk rx status %d\n", urb->status); 300 301 buf = rcv->buffer; 302 buf->size = urb->actual_length; 303 304 spin_lock(&acm->read_lock); 305 list_add_tail(&rcv->list, &acm->spare_read_urbs); 306 list_add_tail(&buf->list, &acm->filled_read_bufs); 307 spin_unlock(&acm->read_lock); 308 309 tasklet_schedule(&acm->urb_task); 310 } 311 312 static void acm_rx_tasklet(unsigned long _acm) 313 { 314 struct acm *acm = (void *)_acm; 315 struct acm_rb *buf; 316 struct tty_struct *tty = acm->tty; 317 struct acm_ru *rcv; 318 //unsigned long flags; 319 int i = 0; 320 dbg("Entering acm_rx_tasklet"); 321 322 if (!ACM_READY(acm) || acm->throttle) 323 return; 324 325 next_buffer: 326 spin_lock(&acm->read_lock); 327 if (list_empty(&acm->filled_read_bufs)) { 328 spin_unlock(&acm->read_lock); 329 goto urbs; 330 } 331 buf = list_entry(acm->filled_read_bufs.next, 332 struct acm_rb, list); 333 list_del(&buf->list); 334 spin_unlock(&acm->read_lock); 335 336 dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d\n", buf, buf->size); 337 338 tty_buffer_request_room(tty, buf->size); 339 if (!acm->throttle) 340 tty_insert_flip_string(tty, buf->base, buf->size); 341 tty_flip_buffer_push(tty); 342 343 spin_lock(&acm->throttle_lock); 344 if (acm->throttle) { 345 dbg("Throtteling noticed"); 346 memmove(buf->base, buf->base + i, buf->size - i); 347 buf->size -= i; 348 spin_unlock(&acm->throttle_lock); 349 spin_lock(&acm->read_lock); 350 list_add(&buf->list, &acm->filled_read_bufs); 351 spin_unlock(&acm->read_lock); 352 return; 353 } 354 spin_unlock(&acm->throttle_lock); 355 356 spin_lock(&acm->read_lock); 357 list_add(&buf->list, &acm->spare_read_bufs); 358 spin_unlock(&acm->read_lock); 359 goto next_buffer; 360 361 urbs: 362 while (!list_empty(&acm->spare_read_bufs)) { 363 spin_lock(&acm->read_lock); 364 if (list_empty(&acm->spare_read_urbs)) { 365 spin_unlock(&acm->read_lock); 366 return; 367 } 368 rcv = list_entry(acm->spare_read_urbs.next, 369 struct acm_ru, list); 370 list_del(&rcv->list); 371 spin_unlock(&acm->read_lock); 372 373 buf = list_entry(acm->spare_read_bufs.next, 374 struct acm_rb, list); 375 list_del(&buf->list); 376 377 rcv->buffer = buf; 378 379 usb_fill_bulk_urb(rcv->urb, acm->dev, 380 acm->rx_endpoint, 381 buf->base, 382 acm->readsize, 383 acm_read_bulk, rcv); 384 rcv->urb->transfer_dma = buf->dma; 385 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 386 387 dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p\n", rcv->urb, rcv, buf); 388 389 /* This shouldn't kill the driver as unsuccessful URBs are returned to the 390 free-urbs-pool and resubmited ASAP */ 391 if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) { 392 list_add(&buf->list, &acm->spare_read_bufs); 393 spin_lock(&acm->read_lock); 394 list_add(&rcv->list, &acm->spare_read_urbs); 395 spin_unlock(&acm->read_lock); 396 return; 397 } 398 } 399 } 400 401 /* data interface wrote those outgoing bytes */ 402 static void acm_write_bulk(struct urb *urb, struct pt_regs *regs) 403 { 404 struct acm *acm = (struct acm *)urb->context; 405 406 dbg("Entering acm_write_bulk with status %d\n", urb->status); 407 408 acm_write_done(acm); 409 acm_write_start(acm); 410 if (ACM_READY(acm)) 411 schedule_work(&acm->work); 412 } 413 414 static void acm_softint(void *private) 415 { 416 struct acm *acm = private; 417 dbg("Entering acm_softint.\n"); 418 419 if (!ACM_READY(acm)) 420 return; 421 tty_wakeup(acm->tty); 422 } 423 424 /* 425 * TTY handlers 426 */ 427 428 static int acm_tty_open(struct tty_struct *tty, struct file *filp) 429 { 430 struct acm *acm; 431 int rv = -EINVAL; 432 int i; 433 dbg("Entering acm_tty_open.\n"); 434 435 down(&open_sem); 436 437 acm = acm_table[tty->index]; 438 if (!acm || !acm->dev) 439 goto err_out; 440 else 441 rv = 0; 442 443 tty->driver_data = acm; 444 acm->tty = tty; 445 446 /* force low_latency on so that our tty_push actually forces the data through, 447 otherwise it is scheduled, and with high data rates data can get lost. */ 448 tty->low_latency = 1; 449 450 if (acm->used++) { 451 goto done; 452 } 453 454 acm->ctrlurb->dev = acm->dev; 455 if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) { 456 dbg("usb_submit_urb(ctrl irq) failed"); 457 goto bail_out; 458 } 459 460 if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS)) 461 goto full_bailout; 462 463 INIT_LIST_HEAD(&acm->spare_read_urbs); 464 INIT_LIST_HEAD(&acm->spare_read_bufs); 465 INIT_LIST_HEAD(&acm->filled_read_bufs); 466 for (i = 0; i < ACM_NRU; i++) { 467 list_add(&(acm->ru[i].list), &acm->spare_read_urbs); 468 } 469 for (i = 0; i < ACM_NRB; i++) { 470 list_add(&(acm->rb[i].list), &acm->spare_read_bufs); 471 } 472 473 tasklet_schedule(&acm->urb_task); 474 475 done: 476 err_out: 477 up(&open_sem); 478 return rv; 479 480 full_bailout: 481 usb_kill_urb(acm->ctrlurb); 482 bail_out: 483 acm->used--; 484 up(&open_sem); 485 return -EIO; 486 } 487 488 static void acm_tty_unregister(struct acm *acm) 489 { 490 int i; 491 492 tty_unregister_device(acm_tty_driver, acm->minor); 493 usb_put_intf(acm->control); 494 acm_table[acm->minor] = NULL; 495 usb_free_urb(acm->ctrlurb); 496 usb_free_urb(acm->writeurb); 497 for (i = 0; i < ACM_NRU; i++) 498 usb_free_urb(acm->ru[i].urb); 499 kfree(acm); 500 } 501 502 static void acm_tty_close(struct tty_struct *tty, struct file *filp) 503 { 504 struct acm *acm = tty->driver_data; 505 int i; 506 507 if (!acm || !acm->used) 508 return; 509 510 down(&open_sem); 511 if (!--acm->used) { 512 if (acm->dev) { 513 acm_set_control(acm, acm->ctrlout = 0); 514 usb_kill_urb(acm->ctrlurb); 515 usb_kill_urb(acm->writeurb); 516 for (i = 0; i < ACM_NRU; i++) 517 usb_kill_urb(acm->ru[i].urb); 518 } else 519 acm_tty_unregister(acm); 520 } 521 up(&open_sem); 522 } 523 524 static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count) 525 { 526 struct acm *acm = tty->driver_data; 527 int stat; 528 unsigned long flags; 529 int wbn; 530 struct acm_wb *wb; 531 532 dbg("Entering acm_tty_write to write %d bytes,\n", count); 533 534 if (!ACM_READY(acm)) 535 return -EINVAL; 536 if (!count) 537 return 0; 538 539 spin_lock_irqsave(&acm->write_lock, flags); 540 if ((wbn = acm_wb_alloc(acm)) < 0) { 541 spin_unlock_irqrestore(&acm->write_lock, flags); 542 acm_write_start(acm); 543 return 0; 544 } 545 wb = &acm->wb[wbn]; 546 547 count = (count > acm->writesize) ? acm->writesize : count; 548 dbg("Get %d bytes...", count); 549 memcpy(wb->buf, buf, count); 550 wb->len = count; 551 spin_unlock_irqrestore(&acm->write_lock, flags); 552 553 if ((stat = acm_write_start(acm)) < 0) 554 return stat; 555 return count; 556 } 557 558 static int acm_tty_write_room(struct tty_struct *tty) 559 { 560 struct acm *acm = tty->driver_data; 561 if (!ACM_READY(acm)) 562 return -EINVAL; 563 /* 564 * Do not let the line discipline to know that we have a reserve, 565 * or it might get too enthusiastic. 566 */ 567 return (acm->write_ready && acm_wb_is_avail(acm)) ? acm->writesize : 0; 568 } 569 570 static int acm_tty_chars_in_buffer(struct tty_struct *tty) 571 { 572 struct acm *acm = tty->driver_data; 573 if (!ACM_READY(acm)) 574 return -EINVAL; 575 /* 576 * This is inaccurate (overcounts), but it works. 577 */ 578 return (ACM_NWB - acm_wb_is_avail(acm)) * acm->writesize; 579 } 580 581 static void acm_tty_throttle(struct tty_struct *tty) 582 { 583 struct acm *acm = tty->driver_data; 584 if (!ACM_READY(acm)) 585 return; 586 spin_lock_bh(&acm->throttle_lock); 587 acm->throttle = 1; 588 spin_unlock_bh(&acm->throttle_lock); 589 } 590 591 static void acm_tty_unthrottle(struct tty_struct *tty) 592 { 593 struct acm *acm = tty->driver_data; 594 if (!ACM_READY(acm)) 595 return; 596 spin_lock_bh(&acm->throttle_lock); 597 acm->throttle = 0; 598 spin_unlock_bh(&acm->throttle_lock); 599 tasklet_schedule(&acm->urb_task); 600 } 601 602 static void acm_tty_break_ctl(struct tty_struct *tty, int state) 603 { 604 struct acm *acm = tty->driver_data; 605 if (!ACM_READY(acm)) 606 return; 607 if (acm_send_break(acm, state ? 0xffff : 0)) 608 dbg("send break failed"); 609 } 610 611 static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file) 612 { 613 struct acm *acm = tty->driver_data; 614 615 if (!ACM_READY(acm)) 616 return -EINVAL; 617 618 return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) | 619 (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) | 620 (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) | 621 (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) | 622 (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) | 623 TIOCM_CTS; 624 } 625 626 static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file, 627 unsigned int set, unsigned int clear) 628 { 629 struct acm *acm = tty->driver_data; 630 unsigned int newctrl; 631 632 if (!ACM_READY(acm)) 633 return -EINVAL; 634 635 newctrl = acm->ctrlout; 636 set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0); 637 clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0); 638 639 newctrl = (newctrl & ~clear) | set; 640 641 if (acm->ctrlout == newctrl) 642 return 0; 643 return acm_set_control(acm, acm->ctrlout = newctrl); 644 } 645 646 static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg) 647 { 648 struct acm *acm = tty->driver_data; 649 650 if (!ACM_READY(acm)) 651 return -EINVAL; 652 653 return -ENOIOCTLCMD; 654 } 655 656 static const __u32 acm_tty_speed[] = { 657 0, 50, 75, 110, 134, 150, 200, 300, 600, 658 1200, 1800, 2400, 4800, 9600, 19200, 38400, 659 57600, 115200, 230400, 460800, 500000, 576000, 660 921600, 1000000, 1152000, 1500000, 2000000, 661 2500000, 3000000, 3500000, 4000000 662 }; 663 664 static const __u8 acm_tty_size[] = { 665 5, 6, 7, 8 666 }; 667 668 static void acm_tty_set_termios(struct tty_struct *tty, struct termios *termios_old) 669 { 670 struct acm *acm = tty->driver_data; 671 struct termios *termios = tty->termios; 672 struct usb_cdc_line_coding newline; 673 int newctrl = acm->ctrlout; 674 675 if (!ACM_READY(acm)) 676 return; 677 678 newline.dwDTERate = cpu_to_le32p(acm_tty_speed + 679 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0)); 680 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0; 681 newline.bParityType = termios->c_cflag & PARENB ? 682 (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0; 683 newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4]; 684 685 acm->clocal = ((termios->c_cflag & CLOCAL) != 0); 686 687 if (!newline.dwDTERate) { 688 newline.dwDTERate = acm->line.dwDTERate; 689 newctrl &= ~ACM_CTRL_DTR; 690 } else newctrl |= ACM_CTRL_DTR; 691 692 if (newctrl != acm->ctrlout) 693 acm_set_control(acm, acm->ctrlout = newctrl); 694 695 if (memcmp(&acm->line, &newline, sizeof newline)) { 696 memcpy(&acm->line, &newline, sizeof newline); 697 dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate), 698 newline.bCharFormat, newline.bParityType, 699 newline.bDataBits); 700 acm_set_line(acm, &acm->line); 701 } 702 } 703 704 /* 705 * USB probe and disconnect routines. 706 */ 707 708 /* Little helper: write buffers free */ 709 static void acm_write_buffers_free(struct acm *acm) 710 { 711 int i; 712 struct acm_wb *wb; 713 714 for (wb = &acm->wb[0], i = 0; i < ACM_NWB; i++, wb++) { 715 usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah); 716 } 717 } 718 719 /* Little helper: write buffers allocate */ 720 static int acm_write_buffers_alloc(struct acm *acm) 721 { 722 int i; 723 struct acm_wb *wb; 724 725 for (wb = &acm->wb[0], i = 0; i < ACM_NWB; i++, wb++) { 726 wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL, 727 &wb->dmah); 728 if (!wb->buf) { 729 while (i != 0) { 730 --i; 731 --wb; 732 usb_buffer_free(acm->dev, acm->writesize, 733 wb->buf, wb->dmah); 734 } 735 return -ENOMEM; 736 } 737 } 738 return 0; 739 } 740 741 static int acm_probe (struct usb_interface *intf, 742 const struct usb_device_id *id) 743 { 744 struct usb_cdc_union_desc *union_header = NULL; 745 char *buffer = intf->altsetting->extra; 746 int buflen = intf->altsetting->extralen; 747 struct usb_interface *control_interface; 748 struct usb_interface *data_interface; 749 struct usb_endpoint_descriptor *epctrl; 750 struct usb_endpoint_descriptor *epread; 751 struct usb_endpoint_descriptor *epwrite; 752 struct usb_device *usb_dev = interface_to_usbdev(intf); 753 struct acm *acm; 754 int minor; 755 int ctrlsize,readsize; 756 u8 *buf; 757 u8 ac_management_function = 0; 758 u8 call_management_function = 0; 759 int call_interface_num = -1; 760 int data_interface_num; 761 unsigned long quirks; 762 int i; 763 764 /* handle quirks deadly to normal probing*/ 765 quirks = (unsigned long)id->driver_info; 766 if (quirks == NO_UNION_NORMAL) { 767 data_interface = usb_ifnum_to_if(usb_dev, 1); 768 control_interface = usb_ifnum_to_if(usb_dev, 0); 769 goto skip_normal_probe; 770 } 771 772 /* normal probing*/ 773 if (!buffer) { 774 err("Wierd descriptor references\n"); 775 return -EINVAL; 776 } 777 778 if (!buflen) { 779 if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) { 780 dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n"); 781 buflen = intf->cur_altsetting->endpoint->extralen; 782 buffer = intf->cur_altsetting->endpoint->extra; 783 } else { 784 err("Zero length descriptor references\n"); 785 return -EINVAL; 786 } 787 } 788 789 while (buflen > 0) { 790 if (buffer [1] != USB_DT_CS_INTERFACE) { 791 err("skipping garbage\n"); 792 goto next_desc; 793 } 794 795 switch (buffer [2]) { 796 case USB_CDC_UNION_TYPE: /* we've found it */ 797 if (union_header) { 798 err("More than one union descriptor, skipping ..."); 799 goto next_desc; 800 } 801 union_header = (struct usb_cdc_union_desc *) 802 buffer; 803 break; 804 case USB_CDC_COUNTRY_TYPE: /* maybe somehow export */ 805 break; /* for now we ignore it */ 806 case USB_CDC_HEADER_TYPE: /* maybe check version */ 807 break; /* for now we ignore it */ 808 case USB_CDC_ACM_TYPE: 809 ac_management_function = buffer[3]; 810 break; 811 case USB_CDC_CALL_MANAGEMENT_TYPE: 812 call_management_function = buffer[3]; 813 call_interface_num = buffer[4]; 814 if ((call_management_function & 3) != 3) 815 err("This device cannot do calls on its own. It is no modem."); 816 break; 817 818 default: 819 err("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]); 820 break; 821 } 822 next_desc: 823 buflen -= buffer[0]; 824 buffer += buffer[0]; 825 } 826 827 if (!union_header) { 828 if (call_interface_num > 0) { 829 dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n"); 830 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num)); 831 control_interface = intf; 832 } else { 833 dev_dbg(&intf->dev,"No union descriptor, giving up\n"); 834 return -ENODEV; 835 } 836 } else { 837 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0); 838 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0)); 839 if (!control_interface || !data_interface) { 840 dev_dbg(&intf->dev,"no interfaces\n"); 841 return -ENODEV; 842 } 843 } 844 845 if (data_interface_num != call_interface_num) 846 dev_dbg(&intf->dev,"Seperate call control interface. That is not fully supported.\n"); 847 848 skip_normal_probe: 849 850 /*workaround for switched interfaces */ 851 if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) { 852 if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) { 853 struct usb_interface *t; 854 dev_dbg(&intf->dev,"Your device has switched interfaces.\n"); 855 856 t = control_interface; 857 control_interface = data_interface; 858 data_interface = t; 859 } else { 860 return -EINVAL; 861 } 862 } 863 864 if (usb_interface_claimed(data_interface)) { /* valid in this context */ 865 dev_dbg(&intf->dev,"The data interface isn't available\n"); 866 return -EBUSY; 867 } 868 869 870 if (data_interface->cur_altsetting->desc.bNumEndpoints < 2) 871 return -EINVAL; 872 873 epctrl = &control_interface->cur_altsetting->endpoint[0].desc; 874 epread = &data_interface->cur_altsetting->endpoint[0].desc; 875 epwrite = &data_interface->cur_altsetting->endpoint[1].desc; 876 877 878 /* workaround for switched endpoints */ 879 if ((epread->bEndpointAddress & USB_DIR_IN) != USB_DIR_IN) { 880 /* descriptors are swapped */ 881 struct usb_endpoint_descriptor *t; 882 dev_dbg(&intf->dev,"The data interface has switched endpoints\n"); 883 884 t = epread; 885 epread = epwrite; 886 epwrite = t; 887 } 888 dbg("interfaces are valid"); 889 for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++); 890 891 if (minor == ACM_TTY_MINORS) { 892 err("no more free acm devices"); 893 return -ENODEV; 894 } 895 896 if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) { 897 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n"); 898 goto alloc_fail; 899 } 900 901 ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize); 902 readsize = le16_to_cpu(epread->wMaxPacketSize)*2; 903 acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize); 904 acm->control = control_interface; 905 acm->data = data_interface; 906 acm->minor = minor; 907 acm->dev = usb_dev; 908 acm->ctrl_caps = ac_management_function; 909 acm->ctrlsize = ctrlsize; 910 acm->readsize = readsize; 911 acm->urb_task.func = acm_rx_tasklet; 912 acm->urb_task.data = (unsigned long) acm; 913 INIT_WORK(&acm->work, acm_softint, acm); 914 spin_lock_init(&acm->throttle_lock); 915 spin_lock_init(&acm->write_lock); 916 spin_lock_init(&acm->read_lock); 917 acm->write_ready = 1; 918 acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress); 919 920 buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); 921 if (!buf) { 922 dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n"); 923 goto alloc_fail2; 924 } 925 acm->ctrl_buffer = buf; 926 927 if (acm_write_buffers_alloc(acm) < 0) { 928 dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n"); 929 goto alloc_fail4; 930 } 931 932 acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL); 933 if (!acm->ctrlurb) { 934 dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n"); 935 goto alloc_fail5; 936 } 937 for (i = 0; i < ACM_NRU; i++) { 938 struct acm_ru *rcv = &(acm->ru[i]); 939 940 if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) { 941 dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n"); 942 goto alloc_fail7; 943 } 944 945 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 946 rcv->instance = acm; 947 } 948 for (i = 0; i < ACM_NRB; i++) { 949 struct acm_rb *buf = &(acm->rb[i]); 950 951 // Using usb_buffer_alloc instead of kmalloc as Oliver suggested 952 if (!(buf->base = usb_buffer_alloc(acm->dev, readsize, GFP_KERNEL, &buf->dma))) { 953 dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n"); 954 goto alloc_fail7; 955 } 956 } 957 acm->writeurb = usb_alloc_urb(0, GFP_KERNEL); 958 if (!acm->writeurb) { 959 dev_dbg(&intf->dev, "out of memory (writeurb kmalloc)\n"); 960 goto alloc_fail7; 961 } 962 963 usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress), 964 acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval); 965 acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 966 acm->ctrlurb->transfer_dma = acm->ctrl_dma; 967 968 usb_fill_bulk_urb(acm->writeurb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress), 969 NULL, acm->writesize, acm_write_bulk, acm); 970 acm->writeurb->transfer_flags |= URB_NO_FSBR | URB_NO_TRANSFER_DMA_MAP; 971 972 dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor); 973 974 acm_set_control(acm, acm->ctrlout); 975 976 acm->line.dwDTERate = cpu_to_le32(9600); 977 acm->line.bDataBits = 8; 978 acm_set_line(acm, &acm->line); 979 980 usb_driver_claim_interface(&acm_driver, data_interface, acm); 981 982 usb_get_intf(control_interface); 983 tty_register_device(acm_tty_driver, minor, &control_interface->dev); 984 985 acm_table[minor] = acm; 986 usb_set_intfdata (intf, acm); 987 return 0; 988 989 alloc_fail7: 990 for (i = 0; i < ACM_NRB; i++) 991 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma); 992 for (i = 0; i < ACM_NRU; i++) 993 usb_free_urb(acm->ru[i].urb); 994 usb_free_urb(acm->ctrlurb); 995 alloc_fail5: 996 acm_write_buffers_free(acm); 997 alloc_fail4: 998 usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); 999 alloc_fail2: 1000 kfree(acm); 1001 alloc_fail: 1002 return -ENOMEM; 1003 } 1004 1005 static void acm_disconnect(struct usb_interface *intf) 1006 { 1007 struct acm *acm = usb_get_intfdata (intf); 1008 struct usb_device *usb_dev = interface_to_usbdev(intf); 1009 int i; 1010 1011 if (!acm || !acm->dev) { 1012 dbg("disconnect on nonexisting interface"); 1013 return; 1014 } 1015 1016 down(&open_sem); 1017 if (!usb_get_intfdata(intf)) { 1018 up(&open_sem); 1019 return; 1020 } 1021 acm->dev = NULL; 1022 usb_set_intfdata(acm->control, NULL); 1023 usb_set_intfdata(acm->data, NULL); 1024 1025 tasklet_disable(&acm->urb_task); 1026 1027 usb_kill_urb(acm->ctrlurb); 1028 usb_kill_urb(acm->writeurb); 1029 for (i = 0; i < ACM_NRU; i++) 1030 usb_kill_urb(acm->ru[i].urb); 1031 1032 INIT_LIST_HEAD(&acm->filled_read_bufs); 1033 INIT_LIST_HEAD(&acm->spare_read_bufs); 1034 1035 tasklet_enable(&acm->urb_task); 1036 1037 flush_scheduled_work(); /* wait for acm_softint */ 1038 1039 acm_write_buffers_free(acm); 1040 usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); 1041 for (i = 0; i < ACM_NRB; i++) 1042 usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma); 1043 1044 usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf); 1045 1046 if (!acm->used) { 1047 acm_tty_unregister(acm); 1048 up(&open_sem); 1049 return; 1050 } 1051 1052 up(&open_sem); 1053 1054 if (acm->tty) 1055 tty_hangup(acm->tty); 1056 } 1057 1058 /* 1059 * USB driver structure. 1060 */ 1061 1062 static struct usb_device_id acm_ids[] = { 1063 /* quirky and broken devices */ 1064 { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */ 1065 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1066 }, 1067 { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */ 1068 .driver_info = NO_UNION_NORMAL, /* has no union descriptor */ 1069 }, 1070 /* control interfaces with various AT-command sets */ 1071 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1072 USB_CDC_ACM_PROTO_AT_V25TER) }, 1073 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1074 USB_CDC_ACM_PROTO_AT_PCCA101) }, 1075 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1076 USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) }, 1077 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1078 USB_CDC_ACM_PROTO_AT_GSM) }, 1079 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1080 USB_CDC_ACM_PROTO_AT_3G ) }, 1081 { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM, 1082 USB_CDC_ACM_PROTO_AT_CDMA) }, 1083 1084 /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */ 1085 { } 1086 }; 1087 1088 MODULE_DEVICE_TABLE (usb, acm_ids); 1089 1090 static struct usb_driver acm_driver = { 1091 .name = "cdc_acm", 1092 .probe = acm_probe, 1093 .disconnect = acm_disconnect, 1094 .id_table = acm_ids, 1095 }; 1096 1097 /* 1098 * TTY driver structures. 1099 */ 1100 1101 static struct tty_operations acm_ops = { 1102 .open = acm_tty_open, 1103 .close = acm_tty_close, 1104 .write = acm_tty_write, 1105 .write_room = acm_tty_write_room, 1106 .ioctl = acm_tty_ioctl, 1107 .throttle = acm_tty_throttle, 1108 .unthrottle = acm_tty_unthrottle, 1109 .chars_in_buffer = acm_tty_chars_in_buffer, 1110 .break_ctl = acm_tty_break_ctl, 1111 .set_termios = acm_tty_set_termios, 1112 .tiocmget = acm_tty_tiocmget, 1113 .tiocmset = acm_tty_tiocmset, 1114 }; 1115 1116 /* 1117 * Init / exit. 1118 */ 1119 1120 static int __init acm_init(void) 1121 { 1122 int retval; 1123 acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS); 1124 if (!acm_tty_driver) 1125 return -ENOMEM; 1126 acm_tty_driver->owner = THIS_MODULE, 1127 acm_tty_driver->driver_name = "acm", 1128 acm_tty_driver->name = "ttyACM", 1129 acm_tty_driver->devfs_name = "usb/acm/", 1130 acm_tty_driver->major = ACM_TTY_MAJOR, 1131 acm_tty_driver->minor_start = 0, 1132 acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL, 1133 acm_tty_driver->subtype = SERIAL_TYPE_NORMAL, 1134 acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS, 1135 acm_tty_driver->init_termios = tty_std_termios; 1136 acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1137 tty_set_operations(acm_tty_driver, &acm_ops); 1138 1139 retval = tty_register_driver(acm_tty_driver); 1140 if (retval) { 1141 put_tty_driver(acm_tty_driver); 1142 return retval; 1143 } 1144 1145 retval = usb_register(&acm_driver); 1146 if (retval) { 1147 tty_unregister_driver(acm_tty_driver); 1148 put_tty_driver(acm_tty_driver); 1149 return retval; 1150 } 1151 1152 info(DRIVER_VERSION ":" DRIVER_DESC); 1153 1154 return 0; 1155 } 1156 1157 static void __exit acm_exit(void) 1158 { 1159 usb_deregister(&acm_driver); 1160 tty_unregister_driver(acm_tty_driver); 1161 put_tty_driver(acm_tty_driver); 1162 } 1163 1164 module_init(acm_init); 1165 module_exit(acm_exit); 1166 1167 MODULE_AUTHOR( DRIVER_AUTHOR ); 1168 MODULE_DESCRIPTION( DRIVER_DESC ); 1169 MODULE_LICENSE("GPL"); 1170 1171