drivers/usb/serial/usb-serial.c

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