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_port_install(&port->port, 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_proc_open(struct inode *inode, struct file *file)
 480 {
 481         return single_open(file, serial_proc_show, NULL);
 482 }
 483
 484 static const struct file_operations serial_proc_fops = {
 485         .owner          = THIS_MODULE,
 486         .open           = serial_proc_open,
 487         .read           = seq_read,
 488         .llseek         = seq_lseek,
 489         .release        = single_release,
 490 };
 491
 492 static int serial_tiocmget(struct tty_struct *tty)
 493 {
 494         struct usb_serial_port *port = tty->driver_data;
 495
 496         dev_dbg(tty->dev, "%s\n", __func__);
 497
 498         if (port->serial->type->tiocmget)
 499                 return port->serial->type->tiocmget(tty);
 500         return -EINVAL;
 501 }
 502
 503 static int serial_tiocmset(struct tty_struct *tty,
 504                             unsigned int set, unsigned int clear)
 505 {
 506         struct usb_serial_port *port = tty->driver_data;
 507
 508         dev_dbg(tty->dev, "%s\n", __func__);
 509
 510         if (port->serial->type->tiocmset)
 511                 return port->serial->type->tiocmset(tty, set, clear);
 512         return -EINVAL;
 513 }
 514
 515 static int serial_get_icount(struct tty_struct *tty,
 516                                 struct serial_icounter_struct *icount)
 517 {
 518         struct usb_serial_port *port = tty->driver_data;
 519
 520         dev_dbg(tty->dev, "%s\n", __func__);
 521
 522         if (port->serial->type->get_icount)
 523                 return port->serial->type->get_icount(tty, icount);
 524         return -EINVAL;
 525 }
 526
 527 /*
 528  * We would be calling tty_wakeup here, but unfortunately some line
 529  * disciplines have an annoying habit of calling tty->write from
 530  * the write wakeup callback (e.g. n_hdlc.c).
 531  */
 532 void usb_serial_port_softint(struct usb_serial_port *port)
 533 {
 534         schedule_work(&port->work);
 535 }
 536 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 537
 538 static void usb_serial_port_work(struct work_struct *work)
 539 {
 540         struct usb_serial_port *port =
 541                 container_of(work, struct usb_serial_port, work);
 542
 543         tty_port_tty_wakeup(&port->port);
 544 }
 545
 546 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
 547 {
 548         int i;
 549
 550         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 551                 usb_poison_urb(port->read_urbs[i]);
 552         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 553                 usb_poison_urb(port->write_urbs[i]);
 554
 555         usb_poison_urb(port->interrupt_in_urb);
 556         usb_poison_urb(port->interrupt_out_urb);
 557 }
 558
 559 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
 560 {
 561         int i;
 562
 563         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 564                 usb_unpoison_urb(port->read_urbs[i]);
 565         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 566                 usb_unpoison_urb(port->write_urbs[i]);
 567
 568         usb_unpoison_urb(port->interrupt_in_urb);
 569         usb_unpoison_urb(port->interrupt_out_urb);
 570 }
 571
 572 static void usb_serial_port_release(struct device *dev)
 573 {
 574         struct usb_serial_port *port = to_usb_serial_port(dev);
 575         int i;
 576
 577         dev_dbg(dev, "%s\n", __func__);
 578
 579         usb_free_urb(port->interrupt_in_urb);
 580         usb_free_urb(port->interrupt_out_urb);
 581         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 582                 usb_free_urb(port->read_urbs[i]);
 583                 kfree(port->bulk_in_buffers[i]);
 584         }
 585         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 586                 usb_free_urb(port->write_urbs[i]);
 587                 kfree(port->bulk_out_buffers[i]);
 588         }
 589         kfifo_free(&port->write_fifo);
 590         kfree(port->interrupt_in_buffer);
 591         kfree(port->interrupt_out_buffer);
 592         tty_port_destroy(&port->port);
 593         kfree(port);
 594 }
 595
 596 static struct usb_serial *create_serial(struct usb_device *dev,
 597                                         struct usb_interface *interface,
 598                                         struct usb_serial_driver *driver)
 599 {
 600         struct usb_serial *serial;
 601
 602         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 603         if (!serial)
 604                 return NULL;
 605         serial->dev = usb_get_dev(dev);
 606         serial->type = driver;
 607         serial->interface = usb_get_intf(interface);
 608         kref_init(&serial->kref);
 609         mutex_init(&serial->disc_mutex);
 610         serial->minors_reserved = 0;
 611
 612         return serial;
 613 }
 614
 615 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 616                                             struct usb_serial_driver *drv)
 617 {
 618         struct usb_dynid *dynid;
 619
 620         spin_lock(&drv->dynids.lock);
 621         list_for_each_entry(dynid, &drv->dynids.list, node) {
 622                 if (usb_match_one_id(intf, &dynid->id)) {
 623                         spin_unlock(&drv->dynids.lock);
 624                         return &dynid->id;
 625                 }
 626         }
 627         spin_unlock(&drv->dynids.lock);
 628         return NULL;
 629 }
 630
 631 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 632                                                 struct usb_interface *intf)
 633 {
 634         const struct usb_device_id *id;
 635
 636         id = usb_match_id(intf, drv->id_table);
 637         if (id) {
 638                 dev_dbg(&intf->dev, "static descriptor matches\n");
 639                 goto exit;
 640         }
 641         id = match_dynamic_id(intf, drv);
 642         if (id)
 643                 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
 644 exit:
 645         return id;
 646 }
 647
 648 /* Caller must hold table_lock */
 649 static struct usb_serial_driver *search_serial_device(
 650                                         struct usb_interface *iface)
 651 {
 652         const struct usb_device_id *id = NULL;
 653         struct usb_serial_driver *drv;
 654         struct usb_driver *driver = to_usb_driver(iface->dev.driver);
 655
 656         /* Check if the usb id matches a known device */
 657         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 658                 if (drv->usb_driver == driver)
 659                         id = get_iface_id(drv, iface);
 660                 if (id)
 661                         return drv;
 662         }
 663
 664         return NULL;
 665 }
 666
 667 static int serial_port_carrier_raised(struct tty_port *port)
 668 {
 669         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 670         struct usb_serial_driver *drv = p->serial->type;
 671
 672         if (drv->carrier_raised)
 673                 return drv->carrier_raised(p);
 674         /* No carrier control - don't block */
 675         return 1;
 676 }
 677
 678 static void serial_port_dtr_rts(struct tty_port *port, int on)
 679 {
 680         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 681         struct usb_serial_driver *drv = p->serial->type;
 682
 683         if (drv->dtr_rts)
 684                 drv->dtr_rts(p, on);
 685 }
 686
 687 static ssize_t port_number_show(struct device *dev,
 688                                 struct device_attribute *attr, char *buf)
 689 {
 690         struct usb_serial_port *port = to_usb_serial_port(dev);
 691
 692         return sprintf(buf, "%u\n", port->port_number);
 693 }
 694 static DEVICE_ATTR_RO(port_number);
 695
 696 static struct attribute *usb_serial_port_attrs[] = {
 697         &dev_attr_port_number.attr,
 698         NULL
 699 };
 700 ATTRIBUTE_GROUPS(usb_serial_port);
 701
 702 static const struct tty_port_operations serial_port_ops = {
 703         .carrier_raised         = serial_port_carrier_raised,
 704         .dtr_rts                = serial_port_dtr_rts,
 705         .activate               = serial_port_activate,
 706         .shutdown               = serial_port_shutdown,
 707 };
 708
 709 static void find_endpoints(struct usb_serial *serial,
 710                                         struct usb_serial_endpoints *epds)
 711 {
 712         struct device *dev = &serial->interface->dev;
 713         struct usb_host_interface *iface_desc;
 714         struct usb_endpoint_descriptor *epd;
 715         unsigned int i;
 716
 717         BUILD_BUG_ON(ARRAY_SIZE(epds->bulk_in) < USB_MAXENDPOINTS / 2);
 718         BUILD_BUG_ON(ARRAY_SIZE(epds->bulk_out) < USB_MAXENDPOINTS / 2);
 719         BUILD_BUG_ON(ARRAY_SIZE(epds->interrupt_in) < USB_MAXENDPOINTS / 2);
 720         BUILD_BUG_ON(ARRAY_SIZE(epds->interrupt_out) < USB_MAXENDPOINTS / 2);
 721
 722         iface_desc = serial->interface->cur_altsetting;
 723         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 724                 epd = &iface_desc->endpoint[i].desc;
 725
 726                 if (usb_endpoint_is_bulk_in(epd)) {
 727                         dev_dbg(dev, "found bulk in on endpoint %u\n", i);
 728                         epds->bulk_in[epds->num_bulk_in++] = epd;
 729                 } else if (usb_endpoint_is_bulk_out(epd)) {
 730                         dev_dbg(dev, "found bulk out on endpoint %u\n", i);
 731                         epds->bulk_out[epds->num_bulk_out++] = epd;
 732                 } else if (usb_endpoint_is_int_in(epd)) {
 733                         dev_dbg(dev, "found interrupt in on endpoint %u\n", i);
 734                         epds->interrupt_in[epds->num_interrupt_in++] = epd;
 735                 } else if (usb_endpoint_is_int_out(epd)) {
 736                         dev_dbg(dev, "found interrupt out on endpoint %u\n", i);
 737                         epds->interrupt_out[epds->num_interrupt_out++] = epd;
 738                 }
 739         }
 740 }
 741
 742 static int setup_port_bulk_in(struct usb_serial_port *port,
 743                                         struct usb_endpoint_descriptor *epd)
 744 {
 745         struct usb_serial_driver *type = port->serial->type;
 746         struct usb_device *udev = port->serial->dev;
 747         int buffer_size;
 748         int i;
 749
 750         buffer_size = max_t(int, type->bulk_in_size, usb_endpoint_maxp(epd));
 751         port->bulk_in_size = buffer_size;
 752         port->bulk_in_endpointAddress = epd->bEndpointAddress;
 753
 754         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 755                 set_bit(i, &port->read_urbs_free);
 756                 port->read_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
 757                 if (!port->read_urbs[i])
 758                         return -ENOMEM;
 759                 port->bulk_in_buffers[i] = kmalloc(buffer_size, GFP_KERNEL);
 760                 if (!port->bulk_in_buffers[i])
 761                         return -ENOMEM;
 762                 usb_fill_bulk_urb(port->read_urbs[i], udev,
 763                                 usb_rcvbulkpipe(udev, epd->bEndpointAddress),
 764                                 port->bulk_in_buffers[i], buffer_size,
 765                                 type->read_bulk_callback, port);
 766         }
 767
 768         port->read_urb = port->read_urbs[0];
 769         port->bulk_in_buffer = port->bulk_in_buffers[0];
 770
 771         return 0;
 772 }
 773
 774 static int setup_port_bulk_out(struct usb_serial_port *port,
 775                                         struct usb_endpoint_descriptor *epd)
 776 {
 777         struct usb_serial_driver *type = port->serial->type;
 778         struct usb_device *udev = port->serial->dev;
 779         int buffer_size;
 780         int i;
 781
 782         if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 783                 return -ENOMEM;
 784         if (type->bulk_out_size)
 785                 buffer_size = type->bulk_out_size;
 786         else
 787                 buffer_size = usb_endpoint_maxp(epd);
 788         port->bulk_out_size = buffer_size;
 789         port->bulk_out_endpointAddress = epd->bEndpointAddress;
 790
 791         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 792                 set_bit(i, &port->write_urbs_free);
 793                 port->write_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
 794                 if (!port->write_urbs[i])
 795                         return -ENOMEM;
 796                 port->bulk_out_buffers[i] = kmalloc(buffer_size, GFP_KERNEL);
 797                 if (!port->bulk_out_buffers[i])
 798                         return -ENOMEM;
 799                 usb_fill_bulk_urb(port->write_urbs[i], udev,
 800                                 usb_sndbulkpipe(udev, epd->bEndpointAddress),
 801                                 port->bulk_out_buffers[i], buffer_size,
 802                                 type->write_bulk_callback, port);
 803         }
 804
 805         port->write_urb = port->write_urbs[0];
 806         port->bulk_out_buffer = port->bulk_out_buffers[0];
 807
 808         return 0;
 809 }
 810
 811 static int setup_port_interrupt_in(struct usb_serial_port *port,
 812                                         struct usb_endpoint_descriptor *epd)
 813 {
 814         struct usb_serial_driver *type = port->serial->type;
 815         struct usb_device *udev = port->serial->dev;
 816         int buffer_size;
 817
 818         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 819         if (!port->interrupt_in_urb)
 820                 return -ENOMEM;
 821         buffer_size = usb_endpoint_maxp(epd);
 822         port->interrupt_in_endpointAddress = epd->bEndpointAddress;
 823         port->interrupt_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 824         if (!port->interrupt_in_buffer)
 825                 return -ENOMEM;
 826         usb_fill_int_urb(port->interrupt_in_urb, udev,
 827                         usb_rcvintpipe(udev, epd->bEndpointAddress),
 828                         port->interrupt_in_buffer, buffer_size,
 829                         type->read_int_callback, port,
 830                         epd->bInterval);
 831
 832         return 0;
 833 }
 834
 835 static int setup_port_interrupt_out(struct usb_serial_port *port,
 836                                         struct usb_endpoint_descriptor *epd)
 837 {
 838         struct usb_serial_driver *type = port->serial->type;
 839         struct usb_device *udev = port->serial->dev;
 840         int buffer_size;
 841
 842         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 843         if (!port->interrupt_out_urb)
 844                 return -ENOMEM;
 845         buffer_size = usb_endpoint_maxp(epd);
 846         port->interrupt_out_size = buffer_size;
 847         port->interrupt_out_endpointAddress = epd->bEndpointAddress;
 848         port->interrupt_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 849         if (!port->interrupt_out_buffer)
 850                 return -ENOMEM;
 851         usb_fill_int_urb(port->interrupt_out_urb, udev,
 852                         usb_sndintpipe(udev, epd->bEndpointAddress),
 853                         port->interrupt_out_buffer, buffer_size,
 854                         type->write_int_callback, port,
 855                         epd->bInterval);
 856
 857         return 0;
 858 }
 859
 860 static int usb_serial_probe(struct usb_interface *interface,
 861                                const struct usb_device_id *id)
 862 {
 863         struct device *ddev = &interface->dev;
 864         struct usb_device *dev = interface_to_usbdev(interface);
 865         struct usb_serial *serial = NULL;
 866         struct usb_serial_port *port;
 867         struct usb_serial_endpoints *epds;
 868         struct usb_serial_driver *type = NULL;
 869         int retval;
 870         int i;
 871         int num_ports = 0;
 872         unsigned char max_endpoints;
 873
 874         mutex_lock(&table_lock);
 875         type = search_serial_device(interface);
 876         if (!type) {
 877                 mutex_unlock(&table_lock);
 878                 dev_dbg(ddev, "none matched\n");
 879                 return -ENODEV;
 880         }
 881
 882         if (!try_module_get(type->driver.owner)) {
 883                 mutex_unlock(&table_lock);
 884                 dev_err(ddev, "module get failed, exiting\n");
 885                 return -EIO;
 886         }
 887         mutex_unlock(&table_lock);
 888
 889         serial = create_serial(dev, interface, type);
 890         if (!serial) {
 891                 retval = -ENOMEM;
 892                 goto err_put_module;
 893         }
 894
 895         /* if this device type has a probe function, call it */
 896         if (type->probe) {
 897                 const struct usb_device_id *id;
 898
 899                 id = get_iface_id(type, interface);
 900                 retval = type->probe(serial, id);
 901
 902                 if (retval) {
 903                         dev_dbg(ddev, "sub driver rejected device\n");
 904                         goto err_put_serial;
 905                 }
 906         }
 907
 908         /* descriptor matches, let's find the endpoints needed */
 909         epds = kzalloc(sizeof(*epds), GFP_KERNEL);
 910         if (!epds) {
 911                 retval = -ENOMEM;
 912                 goto err_put_serial;
 913         }
 914
 915         find_endpoints(serial, epds);
 916
 917         if (epds->num_bulk_in < type->num_bulk_in ||
 918                         epds->num_bulk_out < type->num_bulk_out ||
 919                         epds->num_interrupt_in < type->num_interrupt_in ||
 920                         epds->num_interrupt_out < type->num_interrupt_out) {
 921                 dev_err(ddev, "required endpoints missing\n");
 922                 retval = -ENODEV;
 923                 goto err_free_epds;
 924         }
 925
 926         if (type->calc_num_ports) {
 927                 retval = type->calc_num_ports(serial, epds);
 928                 if (retval < 0)
 929                         goto err_free_epds;
 930                 num_ports = retval;
 931         }
 932
 933         if (!num_ports)
 934                 num_ports = type->num_ports;
 935
 936         if (num_ports > MAX_NUM_PORTS) {
 937                 dev_warn(ddev, "too many ports requested: %d\n", num_ports);
 938                 num_ports = MAX_NUM_PORTS;
 939         }
 940
 941         serial->num_ports = (unsigned char)num_ports;
 942         serial->num_bulk_in = epds->num_bulk_in;
 943         serial->num_bulk_out = epds->num_bulk_out;
 944         serial->num_interrupt_in = epds->num_interrupt_in;
 945         serial->num_interrupt_out = epds->num_interrupt_out;
 946
 947         /* found all that we need */
 948         dev_info(ddev, "%s converter detected\n", type->description);
 949
 950         /* create our ports, we need as many as the max endpoints */
 951         /* we don't use num_ports here because some devices have more
 952            endpoint pairs than ports */
 953         max_endpoints = max(epds->num_bulk_in, epds->num_bulk_out);
 954         max_endpoints = max(max_endpoints, epds->num_interrupt_in);
 955         max_endpoints = max(max_endpoints, epds->num_interrupt_out);
 956         max_endpoints = max(max_endpoints, serial->num_ports);
 957         serial->num_port_pointers = max_endpoints;
 958
 959         dev_dbg(ddev, "setting up %d port structure(s)\n", max_endpoints);
 960         for (i = 0; i < max_endpoints; ++i) {
 961                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 962                 if (!port) {
 963                         retval = -ENOMEM;
 964                         goto err_free_epds;
 965                 }
 966                 tty_port_init(&port->port);
 967                 port->port.ops = &serial_port_ops;
 968                 port->serial = serial;
 969                 spin_lock_init(&port->lock);
 970                 /* Keep this for private driver use for the moment but
 971                    should probably go away */
 972                 INIT_WORK(&port->work, usb_serial_port_work);
 973                 serial->port[i] = port;
 974                 port->dev.parent = &interface->dev;
 975                 port->dev.driver = NULL;
 976                 port->dev.bus = &usb_serial_bus_type;
 977                 port->dev.release = &usb_serial_port_release;
 978                 port->dev.groups = usb_serial_port_groups;
 979                 device_initialize(&port->dev);
 980         }
 981
 982         /* set up the endpoint information */
 983         for (i = 0; i < epds->num_bulk_in; ++i) {
 984                 retval = setup_port_bulk_in(serial->port[i], epds->bulk_in[i]);
 985                 if (retval)
 986                         goto err_free_epds;
 987         }
 988
 989         for (i = 0; i < epds->num_bulk_out; ++i) {
 990                 retval = setup_port_bulk_out(serial->port[i],
 991                                 epds->bulk_out[i]);
 992                 if (retval)
 993                         goto err_free_epds;
 994         }
 995
 996         if (serial->type->read_int_callback) {
 997                 for (i = 0; i < epds->num_interrupt_in; ++i) {
 998                         retval = setup_port_interrupt_in(serial->port[i],
 999                                         epds->interrupt_in[i]);
1000                         if (retval)
1001                                 goto err_free_epds;
1002                 }
1003         } else if (epds->num_interrupt_in) {
1004                 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1005         }
1006
1007         if (serial->type->write_int_callback) {
1008                 for (i = 0; i < epds->num_interrupt_out; ++i) {
1009                         retval = setup_port_interrupt_out(serial->port[i],
1010                                         epds->interrupt_out[i]);
1011                         if (retval)
1012                                 goto err_free_epds;
1013                 }
1014         } else if (epds->num_interrupt_out) {
1015                 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1016         }
1017
1018         usb_set_intfdata(interface, serial);
1019
1020         /* if this device type has an attach function, call it */
1021         if (type->attach) {
1022                 retval = type->attach(serial);
1023                 if (retval < 0)
1024                         goto err_free_epds;
1025                 serial->attached = 1;
1026                 if (retval > 0) {
1027                         /* quietly accept this device, but don't bind to a
1028                            serial port as it's about to disappear */
1029                         serial->num_ports = 0;
1030                         goto exit;
1031                 }
1032         } else {
1033                 serial->attached = 1;
1034         }
1035
1036         retval = allocate_minors(serial, num_ports);
1037         if (retval) {
1038                 dev_err(ddev, "No more free serial minor numbers\n");
1039                 goto err_free_epds;
1040         }
1041
1042         /* register all of the individual ports with the driver core */
1043         for (i = 0; i < num_ports; ++i) {
1044                 port = serial->port[i];
1045                 dev_set_name(&port->dev, "ttyUSB%d", port->minor);
1046                 dev_dbg(ddev, "registering %s\n", dev_name(&port->dev));
1047                 device_enable_async_suspend(&port->dev);
1048
1049                 retval = device_add(&port->dev);
1050                 if (retval)
1051                         dev_err(ddev, "Error registering port device, continuing\n");
1052         }
1053
1054         if (num_ports > 0)
1055                 usb_serial_console_init(serial->port[0]->minor);
1056 exit:
1057         kfree(epds);
1058         module_put(type->driver.owner);
1059         return 0;
1060
1061 err_free_epds:
1062         kfree(epds);
1063 err_put_serial:
1064         usb_serial_put(serial);
1065 err_put_module:
1066         module_put(type->driver.owner);
1067
1068         return retval;
1069 }
1070
1071 static void usb_serial_disconnect(struct usb_interface *interface)
1072 {
1073         int i;
1074         struct usb_serial *serial = usb_get_intfdata(interface);
1075         struct device *dev = &interface->dev;
1076         struct usb_serial_port *port;
1077         struct tty_struct *tty;
1078
1079         usb_serial_console_disconnect(serial);
1080
1081         mutex_lock(&serial->disc_mutex);
1082         /* must set a flag, to signal subdrivers */
1083         serial->disconnected = 1;
1084         mutex_unlock(&serial->disc_mutex);
1085
1086         for (i = 0; i < serial->num_ports; ++i) {
1087                 port = serial->port[i];
1088                 tty = tty_port_tty_get(&port->port);
1089                 if (tty) {
1090                         tty_vhangup(tty);
1091                         tty_kref_put(tty);
1092                 }
1093                 usb_serial_port_poison_urbs(port);
1094                 wake_up_interruptible(&port->port.delta_msr_wait);
1095                 cancel_work_sync(&port->work);
1096                 if (device_is_registered(&port->dev))
1097                         device_del(&port->dev);
1098         }
1099         if (serial->type->disconnect)
1100                 serial->type->disconnect(serial);
1101
1102         /* let the last holder of this object cause it to be cleaned up */
1103         usb_serial_put(serial);
1104         dev_info(dev, "device disconnected\n");
1105 }
1106
1107 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1108 {
1109         struct usb_serial *serial = usb_get_intfdata(intf);
1110         int i, r = 0;
1111
1112         serial->suspending = 1;
1113
1114         /*
1115          * serial->type->suspend() MUST return 0 in system sleep context,
1116          * otherwise, the resume callback has to recover device from
1117          * previous suspend failure.
1118          */
1119         if (serial->type->suspend) {
1120                 r = serial->type->suspend(serial, message);
1121                 if (r < 0) {
1122                         serial->suspending = 0;
1123                         goto err_out;
1124                 }
1125         }
1126
1127         for (i = 0; i < serial->num_ports; ++i)
1128                 usb_serial_port_poison_urbs(serial->port[i]);
1129 err_out:
1130         return r;
1131 }
1132 EXPORT_SYMBOL(usb_serial_suspend);
1133
1134 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1135 {
1136         int i;
1137
1138         for (i = 0; i < serial->num_ports; ++i)
1139                 usb_serial_port_unpoison_urbs(serial->port[i]);
1140 }
1141
1142 int usb_serial_resume(struct usb_interface *intf)
1143 {
1144         struct usb_serial *serial = usb_get_intfdata(intf);
1145         int rv;
1146
1147         usb_serial_unpoison_port_urbs(serial);
1148
1149         serial->suspending = 0;
1150         if (serial->type->resume)
1151                 rv = serial->type->resume(serial);
1152         else
1153                 rv = usb_serial_generic_resume(serial);
1154
1155         return rv;
1156 }
1157 EXPORT_SYMBOL(usb_serial_resume);
1158
1159 static int usb_serial_reset_resume(struct usb_interface *intf)
1160 {
1161         struct usb_serial *serial = usb_get_intfdata(intf);
1162         int rv;
1163
1164         usb_serial_unpoison_port_urbs(serial);
1165
1166         serial->suspending = 0;
1167         if (serial->type->reset_resume) {
1168                 rv = serial->type->reset_resume(serial);
1169         } else {
1170                 rv = -EOPNOTSUPP;
1171                 intf->needs_binding = 1;
1172         }
1173
1174         return rv;
1175 }
1176
1177 static const struct tty_operations serial_ops = {
1178         .open =                 serial_open,
1179         .close =                serial_close,
1180         .write =                serial_write,
1181         .hangup =               serial_hangup,
1182         .write_room =           serial_write_room,
1183         .ioctl =                serial_ioctl,
1184         .set_termios =          serial_set_termios,
1185         .throttle =             serial_throttle,
1186         .unthrottle =           serial_unthrottle,
1187         .break_ctl =            serial_break,
1188         .chars_in_buffer =      serial_chars_in_buffer,
1189         .wait_until_sent =      serial_wait_until_sent,
1190         .tiocmget =             serial_tiocmget,
1191         .tiocmset =             serial_tiocmset,
1192         .get_icount =           serial_get_icount,
1193         .cleanup =              serial_cleanup,
1194         .install =              serial_install,
1195         .proc_fops =            &serial_proc_fops,
1196 };
1197
1198
1199 struct tty_driver *usb_serial_tty_driver;
1200
1201 static int __init usb_serial_init(void)
1202 {
1203         int result;
1204
1205         usb_serial_tty_driver = alloc_tty_driver(USB_SERIAL_TTY_MINORS);
1206         if (!usb_serial_tty_driver)
1207                 return -ENOMEM;
1208
1209         /* Initialize our global data */
1210         result = bus_register(&usb_serial_bus_type);
1211         if (result) {
1212                 pr_err("%s - registering bus driver failed\n", __func__);
1213                 goto exit_bus;
1214         }
1215
1216         usb_serial_tty_driver->driver_name = "usbserial";
1217         usb_serial_tty_driver->name = "ttyUSB";
1218         usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR;
1219         usb_serial_tty_driver->minor_start = 0;
1220         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1221         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1222         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1223                                                 TTY_DRIVER_DYNAMIC_DEV;
1224         usb_serial_tty_driver->init_termios = tty_std_termios;
1225         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1226                                                         | HUPCL | CLOCAL;
1227         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1228         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1229         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1230         result = tty_register_driver(usb_serial_tty_driver);
1231         if (result) {
1232                 pr_err("%s - tty_register_driver failed\n", __func__);
1233                 goto exit_reg_driver;
1234         }
1235
1236         /* register the generic driver, if we should */
1237         result = usb_serial_generic_register();
1238         if (result < 0) {
1239                 pr_err("%s - registering generic driver failed\n", __func__);
1240                 goto exit_generic;
1241         }
1242
1243         return result;
1244
1245 exit_generic:
1246         tty_unregister_driver(usb_serial_tty_driver);
1247
1248 exit_reg_driver:
1249         bus_unregister(&usb_serial_bus_type);
1250
1251 exit_bus:
1252         pr_err("%s - returning with error %d\n", __func__, result);
1253         put_tty_driver(usb_serial_tty_driver);
1254         return result;
1255 }
1256
1257
1258 static void __exit usb_serial_exit(void)
1259 {
1260         usb_serial_console_exit();
1261
1262         usb_serial_generic_deregister();
1263
1264         tty_unregister_driver(usb_serial_tty_driver);
1265         put_tty_driver(usb_serial_tty_driver);
1266         bus_unregister(&usb_serial_bus_type);
1267         idr_destroy(&serial_minors);
1268 }
1269
1270
1271 module_init(usb_serial_init);
1272 module_exit(usb_serial_exit);
1273
1274 #define set_to_generic_if_null(type, function)                          \
1275         do {                                                            \
1276                 if (!type->function) {                                  \
1277                         type->function = usb_serial_generic_##function; \
1278                         pr_debug("%s: using generic " #function "\n",   \
1279                                                 type->driver.name);     \
1280                 }                                                       \
1281         } while (0)
1282
1283 static void usb_serial_operations_init(struct usb_serial_driver *device)
1284 {
1285         set_to_generic_if_null(device, open);
1286         set_to_generic_if_null(device, write);
1287         set_to_generic_if_null(device, close);
1288         set_to_generic_if_null(device, write_room);
1289         set_to_generic_if_null(device, chars_in_buffer);
1290         if (device->tx_empty)
1291                 set_to_generic_if_null(device, wait_until_sent);
1292         set_to_generic_if_null(device, read_bulk_callback);
1293         set_to_generic_if_null(device, write_bulk_callback);
1294         set_to_generic_if_null(device, process_read_urb);
1295         set_to_generic_if_null(device, prepare_write_buffer);
1296 }
1297
1298 static int usb_serial_register(struct usb_serial_driver *driver)
1299 {
1300         int retval;
1301
1302         if (usb_disabled())
1303                 return -ENODEV;
1304
1305         if (!driver->description)
1306                 driver->description = driver->driver.name;
1307         if (!driver->usb_driver) {
1308                 WARN(1, "Serial driver %s has no usb_driver\n",
1309                                 driver->description);
1310                 return -EINVAL;
1311         }
1312
1313         usb_serial_operations_init(driver);
1314
1315         /* Add this device to our list of devices */
1316         mutex_lock(&table_lock);
1317         list_add(&driver->driver_list, &usb_serial_driver_list);
1318
1319         retval = usb_serial_bus_register(driver);
1320         if (retval) {
1321                 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1322                 list_del(&driver->driver_list);
1323         } else {
1324                 pr_info("USB Serial support registered for %s\n", driver->description);
1325         }
1326         mutex_unlock(&table_lock);
1327         return retval;
1328 }
1329
1330 static void usb_serial_deregister(struct usb_serial_driver *device)
1331 {
1332         pr_info("USB Serial deregistering driver %s\n", device->description);
1333
1334         mutex_lock(&table_lock);
1335         list_del(&device->driver_list);
1336         mutex_unlock(&table_lock);
1337
1338         usb_serial_bus_deregister(device);
1339 }
1340
1341 /**
1342  * usb_serial_register_drivers - register drivers for a usb-serial module
1343  * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1344  * @name: name of the usb_driver for this set of @serial_drivers
1345  * @id_table: list of all devices this @serial_drivers set binds to
1346  *
1347  * Registers all the drivers in the @serial_drivers array, and dynamically
1348  * creates a struct usb_driver with the name @name and id_table of @id_table.
1349  */
1350 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1351                                 const char *name,
1352                                 const struct usb_device_id *id_table)
1353 {
1354         int rc;
1355         struct usb_driver *udriver;
1356         struct usb_serial_driver * const *sd;
1357
1358         /*
1359          * udriver must be registered before any of the serial drivers,
1360          * because the store_new_id() routine for the serial drivers (in
1361          * bus.c) probes udriver.
1362          *
1363          * Performance hack: We don't want udriver to be probed until
1364          * the serial drivers are registered, because the probe would
1365          * simply fail for lack of a matching serial driver.
1366          * So we leave udriver's id_table set to NULL until we are all set.
1367          *
1368          * Suspend/resume support is implemented in the usb-serial core,
1369          * so fill in the PM-related fields in udriver.
1370          */
1371         udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1372         if (!udriver)
1373                 return -ENOMEM;
1374
1375         udriver->name = name;
1376         udriver->no_dynamic_id = 1;
1377         udriver->supports_autosuspend = 1;
1378         udriver->suspend = usb_serial_suspend;
1379         udriver->resume = usb_serial_resume;
1380         udriver->probe = usb_serial_probe;
1381         udriver->disconnect = usb_serial_disconnect;
1382
1383         /* we only set the reset_resume field if the serial_driver has one */
1384         for (sd = serial_drivers; *sd; ++sd) {
1385                 if ((*sd)->reset_resume) {
1386                         udriver->reset_resume = usb_serial_reset_resume;
1387                         break;
1388                 }
1389         }
1390
1391         rc = usb_register(udriver);
1392         if (rc)
1393                 goto failed_usb_register;
1394
1395         for (sd = serial_drivers; *sd; ++sd) {
1396                 (*sd)->usb_driver = udriver;
1397                 rc = usb_serial_register(*sd);
1398                 if (rc)
1399                         goto failed;
1400         }
1401
1402         /* Now set udriver's id_table and look for matches */
1403         udriver->id_table = id_table;
1404         rc = driver_attach(&udriver->drvwrap.driver);
1405         return 0;
1406
1407  failed:
1408         while (sd-- > serial_drivers)
1409                 usb_serial_deregister(*sd);
1410         usb_deregister(udriver);
1411 failed_usb_register:
1412         kfree(udriver);
1413         return rc;
1414 }
1415 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1416
1417 /**
1418  * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1419  * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1420  *
1421  * Deregisters all the drivers in the @serial_drivers array and deregisters and
1422  * frees the struct usb_driver that was created by the call to
1423  * usb_serial_register_drivers().
1424  */
1425 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1426 {
1427         struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1428
1429         for (; *serial_drivers; ++serial_drivers)
1430                 usb_serial_deregister(*serial_drivers);
1431         usb_deregister(udriver);
1432         kfree(udriver);
1433 }
1434 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1435
1436 MODULE_AUTHOR(DRIVER_AUTHOR);
1437 MODULE_DESCRIPTION(DRIVER_DESC);
1438 MODULE_LICENSE("GPL v2");