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