drivers/usb/serial/usb-serial.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * USB Serial Converter driver
   4  *
   5  * Copyright (C) 2009 - 2013 Johan Hovold ([email protected])
   6  * Copyright (C) 1999 - 2012 Greg Kroah-Hartman ([email protected])
   7  * Copyright (C) 2000 Peter Berger ([email protected])
   8  * Copyright (C) 2000 Al Borchers ([email protected])
   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 <[email protected]>"
  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");