1/* 2 * USB Serial Converter driver 3 * 4 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com) 5 * Copyright (C) 2000 Peter Berger (pberger@brimson.com) 6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com) 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License version 10 * 2 as published by the Free Software Foundation. 11 * 12 * This driver was originally based on the ACM driver by Armin Fuerst (which was 13 * based on a driver by Brad Keryan) 14 * 15 * See Documentation/usb/usb-serial.txt for more information on using this 16 * driver 17 * 18 */ 19 20#include <linux/kernel.h> 21#include <linux/errno.h> 22#include <linux/init.h> 23#include <linux/slab.h> 24#include <linux/smp_lock.h> 25#include <linux/tty.h> 26#include <linux/tty_driver.h> 27#include <linux/tty_flip.h> 28#include <linux/module.h> 29#include <linux/moduleparam.h> 30#include <linux/seq_file.h> 31#include <linux/spinlock.h> 32#include <linux/mutex.h> 33#include <linux/list.h> 34#include <linux/uaccess.h> 35#include <linux/serial.h> 36#include <linux/usb.h> 37#include <linux/usb/serial.h> 38#include <linux/kfifo.h> 39#include "pl2303.h" 40 41/* 42 * Version Information 43 */ 44#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/" 45#define DRIVER_DESC "USB Serial Driver core" 46 47/* Driver structure we register with the USB core */ 48static struct usb_driver usb_serial_driver = { 49 .name = "usbserial", 50 .probe = usb_serial_probe, 51 .disconnect = usb_serial_disconnect, 52 .suspend = usb_serial_suspend, 53 .resume = usb_serial_resume, 54 .no_dynamic_id = 1, 55 .supports_autosuspend = 1, 56}; 57 58/* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead 59 the MODULE_DEVICE_TABLE declarations in each serial driver 60 cause the "hotplug" program to pull in whatever module is necessary 61 via modprobe, and modprobe will load usbserial because the serial 62 drivers depend on it. 63*/ 64 65static int debug; 66/* initially all NULL */ 67static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; 68static DEFINE_MUTEX(table_lock); 69static LIST_HEAD(usb_serial_driver_list); 70 71/* 72 * Look up the serial structure. If it is found and it hasn't been 73 * disconnected, return with its disc_mutex held and its refcount 74 * incremented. Otherwise return NULL. 75 */ 76struct usb_serial *usb_serial_get_by_index(unsigned index) 77{ 78 struct usb_serial *serial; 79 80 mutex_lock(&table_lock); 81 serial = serial_table[index]; 82 83 if (serial) { 84 mutex_lock(&serial->disc_mutex); 85 if (serial->disconnected) { 86 mutex_unlock(&serial->disc_mutex); 87 serial = NULL; 88 } else { 89 kref_get(&serial->kref); 90 } 91 } 92 mutex_unlock(&table_lock); 93 return serial; 94} 95 96static struct usb_serial *get_free_serial(struct usb_serial *serial, 97 int num_ports, unsigned int *minor) 98{ 99 unsigned int i, j; 100 int good_spot; 101 102 dbg("%s %d", __func__, num_ports); 103 104 *minor = 0; 105 mutex_lock(&table_lock); 106 for (i = 0; i < SERIAL_TTY_MINORS; ++i) { 107 if (serial_table[i]) 108 continue; 109 110 good_spot = 1; 111 for (j = 1; j <= num_ports-1; ++j) 112 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) { 113 good_spot = 0; 114 i += j; 115 break; 116 } 117 if (good_spot == 0) 118 continue; 119 120 *minor = i; 121 j = 0; 122 dbg("%s - minor base = %d", __func__, *minor); 123 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) { 124 serial_table[i] = serial; 125 serial->port[j++]->number = i; 126 } 127 mutex_unlock(&table_lock); 128 return serial; 129 } 130 mutex_unlock(&table_lock); 131 return NULL; 132} 133 134static void return_serial(struct usb_serial *serial) 135{ 136 int i; 137 138 dbg("%s", __func__); 139 140 mutex_lock(&table_lock); 141 for (i = 0; i < serial->num_ports; ++i) 142 serial_table[serial->minor + i] = NULL; 143 mutex_unlock(&table_lock); 144} 145 146static void destroy_serial(struct kref *kref) 147{ 148 struct usb_serial *serial; 149 struct usb_serial_port *port; 150 int i; 151 152 serial = to_usb_serial(kref); 153 154 dbg("%s - %s", __func__, serial->type->description); 155 156 /* return the minor range that this device had */ 157 if (serial->minor != SERIAL_TTY_NO_MINOR) 158 return_serial(serial); 159 160 if (serial->attached) 161 serial->type->release(serial); 162 163 /* Now that nothing is using the ports, they can be freed */ 164 for (i = 0; i < serial->num_port_pointers; ++i) { 165 port = serial->port[i]; 166 if (port) { 167 port->serial = NULL; 168 put_device(&port->dev); 169 } 170 } 171 172 usb_put_dev(serial->dev); 173 kfree(serial); 174} 175 176void usb_serial_put(struct usb_serial *serial) 177{ 178 kref_put(&serial->kref, destroy_serial); 179} 180 181/***************************************************************************** 182 * Driver tty interface functions 183 *****************************************************************************/ 184 185/** 186 * serial_install - install tty 187 * @driver: the driver (USB in our case) 188 * @tty: the tty being created 189 * 190 * Create the termios objects for this tty. We use the default 191 * USB serial settings but permit them to be overridden by 192 * serial->type->init_termios. 193 * 194 * This is the first place a new tty gets used. Hence this is where we 195 * acquire references to the usb_serial structure and the driver module, 196 * where we store a pointer to the port, and where we do an autoresume. 197 * All these actions are reversed in serial_cleanup(). 198 */ 199static int serial_install(struct tty_driver *driver, struct tty_struct *tty) 200{ 201 int idx = tty->index; 202 struct usb_serial *serial; 203 struct usb_serial_port *port; 204 int retval = -ENODEV; 205 206 dbg("%s", __func__); 207 208 serial = usb_serial_get_by_index(idx); 209 if (!serial) 210 return retval; 211 212 port = serial->port[idx - serial->minor]; 213 if (!port) 214 goto error_no_port; 215 if (!try_module_get(serial->type->driver.owner)) 216 goto error_module_get; 217 218 /* perform the standard setup */ 219 retval = tty_init_termios(tty); 220 if (retval) 221 goto error_init_termios; 222 223 retval = usb_autopm_get_interface(serial->interface); 224 if (retval) 225 goto error_get_interface; 226 227 mutex_unlock(&serial->disc_mutex); 228 229 /* allow the driver to update the settings */ 230 if (serial->type->init_termios) 231 serial->type->init_termios(tty); 232 233 tty->driver_data = port; 234 235 /* Final install (we use the default method) */ 236 tty_driver_kref_get(driver); 237 tty->count++; 238 driver->ttys[idx] = tty; 239 return retval; 240 241 error_get_interface: 242 error_init_termios: 243 module_put(serial->type->driver.owner); 244 error_module_get: 245 error_no_port: 246 usb_serial_put(serial); 247 mutex_unlock(&serial->disc_mutex); 248 return retval; 249} 250 251static int serial_activate(struct tty_port *tport, struct tty_struct *tty) 252{ 253 struct usb_serial_port *port = 254 container_of(tport, struct usb_serial_port, port); 255 struct usb_serial *serial = port->serial; 256 int retval; 257 258 mutex_lock(&serial->disc_mutex); 259 if (serial->disconnected) 260 retval = -ENODEV; 261 else 262 retval = port->serial->type->open(tty, port); 263 mutex_unlock(&serial->disc_mutex); 264 return retval; 265} 266 267static int serial_open(struct tty_struct *tty, struct file *filp) 268{ 269 struct usb_serial_port *port = tty->driver_data; 270 271 dbg("%s - port %d", __func__, port->number); 272 return tty_port_open(&port->port, tty, filp); 273} 274 275/** 276 * serial_down - shut down hardware 277 * @tport: tty port to shut down 278 * 279 * Shut down a USB serial port unless it is the console. We never 280 * shut down the console hardware as it will always be in use. Serialized 281 * against activate by the tport mutex and kept to matching open/close pairs 282 * of calls by the ASYNCB_INITIALIZED flag. 283 */ 284static void serial_down(struct tty_port *tport) 285{ 286 struct usb_serial_port *port = 287 container_of(tport, struct usb_serial_port, port); 288 struct usb_serial_driver *drv = port->serial->type; 289 /* 290 * The console is magical. Do not hang up the console hardware 291 * or there will be tears. 292 */ 293 if (port->port.console) 294 return; 295 if (drv->close) 296 drv->close(port); 297} 298 299static void serial_hangup(struct tty_struct *tty) 300{ 301 struct usb_serial_port *port = tty->driver_data; 302 dbg("%s - port %d", __func__, port->number); 303 tty_port_hangup(&port->port); 304} 305 306static void serial_close(struct tty_struct *tty, struct file *filp) 307{ 308 struct usb_serial_port *port = tty->driver_data; 309 dbg("%s - port %d", __func__, port->number); 310 tty_port_close(&port->port, tty, filp); 311} 312 313/** 314 * serial_cleanup - free resources post close/hangup 315 * @port: port to free up 316 * 317 * Do the resource freeing and refcount dropping for the port. 318 * Avoid freeing the console. 319 * 320 * Called asynchronously after the last tty kref is dropped, 321 * and the tty layer has already done the tty_shutdown(tty); 322 */ 323static void serial_cleanup(struct tty_struct *tty) 324{ 325 struct usb_serial_port *port = tty->driver_data; 326 struct usb_serial *serial; 327 struct module *owner; 328 329 /* The console is magical. Do not hang up the console hardware 330 * or there will be tears. 331 */ 332 if (port->port.console) 333 return; 334 335 dbg("%s - port %d", __func__, port->number); 336 337 tty->driver_data = NULL; 338 339 serial = port->serial; 340 owner = serial->type->driver.owner; 341 342 mutex_lock(&serial->disc_mutex); 343 if (!serial->disconnected) 344 usb_autopm_put_interface(serial->interface); 345 mutex_unlock(&serial->disc_mutex); 346 347 usb_serial_put(serial); 348 module_put(owner); 349} 350 351static int serial_write(struct tty_struct *tty, const unsigned char *buf, 352 int count) 353{ 354 struct usb_serial_port *port = tty->driver_data; 355 int retval = -ENODEV; 356 357 if (port->serial->dev->state == USB_STATE_NOTATTACHED) 358 goto exit; 359 360 dbg("%s - port %d, %d byte(s)", __func__, port->number, count); 361 362 /* pass on to the driver specific version of this function */ 363 retval = port->serial->type->write(tty, port, buf, count); 364 365exit: 366 return retval; 367} 368 369static int serial_write_room(struct tty_struct *tty) 370{ 371 struct usb_serial_port *port = tty->driver_data; 372 dbg("%s - port %d", __func__, port->number); 373 /* pass on to the driver specific version of this function */ 374 return port->serial->type->write_room(tty); 375} 376 377static int serial_chars_in_buffer(struct tty_struct *tty) 378{ 379 struct usb_serial_port *port = tty->driver_data; 380 dbg("%s - port %d", __func__, port->number); 381 382 /* if the device was unplugged then any remaining characters 383 fell out of the connector ;) */ 384 if (port->serial->disconnected) 385 return 0; 386 /* pass on to the driver specific version of this function */ 387 return port->serial->type->chars_in_buffer(tty); 388} 389 390static void serial_throttle(struct tty_struct *tty) 391{ 392 struct usb_serial_port *port = tty->driver_data; 393 dbg("%s - port %d", __func__, port->number); 394 395 /* pass on to the driver specific version of this function */ 396 if (port->serial->type->throttle) 397 port->serial->type->throttle(tty); 398} 399 400static void serial_unthrottle(struct tty_struct *tty) 401{ 402 struct usb_serial_port *port = tty->driver_data; 403 dbg("%s - port %d", __func__, port->number); 404 405 /* pass on to the driver specific version of this function */ 406 if (port->serial->type->unthrottle) 407 port->serial->type->unthrottle(tty); 408} 409 410static int serial_ioctl(struct tty_struct *tty, struct file *file, 411 unsigned int cmd, unsigned long arg) 412{ 413 struct usb_serial_port *port = tty->driver_data; 414 int retval = -ENODEV; 415 416 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd); 417 418 /* pass on to the driver specific version of this function 419 if it is available */ 420 if (port->serial->type->ioctl) { 421 retval = port->serial->type->ioctl(tty, file, cmd, arg); 422 } else 423 retval = -ENOIOCTLCMD; 424 return retval; 425} 426 427static void serial_set_termios(struct tty_struct *tty, struct ktermios *old) 428{ 429 struct usb_serial_port *port = tty->driver_data; 430 dbg("%s - port %d", __func__, port->number); 431 432 /* pass on to the driver specific version of this function 433 if it is available */ 434 if (port->serial->type->set_termios) 435 port->serial->type->set_termios(tty, port, old); 436 else 437 tty_termios_copy_hw(tty->termios, old); 438} 439 440static int serial_break(struct tty_struct *tty, int break_state) 441{ 442 struct usb_serial_port *port = tty->driver_data; 443 444 dbg("%s - port %d", __func__, port->number); 445 446 /* pass on to the driver specific version of this function 447 if it is available */ 448 if (port->serial->type->break_ctl) 449 port->serial->type->break_ctl(tty, break_state); 450 return 0; 451} 452 453static int serial_proc_show(struct seq_file *m, void *v) 454{ 455 struct usb_serial *serial; 456 int i; 457 char tmp[40]; 458 459 dbg("%s", __func__); 460 seq_puts(m, "usbserinfo:1.0 driver:2.0\n"); 461 for (i = 0; i < SERIAL_TTY_MINORS; ++i) { 462 serial = usb_serial_get_by_index(i); 463 if (serial == NULL) 464 continue; 465 466 seq_printf(m, "%d:", i); 467 if (serial->type->driver.owner) 468 seq_printf(m, " module:%s", 469 module_name(serial->type->driver.owner)); 470 seq_printf(m, " name:\"%s\"", 471 serial->type->description); 472 seq_printf(m, " vendor:%04x product:%04x", 473 le16_to_cpu(serial->dev->descriptor.idVendor), 474 le16_to_cpu(serial->dev->descriptor.idProduct)); 475 seq_printf(m, " num_ports:%d", serial->num_ports); 476 seq_printf(m, " port:%d", i - serial->minor + 1); 477 usb_make_path(serial->dev, tmp, sizeof(tmp)); 478 seq_printf(m, " path:%s", tmp); 479 480 seq_putc(m, '\n'); 481 usb_serial_put(serial); 482 mutex_unlock(&serial->disc_mutex); 483 } 484 return 0; 485} 486 487static int serial_proc_open(struct inode *inode, struct file *file) 488{ 489 return single_open(file, serial_proc_show, NULL); 490} 491 492static const struct file_operations serial_proc_fops = { 493 .owner = THIS_MODULE, 494 .open = serial_proc_open, 495 .read = seq_read, 496 .llseek = seq_lseek, 497 .release = single_release, 498}; 499 500static int serial_tiocmget(struct tty_struct *tty, struct file *file) 501{ 502 struct usb_serial_port *port = tty->driver_data; 503 504 dbg("%s - port %d", __func__, port->number); 505 506 if (port->serial->type->tiocmget) 507 return port->serial->type->tiocmget(tty, file); 508 return -EINVAL; 509} 510 511static int serial_tiocmset(struct tty_struct *tty, struct file *file, 512 unsigned int set, unsigned int clear) 513{ 514 struct usb_serial_port *port = tty->driver_data; 515 516 dbg("%s - port %d", __func__, port->number); 517 518 if (port->serial->type->tiocmset) 519 return port->serial->type->tiocmset(tty, file, set, clear); 520 return -EINVAL; 521} 522 523/* 524 * We would be calling tty_wakeup here, but unfortunately some line 525 * disciplines have an annoying habit of calling tty->write from 526 * the write wakeup callback (e.g. n_hdlc.c). 527 */ 528void usb_serial_port_softint(struct usb_serial_port *port) 529{ 530 schedule_work(&port->work); 531} 532EXPORT_SYMBOL_GPL(usb_serial_port_softint); 533 534static void usb_serial_port_work(struct work_struct *work) 535{ 536 struct usb_serial_port *port = 537 container_of(work, struct usb_serial_port, work); 538 struct tty_struct *tty; 539 540 dbg("%s - port %d", __func__, port->number); 541 542 tty = tty_port_tty_get(&port->port); 543 if (!tty) 544 return; 545 546 tty_wakeup(tty); 547 tty_kref_put(tty); 548} 549 550static void kill_traffic(struct usb_serial_port *port) 551{ 552 int i; 553 554 usb_kill_urb(port->read_urb); 555 usb_kill_urb(port->write_urb); 556 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) 557 usb_kill_urb(port->write_urbs[i]); 558 /* 559 * This is tricky. 560 * Some drivers submit the read_urb in the 561 * handler for the write_urb or vice versa 562 * this order determines the order in which 563 * usb_kill_urb() must be used to reliably 564 * kill the URBs. As it is unknown here, 565 * both orders must be used in turn. 566 * The call below is not redundant. 567 */ 568 usb_kill_urb(port->read_urb); 569 usb_kill_urb(port->interrupt_in_urb); 570 usb_kill_urb(port->interrupt_out_urb); 571} 572 573static void port_release(struct device *dev) 574{ 575 struct usb_serial_port *port = to_usb_serial_port(dev); 576 int i; 577 578 dbg ("%s - %s", __func__, dev_name(dev)); 579 580 /* 581 * Stop all the traffic before cancelling the work, so that 582 * nobody will restart it by calling usb_serial_port_softint. 583 */ 584 kill_traffic(port); 585 cancel_work_sync(&port->work); 586 587 usb_free_urb(port->read_urb); 588 usb_free_urb(port->write_urb); 589 usb_free_urb(port->interrupt_in_urb); 590 usb_free_urb(port->interrupt_out_urb); 591 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) { 592 usb_free_urb(port->write_urbs[i]); 593 kfree(port->bulk_out_buffers[i]); 594 } 595 kfifo_free(&port->write_fifo); 596 kfree(port->bulk_in_buffer); 597 kfree(port->bulk_out_buffer); 598 kfree(port->interrupt_in_buffer); 599 kfree(port->interrupt_out_buffer); 600 kfree(port); 601} 602 603static struct usb_serial *create_serial(struct usb_device *dev, 604 struct usb_interface *interface, 605 struct usb_serial_driver *driver) 606{ 607 struct usb_serial *serial; 608 609 serial = kzalloc(sizeof(*serial), GFP_KERNEL); 610 if (!serial) { 611 dev_err(&dev->dev, "%s - out of memory\n", __func__); 612 return NULL; 613 } 614 serial->dev = usb_get_dev(dev); 615 serial->type = driver; 616 serial->interface = interface; 617 kref_init(&serial->kref); 618 mutex_init(&serial->disc_mutex); 619 serial->minor = SERIAL_TTY_NO_MINOR; 620 621 return serial; 622} 623 624static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf, 625 struct usb_serial_driver *drv) 626{ 627 struct usb_dynid *dynid; 628 629 spin_lock(&drv->dynids.lock); 630 list_for_each_entry(dynid, &drv->dynids.list, node) { 631 if (usb_match_one_id(intf, &dynid->id)) { 632 spin_unlock(&drv->dynids.lock); 633 return &dynid->id; 634 } 635 } 636 spin_unlock(&drv->dynids.lock); 637 return NULL; 638} 639 640static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv, 641 struct usb_interface *intf) 642{ 643 const struct usb_device_id *id; 644 645 id = usb_match_id(intf, drv->id_table); 646 if (id) { 647 dbg("static descriptor matches"); 648 goto exit; 649 } 650 id = match_dynamic_id(intf, drv); 651 if (id) 652 dbg("dynamic descriptor matches"); 653exit: 654 return id; 655} 656 657/* Caller must hold table_lock */ 658static struct usb_serial_driver *search_serial_device( 659 struct usb_interface *iface) 660{ 661 const struct usb_device_id *id; 662 struct usb_serial_driver *drv; 663 664 /* Check if the usb id matches a known device */ 665 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) { 666 id = get_iface_id(drv, iface); 667 if (id) 668 return drv; 669 } 670 671 return NULL; 672} 673 674static int serial_carrier_raised(struct tty_port *port) 675{ 676 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port); 677 struct usb_serial_driver *drv = p->serial->type; 678 if (drv->carrier_raised) 679 return drv->carrier_raised(p); 680 /* No carrier control - don't block */ 681 return 1; 682} 683 684static void serial_dtr_rts(struct tty_port *port, int on) 685{ 686 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port); 687 struct usb_serial_driver *drv = p->serial->type; 688 if (drv->dtr_rts) 689 drv->dtr_rts(p, on); 690} 691 692static const struct tty_port_operations serial_port_ops = { 693 .carrier_raised = serial_carrier_raised, 694 .dtr_rts = serial_dtr_rts, 695 .activate = serial_activate, 696 .shutdown = serial_down, 697}; 698 699int usb_serial_probe(struct usb_interface *interface, 700 const struct usb_device_id *id) 701{ 702 struct usb_device *dev = interface_to_usbdev(interface); 703 struct usb_serial *serial = NULL; 704 struct usb_serial_port *port; 705 struct usb_host_interface *iface_desc; 706 struct usb_endpoint_descriptor *endpoint; 707 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS]; 708 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS]; 709 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS]; 710 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS]; 711 struct usb_serial_driver *type = NULL; 712 int retval; 713 unsigned int minor; 714 int buffer_size; 715 int i; 716 int num_interrupt_in = 0; 717 int num_interrupt_out = 0; 718 int num_bulk_in = 0; 719 int num_bulk_out = 0; 720 int num_ports = 0; 721 int max_endpoints; 722 723 mutex_lock(&table_lock); 724 type = search_serial_device(interface); 725 if (!type) { 726 mutex_unlock(&table_lock); 727 dbg("none matched"); 728 return -ENODEV; 729 } 730 731 if (!try_module_get(type->driver.owner)) { 732 mutex_unlock(&table_lock); 733 dev_err(&interface->dev, "module get failed, exiting\n"); 734 return -EIO; 735 } 736 mutex_unlock(&table_lock); 737 738 serial = create_serial(dev, interface, type); 739 if (!serial) { 740 module_put(type->driver.owner); 741 dev_err(&interface->dev, "%s - out of memory\n", __func__); 742 return -ENOMEM; 743 } 744 745 /* if this device type has a probe function, call it */ 746 if (type->probe) { 747 const struct usb_device_id *id; 748 749 id = get_iface_id(type, interface); 750 retval = type->probe(serial, id); 751 752 if (retval) { 753 dbg("sub driver rejected device"); 754 kfree(serial); 755 module_put(type->driver.owner); 756 return retval; 757 } 758 } 759 760 /* descriptor matches, let's find the endpoints needed */ 761 /* check out the endpoints */ 762 iface_desc = interface->cur_altsetting; 763 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 764 endpoint = &iface_desc->endpoint[i].desc; 765 766 if (usb_endpoint_is_bulk_in(endpoint)) { 767 /* we found a bulk in endpoint */ 768 dbg("found bulk in on endpoint %d", i); 769 bulk_in_endpoint[num_bulk_in] = endpoint; 770 ++num_bulk_in; 771 } 772 773 if (usb_endpoint_is_bulk_out(endpoint)) { 774 /* we found a bulk out endpoint */ 775 dbg("found bulk out on endpoint %d", i); 776 bulk_out_endpoint[num_bulk_out] = endpoint; 777 ++num_bulk_out; 778 } 779 780 if (usb_endpoint_is_int_in(endpoint)) { 781 /* we found a interrupt in endpoint */ 782 dbg("found interrupt in on endpoint %d", i); 783 interrupt_in_endpoint[num_interrupt_in] = endpoint; 784 ++num_interrupt_in; 785 } 786 787 if (usb_endpoint_is_int_out(endpoint)) { 788 /* we found an interrupt out endpoint */ 789 dbg("found interrupt out on endpoint %d", i); 790 interrupt_out_endpoint[num_interrupt_out] = endpoint; 791 ++num_interrupt_out; 792 } 793 } 794 795#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE) 796 /* BEGIN HORRIBLE HACK FOR PL2303 */ 797 /* this is needed due to the looney way its endpoints are set up */ 798 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) && 799 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) || 800 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) && 801 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) || 802 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) && 803 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) || 804 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) && 805 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) { 806 if (interface != dev->actconfig->interface[0]) { 807 /* check out the endpoints of the other interface*/ 808 iface_desc = dev->actconfig->interface[0]->cur_altsetting; 809 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 810 endpoint = &iface_desc->endpoint[i].desc; 811 if (usb_endpoint_is_int_in(endpoint)) { 812 /* we found a interrupt in endpoint */ 813 dbg("found interrupt in for Prolific device on separate interface"); 814 interrupt_in_endpoint[num_interrupt_in] = endpoint; 815 ++num_interrupt_in; 816 } 817 } 818 } 819 820 /* Now make sure the PL-2303 is configured correctly. 821 * If not, give up now and hope this hack will work 822 * properly during a later invocation of usb_serial_probe 823 */ 824 if (num_bulk_in == 0 || num_bulk_out == 0) { 825 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n"); 826 kfree(serial); 827 module_put(type->driver.owner); 828 return -ENODEV; 829 } 830 } 831 /* END HORRIBLE HACK FOR PL2303 */ 832#endif 833 834#ifdef CONFIG_USB_SERIAL_GENERIC 835 if (type == &usb_serial_generic_device) { 836 num_ports = num_bulk_out; 837 if (num_ports == 0) { 838 dev_err(&interface->dev, 839 "Generic device with no bulk out, not allowed.\n"); 840 kfree(serial); 841 module_put(type->driver.owner); 842 return -EIO; 843 } 844 } 845#endif 846 if (!num_ports) { 847 /* if this device type has a calc_num_ports function, call it */ 848 if (type->calc_num_ports) 849 num_ports = type->calc_num_ports(serial); 850 if (!num_ports) 851 num_ports = type->num_ports; 852 } 853 854 serial->num_ports = num_ports; 855 serial->num_bulk_in = num_bulk_in; 856 serial->num_bulk_out = num_bulk_out; 857 serial->num_interrupt_in = num_interrupt_in; 858 serial->num_interrupt_out = num_interrupt_out; 859 860 /* found all that we need */ 861 dev_info(&interface->dev, "%s converter detected\n", 862 type->description); 863 864 /* create our ports, we need as many as the max endpoints */ 865 /* we don't use num_ports here because some devices have more 866 endpoint pairs than ports */ 867 max_endpoints = max(num_bulk_in, num_bulk_out); 868 max_endpoints = max(max_endpoints, num_interrupt_in); 869 max_endpoints = max(max_endpoints, num_interrupt_out); 870 max_endpoints = max(max_endpoints, (int)serial->num_ports); 871 serial->num_port_pointers = max_endpoints; 872 873 dbg("%s - setting up %d port structures for this device", 874 __func__, max_endpoints); 875 for (i = 0; i < max_endpoints; ++i) { 876 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL); 877 if (!port) 878 goto probe_error; 879 tty_port_init(&port->port); 880 port->port.ops = &serial_port_ops; 881 port->serial = serial; 882 spin_lock_init(&port->lock); 883 /* Keep this for private driver use for the moment but 884 should probably go away */ 885 INIT_WORK(&port->work, usb_serial_port_work); 886 serial->port[i] = port; 887 port->dev.parent = &interface->dev; 888 port->dev.driver = NULL; 889 port->dev.bus = &usb_serial_bus_type; 890 port->dev.release = &port_release; 891 device_initialize(&port->dev); 892 } 893 894 /* set up the endpoint information */ 895 for (i = 0; i < num_bulk_in; ++i) { 896 endpoint = bulk_in_endpoint[i]; 897 port = serial->port[i]; 898 port->read_urb = usb_alloc_urb(0, GFP_KERNEL); 899 if (!port->read_urb) { 900 dev_err(&interface->dev, "No free urbs available\n"); 901 goto probe_error; 902 } 903 buffer_size = serial->type->bulk_in_size; 904 if (!buffer_size) 905 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 906 port->bulk_in_size = buffer_size; 907 port->bulk_in_endpointAddress = endpoint->bEndpointAddress; 908 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL); 909 if (!port->bulk_in_buffer) { 910 dev_err(&interface->dev, 911 "Couldn't allocate bulk_in_buffer\n"); 912 goto probe_error; 913 } 914 usb_fill_bulk_urb(port->read_urb, dev, 915 usb_rcvbulkpipe(dev, 916 endpoint->bEndpointAddress), 917 port->bulk_in_buffer, buffer_size, 918 serial->type->read_bulk_callback, port); 919 } 920 921 for (i = 0; i < num_bulk_out; ++i) { 922 int j; 923 924 endpoint = bulk_out_endpoint[i]; 925 port = serial->port[i]; 926 port->write_urb = usb_alloc_urb(0, GFP_KERNEL); 927 if (!port->write_urb) { 928 dev_err(&interface->dev, "No free urbs available\n"); 929 goto probe_error; 930 } 931 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL)) 932 goto probe_error; 933 buffer_size = serial->type->bulk_out_size; 934 if (!buffer_size) 935 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 936 port->bulk_out_size = buffer_size; 937 port->bulk_out_endpointAddress = endpoint->bEndpointAddress; 938 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL); 939 if (!port->bulk_out_buffer) { 940 dev_err(&interface->dev, 941 "Couldn't allocate bulk_out_buffer\n"); 942 goto probe_error; 943 } 944 usb_fill_bulk_urb(port->write_urb, dev, 945 usb_sndbulkpipe(dev, 946 endpoint->bEndpointAddress), 947 port->bulk_out_buffer, buffer_size, 948 serial->type->write_bulk_callback, port); 949 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) { 950 set_bit(j, &port->write_urbs_free); 951 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL); 952 if (!port->write_urbs[j]) { 953 dev_err(&interface->dev, 954 "No free urbs available\n"); 955 goto probe_error; 956 } 957 port->bulk_out_buffers[j] = kmalloc(buffer_size, 958 GFP_KERNEL); 959 if (!port->bulk_out_buffers[j]) { 960 dev_err(&interface->dev, 961 "Couldn't allocate bulk_out_buffer\n"); 962 goto probe_error; 963 } 964 usb_fill_bulk_urb(port->write_urbs[j], dev, 965 usb_sndbulkpipe(dev, 966 endpoint->bEndpointAddress), 967 port->bulk_out_buffers[j], buffer_size, 968 serial->type->write_bulk_callback, 969 port); 970 } 971 } 972 973 if (serial->type->read_int_callback) { 974 for (i = 0; i < num_interrupt_in; ++i) { 975 endpoint = interrupt_in_endpoint[i]; 976 port = serial->port[i]; 977 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); 978 if (!port->interrupt_in_urb) { 979 dev_err(&interface->dev, 980 "No free urbs available\n"); 981 goto probe_error; 982 } 983 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 984 port->interrupt_in_endpointAddress = 985 endpoint->bEndpointAddress; 986 port->interrupt_in_buffer = kmalloc(buffer_size, 987 GFP_KERNEL); 988 if (!port->interrupt_in_buffer) { 989 dev_err(&interface->dev, 990 "Couldn't allocate interrupt_in_buffer\n"); 991 goto probe_error; 992 } 993 usb_fill_int_urb(port->interrupt_in_urb, dev, 994 usb_rcvintpipe(dev, 995 endpoint->bEndpointAddress), 996 port->interrupt_in_buffer, buffer_size, 997 serial->type->read_int_callback, port, 998 endpoint->bInterval); 999 } 1000 } else if (num_interrupt_in) { 1001 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined"); 1002 } 1003 1004 if (serial->type->write_int_callback) { 1005 for (i = 0; i < num_interrupt_out; ++i) { 1006 endpoint = interrupt_out_endpoint[i]; 1007 port = serial->port[i]; 1008 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); 1009 if (!port->interrupt_out_urb) { 1010 dev_err(&interface->dev, 1011 "No free urbs available\n"); 1012 goto probe_error; 1013 } 1014 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 1015 port->interrupt_out_size = buffer_size; 1016 port->interrupt_out_endpointAddress = 1017 endpoint->bEndpointAddress; 1018 port->interrupt_out_buffer = kmalloc(buffer_size, 1019 GFP_KERNEL); 1020 if (!port->interrupt_out_buffer) { 1021 dev_err(&interface->dev, 1022 "Couldn't allocate interrupt_out_buffer\n"); 1023 goto probe_error; 1024 } 1025 usb_fill_int_urb(port->interrupt_out_urb, dev, 1026 usb_sndintpipe(dev, 1027 endpoint->bEndpointAddress), 1028 port->interrupt_out_buffer, buffer_size, 1029 serial->type->write_int_callback, port, 1030 endpoint->bInterval); 1031 } 1032 } else if (num_interrupt_out) { 1033 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined"); 1034 } 1035 1036 /* if this device type has an attach function, call it */ 1037 if (type->attach) { 1038 retval = type->attach(serial); 1039 if (retval < 0) 1040 goto probe_error; 1041 serial->attached = 1; 1042 if (retval > 0) { 1043 /* quietly accept this device, but don't bind to a 1044 serial port as it's about to disappear */ 1045 serial->num_ports = 0; 1046 goto exit; 1047 } 1048 } else { 1049 serial->attached = 1; 1050 } 1051 1052 if (get_free_serial(serial, num_ports, &minor) == NULL) { 1053 dev_err(&interface->dev, "No more free serial devices\n"); 1054 goto probe_error; 1055 } 1056 serial->minor = minor; 1057 1058 /* register all of the individual ports with the driver core */ 1059 for (i = 0; i < num_ports; ++i) { 1060 port = serial->port[i]; 1061 dev_set_name(&port->dev, "ttyUSB%d", port->number); 1062 dbg ("%s - registering %s", __func__, dev_name(&port->dev)); 1063 port->dev_state = PORT_REGISTERING; 1064 device_enable_async_suspend(&port->dev); 1065 1066 retval = device_add(&port->dev); 1067 if (retval) { 1068 dev_err(&port->dev, "Error registering port device, " 1069 "continuing\n"); 1070 port->dev_state = PORT_UNREGISTERED; 1071 } else { 1072 port->dev_state = PORT_REGISTERED; 1073 } 1074 } 1075 1076 usb_serial_console_init(debug, minor); 1077 1078exit: 1079 /* success */ 1080 usb_set_intfdata(interface, serial); 1081 module_put(type->driver.owner); 1082 return 0; 1083 1084probe_error: 1085 usb_serial_put(serial); 1086 module_put(type->driver.owner); 1087 return -EIO; 1088} 1089EXPORT_SYMBOL_GPL(usb_serial_probe); 1090 1091void usb_serial_disconnect(struct usb_interface *interface) 1092{ 1093 int i; 1094 struct usb_serial *serial = usb_get_intfdata(interface); 1095 struct device *dev = &interface->dev; 1096 struct usb_serial_port *port; 1097 1098 usb_serial_console_disconnect(serial); 1099 dbg("%s", __func__); 1100 1101 mutex_lock(&serial->disc_mutex); 1102 usb_set_intfdata(interface, NULL); 1103 /* must set a flag, to signal subdrivers */ 1104 serial->disconnected = 1; 1105 mutex_unlock(&serial->disc_mutex); 1106 1107 for (i = 0; i < serial->num_ports; ++i) { 1108 port = serial->port[i]; 1109 if (port) { 1110 struct tty_struct *tty = tty_port_tty_get(&port->port); 1111 if (tty) { 1112 tty_vhangup(tty); 1113 tty_kref_put(tty); 1114 } 1115 kill_traffic(port); 1116 cancel_work_sync(&port->work); 1117 if (port->dev_state == PORT_REGISTERED) { 1118 1119 /* Make sure the port is bound so that the 1120 * driver's port_remove method is called. 1121 */ 1122 if (!port->dev.driver) { 1123 int rc; 1124 1125 port->dev.driver = 1126 &serial->type->driver; 1127 rc = device_bind_driver(&port->dev); 1128 } 1129 port->dev_state = PORT_UNREGISTERING; 1130 device_del(&port->dev); 1131 port->dev_state = PORT_UNREGISTERED; 1132 } 1133 } 1134 } 1135 serial->type->disconnect(serial); 1136 1137 /* let the last holder of this object cause it to be cleaned up */ 1138 usb_serial_put(serial); 1139 dev_info(dev, "device disconnected\n"); 1140} 1141EXPORT_SYMBOL_GPL(usb_serial_disconnect); 1142 1143int usb_serial_suspend(struct usb_interface *intf, pm_message_t message) 1144{ 1145 struct usb_serial *serial = usb_get_intfdata(intf); 1146 struct usb_serial_port *port; 1147 int i, r = 0; 1148 1149 serial->suspending = 1; 1150 1151 if (serial->type->suspend) { 1152 r = serial->type->suspend(serial, message); 1153 if (r < 0) { 1154 serial->suspending = 0; 1155 goto err_out; 1156 } 1157 } 1158 1159 for (i = 0; i < serial->num_ports; ++i) { 1160 port = serial->port[i]; 1161 if (port) 1162 kill_traffic(port); 1163 } 1164 1165err_out: 1166 return r; 1167} 1168EXPORT_SYMBOL(usb_serial_suspend); 1169 1170int usb_serial_resume(struct usb_interface *intf) 1171{ 1172 struct usb_serial *serial = usb_get_intfdata(intf); 1173 int rv; 1174 1175 serial->suspending = 0; 1176 if (serial->type->resume) 1177 rv = serial->type->resume(serial); 1178 else 1179 rv = usb_serial_generic_resume(serial); 1180 1181 return rv; 1182} 1183EXPORT_SYMBOL(usb_serial_resume); 1184 1185static const struct tty_operations serial_ops = { 1186 .open = serial_open, 1187 .close = serial_close, 1188 .write = serial_write, 1189 .hangup = serial_hangup, 1190 .write_room = serial_write_room, 1191 .ioctl = serial_ioctl, 1192 .set_termios = serial_set_termios, 1193 .throttle = serial_throttle, 1194 .unthrottle = serial_unthrottle, 1195 .break_ctl = serial_break, 1196 .chars_in_buffer = serial_chars_in_buffer, 1197 .tiocmget = serial_tiocmget, 1198 .tiocmset = serial_tiocmset, 1199 .cleanup = serial_cleanup, 1200 .install = serial_install, 1201 .proc_fops = &serial_proc_fops, 1202}; 1203 1204 1205struct tty_driver *usb_serial_tty_driver; 1206 1207static int __init usb_serial_init(void) 1208{ 1209 int i; 1210 int result; 1211 1212 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS); 1213 if (!usb_serial_tty_driver) 1214 return -ENOMEM; 1215 1216 /* Initialize our global data */ 1217 for (i = 0; i < SERIAL_TTY_MINORS; ++i) 1218 serial_table[i] = NULL; 1219 1220 result = bus_register(&usb_serial_bus_type); 1221 if (result) { 1222 printk(KERN_ERR "usb-serial: %s - registering bus driver " 1223 "failed\n", __func__); 1224 goto exit_bus; 1225 } 1226 1227 usb_serial_tty_driver->owner = THIS_MODULE; 1228 usb_serial_tty_driver->driver_name = "usbserial"; 1229 usb_serial_tty_driver->name = "ttyUSB"; 1230 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR; 1231 usb_serial_tty_driver->minor_start = 0; 1232 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1233 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1234 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | 1235 TTY_DRIVER_DYNAMIC_DEV; 1236 usb_serial_tty_driver->init_termios = tty_std_termios; 1237 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD 1238 | HUPCL | CLOCAL; 1239 usb_serial_tty_driver->init_termios.c_ispeed = 9600; 1240 usb_serial_tty_driver->init_termios.c_ospeed = 9600; 1241 tty_set_operations(usb_serial_tty_driver, &serial_ops); 1242 result = tty_register_driver(usb_serial_tty_driver); 1243 if (result) { 1244 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n", 1245 __func__); 1246 goto exit_reg_driver; 1247 } 1248 1249 /* register the USB driver */ 1250 result = usb_register(&usb_serial_driver); 1251 if (result < 0) { 1252 printk(KERN_ERR "usb-serial: %s - usb_register failed\n", 1253 __func__); 1254 goto exit_tty; 1255 } 1256 1257 /* register the generic driver, if we should */ 1258 result = usb_serial_generic_register(debug); 1259 if (result < 0) { 1260 printk(KERN_ERR "usb-serial: %s - registering generic " 1261 "driver failed\n", __func__); 1262 goto exit_generic; 1263 } 1264 1265 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1266 1267 return result; 1268 1269exit_generic: 1270 usb_deregister(&usb_serial_driver); 1271 1272exit_tty: 1273 tty_unregister_driver(usb_serial_tty_driver); 1274 1275exit_reg_driver: 1276 bus_unregister(&usb_serial_bus_type); 1277 1278exit_bus: 1279 printk(KERN_ERR "usb-serial: %s - returning with error %d\n", 1280 __func__, result); 1281 put_tty_driver(usb_serial_tty_driver); 1282 return result; 1283} 1284 1285 1286static void __exit usb_serial_exit(void) 1287{ 1288 usb_serial_console_exit(); 1289 1290 usb_serial_generic_deregister(); 1291 1292 usb_deregister(&usb_serial_driver); 1293 tty_unregister_driver(usb_serial_tty_driver); 1294 put_tty_driver(usb_serial_tty_driver); 1295 bus_unregister(&usb_serial_bus_type); 1296} 1297 1298 1299module_init(usb_serial_init); 1300module_exit(usb_serial_exit); 1301 1302#define set_to_generic_if_null(type, function) \ 1303 do { \ 1304 if (!type->function) { \ 1305 type->function = usb_serial_generic_##function; \ 1306 dbg("Had to override the " #function \ 1307 " usb serial operation with the generic one.");\ 1308 } \ 1309 } while (0) 1310 1311static void fixup_generic(struct usb_serial_driver *device) 1312{ 1313 set_to_generic_if_null(device, open); 1314 set_to_generic_if_null(device, write); 1315 set_to_generic_if_null(device, close); 1316 set_to_generic_if_null(device, write_room); 1317 set_to_generic_if_null(device, chars_in_buffer); 1318 set_to_generic_if_null(device, read_bulk_callback); 1319 set_to_generic_if_null(device, write_bulk_callback); 1320 set_to_generic_if_null(device, disconnect); 1321 set_to_generic_if_null(device, release); 1322 set_to_generic_if_null(device, process_read_urb); 1323 set_to_generic_if_null(device, prepare_write_buffer); 1324} 1325 1326int usb_serial_register(struct usb_serial_driver *driver) 1327{ 1328 /* must be called with BKL held */ 1329 int retval; 1330 1331 if (usb_disabled()) 1332 return -ENODEV; 1333 1334 fixup_generic(driver); 1335 1336 if (!driver->description) 1337 driver->description = driver->driver.name; 1338 if (!driver->usb_driver) { 1339 WARN(1, "Serial driver %s has no usb_driver\n", 1340 driver->description); 1341 return -EINVAL; 1342 } 1343 driver->usb_driver->supports_autosuspend = 1; 1344 1345 /* Add this device to our list of devices */ 1346 mutex_lock(&table_lock); 1347 list_add(&driver->driver_list, &usb_serial_driver_list); 1348 1349 retval = usb_serial_bus_register(driver); 1350 if (retval) { 1351 printk(KERN_ERR "usb-serial: problem %d when registering " 1352 "driver %s\n", retval, driver->description); 1353 list_del(&driver->driver_list); 1354 } else 1355 printk(KERN_INFO "USB Serial support registered for %s\n", 1356 driver->description); 1357 1358 mutex_unlock(&table_lock); 1359 return retval; 1360} 1361EXPORT_SYMBOL_GPL(usb_serial_register); 1362 1363 1364void usb_serial_deregister(struct usb_serial_driver *device) 1365{ 1366 /* must be called with BKL held */ 1367 printk(KERN_INFO "USB Serial deregistering driver %s\n", 1368 device->description); 1369 mutex_lock(&table_lock); 1370 list_del(&device->driver_list); 1371 usb_serial_bus_deregister(device); 1372 mutex_unlock(&table_lock); 1373} 1374EXPORT_SYMBOL_GPL(usb_serial_deregister); 1375 1376/* Module information */ 1377MODULE_AUTHOR(DRIVER_AUTHOR); 1378MODULE_DESCRIPTION(DRIVER_DESC); 1379MODULE_LICENSE("GPL"); 1380 1381module_param(debug, bool, S_IRUGO | S_IWUSR); 1382MODULE_PARM_DESC(debug, "Debug enabled or not"); 1383