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