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 driver 16 * 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/errno.h> 21 #include <linux/init.h> 22 #include <linux/slab.h> 23 #include <linux/tty.h> 24 #include <linux/tty_driver.h> 25 #include <linux/tty_flip.h> 26 #include <linux/module.h> 27 #include <linux/moduleparam.h> 28 #include <linux/spinlock.h> 29 #include <linux/mutex.h> 30 #include <linux/list.h> 31 #include <linux/smp_lock.h> 32 #include <asm/uaccess.h> 33 #include <linux/usb.h> 34 #include <linux/usb/serial.h> 35 #include "pl2303.h" 36 37 /* 38 * Version Information 39 */ 40 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/" 41 #define DRIVER_DESC "USB Serial Driver core" 42 43 static void port_free(struct usb_serial_port *port); 44 45 /* Driver structure we register with the USB core */ 46 static struct usb_driver usb_serial_driver = { 47 .name = "usbserial", 48 .probe = usb_serial_probe, 49 .disconnect = usb_serial_disconnect, 50 .no_dynamic_id = 1, 51 }; 52 53 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead 54 the MODULE_DEVICE_TABLE declarations in each serial driver 55 cause the "hotplug" program to pull in whatever module is necessary 56 via modprobe, and modprobe will load usbserial because the serial 57 drivers depend on it. 58 */ 59 60 static int debug; 61 static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */ 62 static LIST_HEAD(usb_serial_driver_list); 63 64 struct usb_serial *usb_serial_get_by_index(unsigned index) 65 { 66 struct usb_serial *serial = serial_table[index]; 67 68 if (serial) 69 kref_get(&serial->kref); 70 return serial; 71 } 72 73 static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor) 74 { 75 unsigned int i, j; 76 int good_spot; 77 78 dbg("%s %d", __FUNCTION__, num_ports); 79 80 *minor = 0; 81 for (i = 0; i < SERIAL_TTY_MINORS; ++i) { 82 if (serial_table[i]) 83 continue; 84 85 good_spot = 1; 86 for (j = 1; j <= num_ports-1; ++j) 87 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) { 88 good_spot = 0; 89 i += j; 90 break; 91 } 92 if (good_spot == 0) 93 continue; 94 95 *minor = i; 96 dbg("%s - minor base = %d", __FUNCTION__, *minor); 97 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) 98 serial_table[i] = serial; 99 return serial; 100 } 101 return NULL; 102 } 103 104 static void return_serial(struct usb_serial *serial) 105 { 106 int i; 107 108 dbg("%s", __FUNCTION__); 109 110 if (serial == NULL) 111 return; 112 113 for (i = 0; i < serial->num_ports; ++i) { 114 serial_table[serial->minor + i] = NULL; 115 } 116 } 117 118 static void destroy_serial(struct kref *kref) 119 { 120 struct usb_serial *serial; 121 struct usb_serial_port *port; 122 int i; 123 124 serial = to_usb_serial(kref); 125 126 dbg("%s - %s", __FUNCTION__, serial->type->description); 127 128 serial->type->shutdown(serial); 129 130 /* return the minor range that this device had */ 131 return_serial(serial); 132 133 for (i = 0; i < serial->num_ports; ++i) 134 serial->port[i]->open_count = 0; 135 136 /* the ports are cleaned up and released in port_release() */ 137 for (i = 0; i < serial->num_ports; ++i) 138 if (serial->port[i]->dev.parent != NULL) { 139 device_unregister(&serial->port[i]->dev); 140 serial->port[i] = NULL; 141 } 142 143 /* If this is a "fake" port, we have to clean it up here, as it will 144 * not get cleaned up in port_release() as it was never registered with 145 * the driver core */ 146 if (serial->num_ports < serial->num_port_pointers) { 147 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) { 148 port = serial->port[i]; 149 if (!port) 150 continue; 151 port_free(port); 152 } 153 } 154 155 usb_put_dev(serial->dev); 156 157 /* free up any memory that we allocated */ 158 kfree (serial); 159 } 160 161 void usb_serial_put(struct usb_serial *serial) 162 { 163 kref_put(&serial->kref, destroy_serial); 164 } 165 166 /***************************************************************************** 167 * Driver tty interface functions 168 *****************************************************************************/ 169 static int serial_open (struct tty_struct *tty, struct file * filp) 170 { 171 struct usb_serial *serial; 172 struct usb_serial_port *port; 173 unsigned int portNumber; 174 int retval; 175 176 dbg("%s", __FUNCTION__); 177 178 /* get the serial object associated with this tty pointer */ 179 serial = usb_serial_get_by_index(tty->index); 180 if (!serial) { 181 tty->driver_data = NULL; 182 return -ENODEV; 183 } 184 185 portNumber = tty->index - serial->minor; 186 port = serial->port[portNumber]; 187 if (!port) { 188 retval = -ENODEV; 189 goto bailout_kref_put; 190 } 191 192 if (mutex_lock_interruptible(&port->mutex)) { 193 retval = -ERESTARTSYS; 194 goto bailout_kref_put; 195 } 196 197 ++port->open_count; 198 199 /* set up our port structure making the tty driver 200 * remember our port object, and us it */ 201 tty->driver_data = port; 202 port->tty = tty; 203 204 if (port->open_count == 1) { 205 206 /* lock this module before we call it 207 * this may fail, which means we must bail out, 208 * safe because we are called with BKL held */ 209 if (!try_module_get(serial->type->driver.owner)) { 210 retval = -ENODEV; 211 goto bailout_mutex_unlock; 212 } 213 214 /* only call the device specific open if this 215 * is the first time the port is opened */ 216 retval = serial->type->open(port, filp); 217 if (retval) 218 goto bailout_module_put; 219 } 220 221 mutex_unlock(&port->mutex); 222 return 0; 223 224 bailout_module_put: 225 module_put(serial->type->driver.owner); 226 bailout_mutex_unlock: 227 port->open_count = 0; 228 tty->driver_data = NULL; 229 port->tty = NULL; 230 mutex_unlock(&port->mutex); 231 bailout_kref_put: 232 usb_serial_put(serial); 233 return retval; 234 } 235 236 static void serial_close(struct tty_struct *tty, struct file * filp) 237 { 238 struct usb_serial_port *port = tty->driver_data; 239 240 if (!port) 241 return; 242 243 dbg("%s - port %d", __FUNCTION__, port->number); 244 245 mutex_lock(&port->mutex); 246 247 if (port->open_count == 0) { 248 mutex_unlock(&port->mutex); 249 return; 250 } 251 252 --port->open_count; 253 if (port->open_count == 0) { 254 /* only call the device specific close if this 255 * port is being closed by the last owner */ 256 port->serial->type->close(port, filp); 257 258 if (port->tty) { 259 if (port->tty->driver_data) 260 port->tty->driver_data = NULL; 261 port->tty = NULL; 262 } 263 264 module_put(port->serial->type->driver.owner); 265 } 266 267 mutex_unlock(&port->mutex); 268 usb_serial_put(port->serial); 269 } 270 271 static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count) 272 { 273 struct usb_serial_port *port = tty->driver_data; 274 int retval = -EINVAL; 275 276 if (!port || port->serial->dev->state == USB_STATE_NOTATTACHED) 277 goto exit; 278 279 dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count); 280 281 if (!port->open_count) { 282 dbg("%s - port not opened", __FUNCTION__); 283 goto exit; 284 } 285 286 /* pass on to the driver specific version of this function */ 287 retval = port->serial->type->write(port, buf, count); 288 289 exit: 290 return retval; 291 } 292 293 static int serial_write_room (struct tty_struct *tty) 294 { 295 struct usb_serial_port *port = tty->driver_data; 296 int retval = -ENODEV; 297 298 if (!port) 299 goto exit; 300 301 dbg("%s - port %d", __FUNCTION__, port->number); 302 303 if (!port->open_count) { 304 dbg("%s - port not open", __FUNCTION__); 305 goto exit; 306 } 307 308 /* pass on to the driver specific version of this function */ 309 retval = port->serial->type->write_room(port); 310 311 exit: 312 return retval; 313 } 314 315 static int serial_chars_in_buffer (struct tty_struct *tty) 316 { 317 struct usb_serial_port *port = tty->driver_data; 318 int retval = -ENODEV; 319 320 if (!port) 321 goto exit; 322 323 dbg("%s = port %d", __FUNCTION__, port->number); 324 325 if (!port->open_count) { 326 dbg("%s - port not open", __FUNCTION__); 327 goto exit; 328 } 329 330 /* pass on to the driver specific version of this function */ 331 retval = port->serial->type->chars_in_buffer(port); 332 333 exit: 334 return retval; 335 } 336 337 static void serial_throttle (struct tty_struct * tty) 338 { 339 struct usb_serial_port *port = tty->driver_data; 340 341 if (!port) 342 return; 343 344 dbg("%s - port %d", __FUNCTION__, port->number); 345 346 if (!port->open_count) { 347 dbg ("%s - port not open", __FUNCTION__); 348 return; 349 } 350 351 /* pass on to the driver specific version of this function */ 352 if (port->serial->type->throttle) 353 port->serial->type->throttle(port); 354 } 355 356 static void serial_unthrottle (struct tty_struct * tty) 357 { 358 struct usb_serial_port *port = tty->driver_data; 359 360 if (!port) 361 return; 362 363 dbg("%s - port %d", __FUNCTION__, port->number); 364 365 if (!port->open_count) { 366 dbg("%s - port not open", __FUNCTION__); 367 return; 368 } 369 370 /* pass on to the driver specific version of this function */ 371 if (port->serial->type->unthrottle) 372 port->serial->type->unthrottle(port); 373 } 374 375 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg) 376 { 377 struct usb_serial_port *port = tty->driver_data; 378 int retval = -ENODEV; 379 380 if (!port) 381 goto exit; 382 383 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd); 384 385 if (!port->open_count) { 386 dbg ("%s - port not open", __FUNCTION__); 387 goto exit; 388 } 389 390 /* pass on to the driver specific version of this function if it is available */ 391 if (port->serial->type->ioctl) 392 retval = port->serial->type->ioctl(port, file, cmd, arg); 393 else 394 retval = -ENOIOCTLCMD; 395 396 exit: 397 return retval; 398 } 399 400 static void serial_set_termios (struct tty_struct *tty, struct termios * old) 401 { 402 struct usb_serial_port *port = tty->driver_data; 403 404 if (!port) 405 return; 406 407 dbg("%s - port %d", __FUNCTION__, port->number); 408 409 if (!port->open_count) { 410 dbg("%s - port not open", __FUNCTION__); 411 return; 412 } 413 414 /* pass on to the driver specific version of this function if it is available */ 415 if (port->serial->type->set_termios) 416 port->serial->type->set_termios(port, old); 417 } 418 419 static void serial_break (struct tty_struct *tty, int break_state) 420 { 421 struct usb_serial_port *port = tty->driver_data; 422 423 if (!port) 424 return; 425 426 dbg("%s - port %d", __FUNCTION__, port->number); 427 428 if (!port->open_count) { 429 dbg("%s - port not open", __FUNCTION__); 430 return; 431 } 432 433 /* pass on to the driver specific version of this function if it is available */ 434 if (port->serial->type->break_ctl) 435 port->serial->type->break_ctl(port, break_state); 436 } 437 438 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data) 439 { 440 struct usb_serial *serial; 441 int length = 0; 442 int i; 443 off_t begin = 0; 444 char tmp[40]; 445 446 dbg("%s", __FUNCTION__); 447 length += sprintf (page, "usbserinfo:1.0 driver:2.0\n"); 448 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) { 449 serial = usb_serial_get_by_index(i); 450 if (serial == NULL) 451 continue; 452 453 length += sprintf (page+length, "%d:", i); 454 if (serial->type->driver.owner) 455 length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner)); 456 length += sprintf (page+length, " name:\"%s\"", serial->type->description); 457 length += sprintf (page+length, " vendor:%04x product:%04x", 458 le16_to_cpu(serial->dev->descriptor.idVendor), 459 le16_to_cpu(serial->dev->descriptor.idProduct)); 460 length += sprintf (page+length, " num_ports:%d", serial->num_ports); 461 length += sprintf (page+length, " port:%d", i - serial->minor + 1); 462 463 usb_make_path(serial->dev, tmp, sizeof(tmp)); 464 length += sprintf (page+length, " path:%s", tmp); 465 466 length += sprintf (page+length, "\n"); 467 if ((length + begin) > (off + count)) { 468 usb_serial_put(serial); 469 goto done; 470 } 471 if ((length + begin) < off) { 472 begin += length; 473 length = 0; 474 } 475 usb_serial_put(serial); 476 } 477 *eof = 1; 478 done: 479 if (off >= (length + begin)) 480 return 0; 481 *start = page + (off-begin); 482 return ((count < begin+length-off) ? count : begin+length-off); 483 } 484 485 static int serial_tiocmget (struct tty_struct *tty, struct file *file) 486 { 487 struct usb_serial_port *port = tty->driver_data; 488 489 if (!port) 490 return -ENODEV; 491 492 dbg("%s - port %d", __FUNCTION__, port->number); 493 494 if (!port->open_count) { 495 dbg("%s - port not open", __FUNCTION__); 496 return -ENODEV; 497 } 498 499 if (port->serial->type->tiocmget) 500 return port->serial->type->tiocmget(port, file); 501 502 return -EINVAL; 503 } 504 505 static int serial_tiocmset (struct tty_struct *tty, struct file *file, 506 unsigned int set, unsigned int clear) 507 { 508 struct usb_serial_port *port = tty->driver_data; 509 510 if (!port) 511 return -ENODEV; 512 513 dbg("%s - port %d", __FUNCTION__, port->number); 514 515 if (!port->open_count) { 516 dbg("%s - port not open", __FUNCTION__); 517 return -ENODEV; 518 } 519 520 if (port->serial->type->tiocmset) 521 return port->serial->type->tiocmset(port, file, set, clear); 522 523 return -EINVAL; 524 } 525 526 /* 527 * We would be calling tty_wakeup here, but unfortunately some line 528 * disciplines have an annoying habit of calling tty->write from 529 * the write wakeup callback (e.g. n_hdlc.c). 530 */ 531 void usb_serial_port_softint(struct usb_serial_port *port) 532 { 533 schedule_work(&port->work); 534 } 535 536 static void usb_serial_port_work(void *private) 537 { 538 struct usb_serial_port *port = private; 539 struct tty_struct *tty; 540 541 dbg("%s - port %d", __FUNCTION__, port->number); 542 543 if (!port) 544 return; 545 546 tty = port->tty; 547 if (!tty) 548 return; 549 550 tty_wakeup(tty); 551 } 552 553 static void port_release(struct device *dev) 554 { 555 struct usb_serial_port *port = to_usb_serial_port(dev); 556 557 dbg ("%s - %s", __FUNCTION__, dev->bus_id); 558 port_free(port); 559 } 560 561 static void port_free(struct usb_serial_port *port) 562 { 563 usb_kill_urb(port->read_urb); 564 usb_free_urb(port->read_urb); 565 usb_kill_urb(port->write_urb); 566 usb_free_urb(port->write_urb); 567 usb_kill_urb(port->interrupt_in_urb); 568 usb_free_urb(port->interrupt_in_urb); 569 usb_kill_urb(port->interrupt_out_urb); 570 usb_free_urb(port->interrupt_out_urb); 571 kfree(port->bulk_in_buffer); 572 kfree(port->bulk_out_buffer); 573 kfree(port->interrupt_in_buffer); 574 kfree(port->interrupt_out_buffer); 575 flush_scheduled_work(); /* port->work */ 576 kfree(port); 577 } 578 579 static struct usb_serial * create_serial (struct usb_device *dev, 580 struct usb_interface *interface, 581 struct usb_serial_driver *driver) 582 { 583 struct usb_serial *serial; 584 585 serial = kzalloc(sizeof(*serial), GFP_KERNEL); 586 if (!serial) { 587 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__); 588 return NULL; 589 } 590 serial->dev = usb_get_dev(dev); 591 serial->type = driver; 592 serial->interface = interface; 593 kref_init(&serial->kref); 594 595 return serial; 596 } 597 598 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface) 599 { 600 struct list_head *p; 601 const struct usb_device_id *id; 602 struct usb_serial_driver *t; 603 604 /* Check if the usb id matches a known device */ 605 list_for_each(p, &usb_serial_driver_list) { 606 t = list_entry(p, struct usb_serial_driver, driver_list); 607 id = usb_match_id(iface, t->id_table); 608 if (id != NULL) { 609 dbg("descriptor matches"); 610 return t; 611 } 612 } 613 614 return NULL; 615 } 616 617 int usb_serial_probe(struct usb_interface *interface, 618 const struct usb_device_id *id) 619 { 620 struct usb_device *dev = interface_to_usbdev (interface); 621 struct usb_serial *serial = NULL; 622 struct usb_serial_port *port; 623 struct usb_host_interface *iface_desc; 624 struct usb_endpoint_descriptor *endpoint; 625 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS]; 626 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS]; 627 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS]; 628 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS]; 629 struct usb_serial_driver *type = NULL; 630 int retval; 631 int minor; 632 int buffer_size; 633 int i; 634 int num_interrupt_in = 0; 635 int num_interrupt_out = 0; 636 int num_bulk_in = 0; 637 int num_bulk_out = 0; 638 int num_ports = 0; 639 int max_endpoints; 640 641 type = search_serial_device(interface); 642 if (!type) { 643 dbg("none matched"); 644 return -ENODEV; 645 } 646 647 serial = create_serial (dev, interface, type); 648 if (!serial) { 649 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__); 650 return -ENOMEM; 651 } 652 653 /* if this device type has a probe function, call it */ 654 if (type->probe) { 655 const struct usb_device_id *id; 656 657 if (!try_module_get(type->driver.owner)) { 658 dev_err(&interface->dev, "module get failed, exiting\n"); 659 kfree (serial); 660 return -EIO; 661 } 662 663 id = usb_match_id(interface, type->id_table); 664 retval = type->probe(serial, id); 665 module_put(type->driver.owner); 666 667 if (retval) { 668 dbg ("sub driver rejected device"); 669 kfree (serial); 670 return retval; 671 } 672 } 673 674 /* descriptor matches, let's find the endpoints needed */ 675 /* check out the endpoints */ 676 iface_desc = interface->cur_altsetting; 677 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 678 endpoint = &iface_desc->endpoint[i].desc; 679 680 if ((endpoint->bEndpointAddress & 0x80) && 681 ((endpoint->bmAttributes & 3) == 0x02)) { 682 /* we found a bulk in endpoint */ 683 dbg("found bulk in on endpoint %d", i); 684 bulk_in_endpoint[num_bulk_in] = endpoint; 685 ++num_bulk_in; 686 } 687 688 if (((endpoint->bEndpointAddress & 0x80) == 0x00) && 689 ((endpoint->bmAttributes & 3) == 0x02)) { 690 /* we found a bulk out endpoint */ 691 dbg("found bulk out on endpoint %d", i); 692 bulk_out_endpoint[num_bulk_out] = endpoint; 693 ++num_bulk_out; 694 } 695 696 if ((endpoint->bEndpointAddress & 0x80) && 697 ((endpoint->bmAttributes & 3) == 0x03)) { 698 /* we found a interrupt in endpoint */ 699 dbg("found interrupt in on endpoint %d", i); 700 interrupt_in_endpoint[num_interrupt_in] = endpoint; 701 ++num_interrupt_in; 702 } 703 704 if (((endpoint->bEndpointAddress & 0x80) == 0x00) && 705 ((endpoint->bmAttributes & 3) == 0x03)) { 706 /* we found an interrupt out endpoint */ 707 dbg("found interrupt out on endpoint %d", i); 708 interrupt_out_endpoint[num_interrupt_out] = endpoint; 709 ++num_interrupt_out; 710 } 711 } 712 713 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE) 714 /* BEGIN HORRIBLE HACK FOR PL2303 */ 715 /* this is needed due to the looney way its endpoints are set up */ 716 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) && 717 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) || 718 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) && 719 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID))) { 720 if (interface != dev->actconfig->interface[0]) { 721 /* check out the endpoints of the other interface*/ 722 iface_desc = dev->actconfig->interface[0]->cur_altsetting; 723 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 724 endpoint = &iface_desc->endpoint[i].desc; 725 if ((endpoint->bEndpointAddress & 0x80) && 726 ((endpoint->bmAttributes & 3) == 0x03)) { 727 /* we found a interrupt in endpoint */ 728 dbg("found interrupt in for Prolific device on separate interface"); 729 interrupt_in_endpoint[num_interrupt_in] = endpoint; 730 ++num_interrupt_in; 731 } 732 } 733 } 734 735 /* Now make sure the PL-2303 is configured correctly. 736 * If not, give up now and hope this hack will work 737 * properly during a later invocation of usb_serial_probe 738 */ 739 if (num_bulk_in == 0 || num_bulk_out == 0) { 740 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n"); 741 kfree (serial); 742 return -ENODEV; 743 } 744 } 745 /* END HORRIBLE HACK FOR PL2303 */ 746 #endif 747 748 /* found all that we need */ 749 dev_info(&interface->dev, "%s converter detected\n", type->description); 750 751 #ifdef CONFIG_USB_SERIAL_GENERIC 752 if (type == &usb_serial_generic_device) { 753 num_ports = num_bulk_out; 754 if (num_ports == 0) { 755 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n"); 756 kfree (serial); 757 return -EIO; 758 } 759 } 760 #endif 761 if (!num_ports) { 762 /* if this device type has a calc_num_ports function, call it */ 763 if (type->calc_num_ports) { 764 if (!try_module_get(type->driver.owner)) { 765 dev_err(&interface->dev, "module get failed, exiting\n"); 766 kfree (serial); 767 return -EIO; 768 } 769 num_ports = type->calc_num_ports (serial); 770 module_put(type->driver.owner); 771 } 772 if (!num_ports) 773 num_ports = type->num_ports; 774 } 775 776 if (get_free_serial (serial, num_ports, &minor) == NULL) { 777 dev_err(&interface->dev, "No more free serial devices\n"); 778 kfree (serial); 779 return -ENOMEM; 780 } 781 782 serial->minor = minor; 783 serial->num_ports = num_ports; 784 serial->num_bulk_in = num_bulk_in; 785 serial->num_bulk_out = num_bulk_out; 786 serial->num_interrupt_in = num_interrupt_in; 787 serial->num_interrupt_out = num_interrupt_out; 788 789 /* create our ports, we need as many as the max endpoints */ 790 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */ 791 max_endpoints = max(num_bulk_in, num_bulk_out); 792 max_endpoints = max(max_endpoints, num_interrupt_in); 793 max_endpoints = max(max_endpoints, num_interrupt_out); 794 max_endpoints = max(max_endpoints, (int)serial->num_ports); 795 serial->num_port_pointers = max_endpoints; 796 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints); 797 for (i = 0; i < max_endpoints; ++i) { 798 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL); 799 if (!port) 800 goto probe_error; 801 port->number = i + serial->minor; 802 port->serial = serial; 803 spin_lock_init(&port->lock); 804 mutex_init(&port->mutex); 805 INIT_WORK(&port->work, usb_serial_port_work, port); 806 serial->port[i] = port; 807 } 808 809 /* set up the endpoint information */ 810 for (i = 0; i < num_bulk_in; ++i) { 811 endpoint = bulk_in_endpoint[i]; 812 port = serial->port[i]; 813 port->read_urb = usb_alloc_urb (0, GFP_KERNEL); 814 if (!port->read_urb) { 815 dev_err(&interface->dev, "No free urbs available\n"); 816 goto probe_error; 817 } 818 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 819 port->bulk_in_size = buffer_size; 820 port->bulk_in_endpointAddress = endpoint->bEndpointAddress; 821 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL); 822 if (!port->bulk_in_buffer) { 823 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n"); 824 goto probe_error; 825 } 826 usb_fill_bulk_urb (port->read_urb, dev, 827 usb_rcvbulkpipe (dev, 828 endpoint->bEndpointAddress), 829 port->bulk_in_buffer, buffer_size, 830 serial->type->read_bulk_callback, 831 port); 832 } 833 834 for (i = 0; i < num_bulk_out; ++i) { 835 endpoint = bulk_out_endpoint[i]; 836 port = serial->port[i]; 837 port->write_urb = usb_alloc_urb(0, GFP_KERNEL); 838 if (!port->write_urb) { 839 dev_err(&interface->dev, "No free urbs available\n"); 840 goto probe_error; 841 } 842 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 843 port->bulk_out_size = buffer_size; 844 port->bulk_out_endpointAddress = endpoint->bEndpointAddress; 845 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL); 846 if (!port->bulk_out_buffer) { 847 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n"); 848 goto probe_error; 849 } 850 usb_fill_bulk_urb (port->write_urb, dev, 851 usb_sndbulkpipe (dev, 852 endpoint->bEndpointAddress), 853 port->bulk_out_buffer, buffer_size, 854 serial->type->write_bulk_callback, 855 port); 856 } 857 858 if (serial->type->read_int_callback) { 859 for (i = 0; i < num_interrupt_in; ++i) { 860 endpoint = interrupt_in_endpoint[i]; 861 port = serial->port[i]; 862 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); 863 if (!port->interrupt_in_urb) { 864 dev_err(&interface->dev, "No free urbs available\n"); 865 goto probe_error; 866 } 867 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 868 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress; 869 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL); 870 if (!port->interrupt_in_buffer) { 871 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n"); 872 goto probe_error; 873 } 874 usb_fill_int_urb (port->interrupt_in_urb, dev, 875 usb_rcvintpipe (dev, 876 endpoint->bEndpointAddress), 877 port->interrupt_in_buffer, buffer_size, 878 serial->type->read_int_callback, port, 879 endpoint->bInterval); 880 } 881 } else if (num_interrupt_in) { 882 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined"); 883 } 884 885 if (serial->type->write_int_callback) { 886 for (i = 0; i < num_interrupt_out; ++i) { 887 endpoint = interrupt_out_endpoint[i]; 888 port = serial->port[i]; 889 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); 890 if (!port->interrupt_out_urb) { 891 dev_err(&interface->dev, "No free urbs available\n"); 892 goto probe_error; 893 } 894 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize); 895 port->interrupt_out_size = buffer_size; 896 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress; 897 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL); 898 if (!port->interrupt_out_buffer) { 899 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n"); 900 goto probe_error; 901 } 902 usb_fill_int_urb (port->interrupt_out_urb, dev, 903 usb_sndintpipe (dev, 904 endpoint->bEndpointAddress), 905 port->interrupt_out_buffer, buffer_size, 906 serial->type->write_int_callback, port, 907 endpoint->bInterval); 908 } 909 } else if (num_interrupt_out) { 910 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined"); 911 } 912 913 /* if this device type has an attach function, call it */ 914 if (type->attach) { 915 if (!try_module_get(type->driver.owner)) { 916 dev_err(&interface->dev, "module get failed, exiting\n"); 917 goto probe_error; 918 } 919 retval = type->attach (serial); 920 module_put(type->driver.owner); 921 if (retval < 0) 922 goto probe_error; 923 if (retval > 0) { 924 /* quietly accept this device, but don't bind to a serial port 925 * as it's about to disappear */ 926 goto exit; 927 } 928 } 929 930 /* register all of the individual ports with the driver core */ 931 for (i = 0; i < num_ports; ++i) { 932 port = serial->port[i]; 933 port->dev.parent = &interface->dev; 934 port->dev.driver = NULL; 935 port->dev.bus = &usb_serial_bus_type; 936 port->dev.release = &port_release; 937 938 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number); 939 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id); 940 device_register (&port->dev); 941 } 942 943 usb_serial_console_init (debug, minor); 944 945 exit: 946 /* success */ 947 usb_set_intfdata (interface, serial); 948 return 0; 949 950 probe_error: 951 for (i = 0; i < num_bulk_in; ++i) { 952 port = serial->port[i]; 953 if (!port) 954 continue; 955 if (port->read_urb) 956 usb_free_urb (port->read_urb); 957 kfree(port->bulk_in_buffer); 958 } 959 for (i = 0; i < num_bulk_out; ++i) { 960 port = serial->port[i]; 961 if (!port) 962 continue; 963 if (port->write_urb) 964 usb_free_urb (port->write_urb); 965 kfree(port->bulk_out_buffer); 966 } 967 for (i = 0; i < num_interrupt_in; ++i) { 968 port = serial->port[i]; 969 if (!port) 970 continue; 971 if (port->interrupt_in_urb) 972 usb_free_urb (port->interrupt_in_urb); 973 kfree(port->interrupt_in_buffer); 974 } 975 for (i = 0; i < num_interrupt_out; ++i) { 976 port = serial->port[i]; 977 if (!port) 978 continue; 979 if (port->interrupt_out_urb) 980 usb_free_urb (port->interrupt_out_urb); 981 kfree(port->interrupt_out_buffer); 982 } 983 984 /* return the minor range that this device had */ 985 return_serial (serial); 986 987 /* free up any memory that we allocated */ 988 for (i = 0; i < serial->num_port_pointers; ++i) 989 kfree(serial->port[i]); 990 kfree (serial); 991 return -EIO; 992 } 993 994 void usb_serial_disconnect(struct usb_interface *interface) 995 { 996 int i; 997 struct usb_serial *serial = usb_get_intfdata (interface); 998 struct device *dev = &interface->dev; 999 struct usb_serial_port *port; 1000 1001 usb_serial_console_disconnect(serial); 1002 dbg ("%s", __FUNCTION__); 1003 1004 usb_set_intfdata (interface, NULL); 1005 if (serial) { 1006 for (i = 0; i < serial->num_ports; ++i) { 1007 port = serial->port[i]; 1008 if (port && port->tty) 1009 tty_hangup(port->tty); 1010 } 1011 /* let the last holder of this object 1012 * cause it to be cleaned up */ 1013 usb_serial_put(serial); 1014 } 1015 dev_info(dev, "device disconnected\n"); 1016 } 1017 1018 static struct tty_operations serial_ops = { 1019 .open = serial_open, 1020 .close = serial_close, 1021 .write = serial_write, 1022 .write_room = serial_write_room, 1023 .ioctl = serial_ioctl, 1024 .set_termios = serial_set_termios, 1025 .throttle = serial_throttle, 1026 .unthrottle = serial_unthrottle, 1027 .break_ctl = serial_break, 1028 .chars_in_buffer = serial_chars_in_buffer, 1029 .read_proc = serial_read_proc, 1030 .tiocmget = serial_tiocmget, 1031 .tiocmset = serial_tiocmset, 1032 }; 1033 1034 struct tty_driver *usb_serial_tty_driver; 1035 1036 static int __init usb_serial_init(void) 1037 { 1038 int i; 1039 int result; 1040 1041 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS); 1042 if (!usb_serial_tty_driver) 1043 return -ENOMEM; 1044 1045 /* Initialize our global data */ 1046 for (i = 0; i < SERIAL_TTY_MINORS; ++i) { 1047 serial_table[i] = NULL; 1048 } 1049 1050 result = bus_register(&usb_serial_bus_type); 1051 if (result) { 1052 err("%s - registering bus driver failed", __FUNCTION__); 1053 goto exit_bus; 1054 } 1055 1056 usb_serial_tty_driver->owner = THIS_MODULE; 1057 usb_serial_tty_driver->driver_name = "usbserial"; 1058 usb_serial_tty_driver->name = "ttyUSB"; 1059 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR; 1060 usb_serial_tty_driver->minor_start = 0; 1061 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1062 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL; 1063 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1064 usb_serial_tty_driver->init_termios = tty_std_termios; 1065 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL; 1066 tty_set_operations(usb_serial_tty_driver, &serial_ops); 1067 result = tty_register_driver(usb_serial_tty_driver); 1068 if (result) { 1069 err("%s - tty_register_driver failed", __FUNCTION__); 1070 goto exit_reg_driver; 1071 } 1072 1073 /* register the USB driver */ 1074 result = usb_register(&usb_serial_driver); 1075 if (result < 0) { 1076 err("%s - usb_register failed", __FUNCTION__); 1077 goto exit_tty; 1078 } 1079 1080 /* register the generic driver, if we should */ 1081 result = usb_serial_generic_register(debug); 1082 if (result < 0) { 1083 err("%s - registering generic driver failed", __FUNCTION__); 1084 goto exit_generic; 1085 } 1086 1087 info(DRIVER_DESC); 1088 1089 return result; 1090 1091 exit_generic: 1092 usb_deregister(&usb_serial_driver); 1093 1094 exit_tty: 1095 tty_unregister_driver(usb_serial_tty_driver); 1096 1097 exit_reg_driver: 1098 bus_unregister(&usb_serial_bus_type); 1099 1100 exit_bus: 1101 err ("%s - returning with error %d", __FUNCTION__, result); 1102 put_tty_driver(usb_serial_tty_driver); 1103 return result; 1104 } 1105 1106 1107 static void __exit usb_serial_exit(void) 1108 { 1109 usb_serial_console_exit(); 1110 1111 usb_serial_generic_deregister(); 1112 1113 usb_deregister(&usb_serial_driver); 1114 tty_unregister_driver(usb_serial_tty_driver); 1115 put_tty_driver(usb_serial_tty_driver); 1116 bus_unregister(&usb_serial_bus_type); 1117 } 1118 1119 1120 module_init(usb_serial_init); 1121 module_exit(usb_serial_exit); 1122 1123 #define set_to_generic_if_null(type, function) \ 1124 do { \ 1125 if (!type->function) { \ 1126 type->function = usb_serial_generic_##function; \ 1127 dbg("Had to override the " #function \ 1128 " usb serial operation with the generic one.");\ 1129 } \ 1130 } while (0) 1131 1132 static void fixup_generic(struct usb_serial_driver *device) 1133 { 1134 set_to_generic_if_null(device, open); 1135 set_to_generic_if_null(device, write); 1136 set_to_generic_if_null(device, close); 1137 set_to_generic_if_null(device, write_room); 1138 set_to_generic_if_null(device, chars_in_buffer); 1139 set_to_generic_if_null(device, read_bulk_callback); 1140 set_to_generic_if_null(device, write_bulk_callback); 1141 set_to_generic_if_null(device, shutdown); 1142 } 1143 1144 int usb_serial_register(struct usb_serial_driver *driver) 1145 { 1146 int retval; 1147 1148 fixup_generic(driver); 1149 1150 if (!driver->description) 1151 driver->description = driver->driver.name; 1152 1153 /* Add this device to our list of devices */ 1154 list_add(&driver->driver_list, &usb_serial_driver_list); 1155 1156 retval = usb_serial_bus_register(driver); 1157 if (retval) { 1158 err("problem %d when registering driver %s", retval, driver->description); 1159 list_del(&driver->driver_list); 1160 } 1161 else 1162 info("USB Serial support registered for %s", driver->description); 1163 1164 return retval; 1165 } 1166 1167 1168 void usb_serial_deregister(struct usb_serial_driver *device) 1169 { 1170 info("USB Serial deregistering driver %s", device->description); 1171 list_del(&device->driver_list); 1172 usb_serial_bus_deregister(device); 1173 } 1174 1175 1176 1177 /* If the usb-serial core is built into the core, the usb-serial drivers 1178 need these symbols to load properly as modules. */ 1179 EXPORT_SYMBOL_GPL(usb_serial_register); 1180 EXPORT_SYMBOL_GPL(usb_serial_deregister); 1181 EXPORT_SYMBOL_GPL(usb_serial_probe); 1182 EXPORT_SYMBOL_GPL(usb_serial_disconnect); 1183 EXPORT_SYMBOL_GPL(usb_serial_port_softint); 1184 1185 1186 /* Module information */ 1187 MODULE_AUTHOR( DRIVER_AUTHOR ); 1188 MODULE_DESCRIPTION( DRIVER_DESC ); 1189 MODULE_LICENSE("GPL"); 1190 1191 module_param(debug, bool, S_IRUGO | S_IWUSR); 1192 MODULE_PARM_DESC(debug, "Debug enabled or not"); 1193