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