drivers/usb/serial/usb-serial.c

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