drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 1999 - 2005 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 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         }
 849 #endif
 850         if (!num_ports) {
 851                 /* if this device type has a calc_num_ports function, call it */
 852                 if (type->calc_num_ports)
 853                         num_ports = type->calc_num_ports(serial);
 854                 if (!num_ports)
 855                         num_ports = type->num_ports;
 856         }
 857
 858         serial->num_ports = num_ports;
 859         serial->num_bulk_in = num_bulk_in;
 860         serial->num_bulk_out = num_bulk_out;
 861         serial->num_interrupt_in = num_interrupt_in;
 862         serial->num_interrupt_out = num_interrupt_out;
 863
 864         /* found all that we need */
 865         dev_info(&interface->dev, "%s converter detected\n",
 866                         type->description);
 867
 868         /* create our ports, we need as many as the max endpoints */
 869         /* we don't use num_ports here because some devices have more
 870            endpoint pairs than ports */
 871         max_endpoints = max(num_bulk_in, num_bulk_out);
 872         max_endpoints = max(max_endpoints, num_interrupt_in);
 873         max_endpoints = max(max_endpoints, num_interrupt_out);
 874         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 875         serial->num_port_pointers = max_endpoints;
 876
 877         dbg("%s - setting up %d port structures for this device",
 878                                                 __func__, max_endpoints);
 879         for (i = 0; i < max_endpoints; ++i) {
 880                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 881                 if (!port)
 882                         goto probe_error;
 883                 tty_port_init(&port->port);
 884                 port->port.ops = &serial_port_ops;
 885                 port->serial = serial;
 886                 spin_lock_init(&port->lock);
 887                 /* Keep this for private driver use for the moment but
 888                    should probably go away */
 889                 INIT_WORK(&port->work, usb_serial_port_work);
 890                 serial->port[i] = port;
 891                 port->dev.parent = &interface->dev;
 892                 port->dev.driver = NULL;
 893                 port->dev.bus = &usb_serial_bus_type;
 894                 port->dev.release = &port_release;
 895                 device_initialize(&port->dev);
 896         }
 897
 898         /* set up the endpoint information */
 899         for (i = 0; i < num_bulk_in; ++i) {
 900                 endpoint = bulk_in_endpoint[i];
 901                 port = serial->port[i];
 902                 buffer_size = max_t(int, serial->type->bulk_in_size,
 903                                 usb_endpoint_maxp(endpoint));
 904                 port->bulk_in_size = buffer_size;
 905                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 906
 907                 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
 908                         set_bit(j, &port->read_urbs_free);
 909                         port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 910                         if (!port->read_urbs[j]) {
 911                                 dev_err(&interface->dev,
 912                                                 "No free urbs available\n");
 913                                 goto probe_error;
 914                         }
 915                         port->bulk_in_buffers[j] = kmalloc(buffer_size,
 916                                                                 GFP_KERNEL);
 917                         if (!port->bulk_in_buffers[j]) {
 918                                 dev_err(&interface->dev,
 919                                         "Couldn't allocate bulk_in_buffer\n");
 920                                 goto probe_error;
 921                         }
 922                         usb_fill_bulk_urb(port->read_urbs[j], dev,
 923                                         usb_rcvbulkpipe(dev,
 924                                                 endpoint->bEndpointAddress),
 925                                         port->bulk_in_buffers[j], buffer_size,
 926                                         serial->type->read_bulk_callback,
 927                                         port);
 928                 }
 929
 930                 port->read_urb = port->read_urbs[0];
 931                 port->bulk_in_buffer = port->bulk_in_buffers[0];
 932         }
 933
 934         for (i = 0; i < num_bulk_out; ++i) {
 935                 endpoint = bulk_out_endpoint[i];
 936                 port = serial->port[i];
 937                 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 938                         goto probe_error;
 939                 buffer_size = serial->type->bulk_out_size;
 940                 if (!buffer_size)
 941                         buffer_size = usb_endpoint_maxp(endpoint);
 942                 port->bulk_out_size = buffer_size;
 943                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 944
 945                 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
 946                         set_bit(j, &port->write_urbs_free);
 947                         port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 948                         if (!port->write_urbs[j]) {
 949                                 dev_err(&interface->dev,
 950                                                 "No free urbs available\n");
 951                                 goto probe_error;
 952                         }
 953                         port->bulk_out_buffers[j] = kmalloc(buffer_size,
 954                                                                 GFP_KERNEL);
 955                         if (!port->bulk_out_buffers[j]) {
 956                                 dev_err(&interface->dev,
 957                                         "Couldn't allocate bulk_out_buffer\n");
 958                                 goto probe_error;
 959                         }
 960                         usb_fill_bulk_urb(port->write_urbs[j], dev,
 961                                         usb_sndbulkpipe(dev,
 962                                                 endpoint->bEndpointAddress),
 963                                         port->bulk_out_buffers[j], buffer_size,
 964                                         serial->type->write_bulk_callback,
 965                                         port);
 966                 }
 967
 968                 port->write_urb = port->write_urbs[0];
 969                 port->bulk_out_buffer = port->bulk_out_buffers[0];
 970         }
 971
 972         if (serial->type->read_int_callback) {
 973                 for (i = 0; i < num_interrupt_in; ++i) {
 974                         endpoint = interrupt_in_endpoint[i];
 975                         port = serial->port[i];
 976                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 977                         if (!port->interrupt_in_urb) {
 978                                 dev_err(&interface->dev,
 979                                                 "No free urbs available\n");
 980                                 goto probe_error;
 981                         }
 982                         buffer_size = usb_endpoint_maxp(endpoint);
 983                         port->interrupt_in_endpointAddress =
 984                                                 endpoint->bEndpointAddress;
 985                         port->interrupt_in_buffer = kmalloc(buffer_size,
 986                                                                 GFP_KERNEL);
 987                         if (!port->interrupt_in_buffer) {
 988                                 dev_err(&interface->dev,
 989                                     "Couldn't allocate interrupt_in_buffer\n");
 990                                 goto probe_error;
 991                         }
 992                         usb_fill_int_urb(port->interrupt_in_urb, dev,
 993                                 usb_rcvintpipe(dev,
 994                                                 endpoint->bEndpointAddress),
 995                                 port->interrupt_in_buffer, buffer_size,
 996                                 serial->type->read_int_callback, port,
 997                                 endpoint->bInterval);
 998                 }
 999         } else if (num_interrupt_in) {
1000                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1001         }
1002
1003         if (serial->type->write_int_callback) {
1004                 for (i = 0; i < num_interrupt_out; ++i) {
1005                         endpoint = interrupt_out_endpoint[i];
1006                         port = serial->port[i];
1007                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1008                         if (!port->interrupt_out_urb) {
1009                                 dev_err(&interface->dev,
1010                                                 "No free urbs available\n");
1011                                 goto probe_error;
1012                         }
1013                         buffer_size = usb_endpoint_maxp(endpoint);
1014                         port->interrupt_out_size = buffer_size;
1015                         port->interrupt_out_endpointAddress =
1016                                                 endpoint->bEndpointAddress;
1017                         port->interrupt_out_buffer = kmalloc(buffer_size,
1018                                                                 GFP_KERNEL);
1019                         if (!port->interrupt_out_buffer) {
1020                                 dev_err(&interface->dev,
1021                                   "Couldn't allocate interrupt_out_buffer\n");
1022                                 goto probe_error;
1023                         }
1024                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1025                                 usb_sndintpipe(dev,
1026                                                   endpoint->bEndpointAddress),
1027                                 port->interrupt_out_buffer, buffer_size,
1028                                 serial->type->write_int_callback, port,
1029                                 endpoint->bInterval);
1030                 }
1031         } else if (num_interrupt_out) {
1032                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1033         }
1034
1035         usb_set_intfdata(interface, serial);
1036
1037         /* if this device type has an attach function, call it */
1038         if (type->attach) {
1039                 retval = type->attach(serial);
1040                 if (retval < 0)
1041                         goto probe_error;
1042                 serial->attached = 1;
1043                 if (retval > 0) {
1044                         /* quietly accept this device, but don't bind to a
1045                            serial port as it's about to disappear */
1046                         serial->num_ports = 0;
1047                         goto exit;
1048                 }
1049         } else {
1050                 serial->attached = 1;
1051         }
1052
1053         /* Avoid race with tty_open and serial_install by setting the
1054          * disconnected flag and not clearing it until all ports have been
1055          * registered.
1056          */
1057         serial->disconnected = 1;
1058
1059         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1060                 dev_err(&interface->dev, "No more free serial devices\n");
1061                 goto probe_error;
1062         }
1063         serial->minor = minor;
1064
1065         /* register all of the individual ports with the driver core */
1066         for (i = 0; i < num_ports; ++i) {
1067                 port = serial->port[i];
1068                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1069                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1070                 device_enable_async_suspend(&port->dev);
1071
1072                 retval = device_add(&port->dev);
1073                 if (retval)
1074                         dev_err(&port->dev, "Error registering port device, "
1075                                 "continuing\n");
1076         }
1077
1078         serial->disconnected = 0;
1079
1080         usb_serial_console_init(debug, minor);
1081 exit:
1082         module_put(type->driver.owner);
1083         return 0;
1084
1085 probe_error:
1086         usb_serial_put(serial);
1087         module_put(type->driver.owner);
1088         return -EIO;
1089 }
1090
1091 static void usb_serial_disconnect(struct usb_interface *interface)
1092 {
1093         int i;
1094         struct usb_serial *serial = usb_get_intfdata(interface);
1095         struct device *dev = &interface->dev;
1096         struct usb_serial_port *port;
1097
1098         usb_serial_console_disconnect(serial);
1099         dbg("%s", __func__);
1100
1101         mutex_lock(&serial->disc_mutex);
1102         /* must set a flag, to signal subdrivers */
1103         serial->disconnected = 1;
1104         mutex_unlock(&serial->disc_mutex);
1105
1106         for (i = 0; i < serial->num_ports; ++i) {
1107                 port = serial->port[i];
1108                 if (port) {
1109                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1110                         if (tty) {
1111                                 tty_vhangup(tty);
1112                                 tty_kref_put(tty);
1113                         }
1114                         kill_traffic(port);
1115                         cancel_work_sync(&port->work);
1116                         if (device_is_registered(&port->dev))
1117                                 device_del(&port->dev);
1118                 }
1119         }
1120         serial->type->disconnect(serial);
1121
1122         /* let the last holder of this object cause it to be cleaned up */
1123         usb_serial_put(serial);
1124         dev_info(dev, "device disconnected\n");
1125 }
1126
1127 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1128 {
1129         struct usb_serial *serial = usb_get_intfdata(intf);
1130         struct usb_serial_port *port;
1131         int i, r = 0;
1132
1133         serial->suspending = 1;
1134
1135         if (serial->type->suspend) {
1136                 r = serial->type->suspend(serial, message);
1137                 if (r < 0) {
1138                         serial->suspending = 0;
1139                         goto err_out;
1140                 }
1141         }
1142
1143         for (i = 0; i < serial->num_ports; ++i) {
1144                 port = serial->port[i];
1145                 if (port)
1146                         kill_traffic(port);
1147         }
1148
1149 err_out:
1150         return r;
1151 }
1152 EXPORT_SYMBOL(usb_serial_suspend);
1153
1154 int usb_serial_resume(struct usb_interface *intf)
1155 {
1156         struct usb_serial *serial = usb_get_intfdata(intf);
1157         int rv;
1158
1159         serial->suspending = 0;
1160         if (serial->type->resume)
1161                 rv = serial->type->resume(serial);
1162         else
1163                 rv = usb_serial_generic_resume(serial);
1164
1165         return rv;
1166 }
1167 EXPORT_SYMBOL(usb_serial_resume);
1168
1169 static const struct tty_operations serial_ops = {
1170         .open =                 serial_open,
1171         .close =                serial_close,
1172         .write =                serial_write,
1173         .hangup =               serial_hangup,
1174         .write_room =           serial_write_room,
1175         .ioctl =                serial_ioctl,
1176         .set_termios =          serial_set_termios,
1177         .throttle =             serial_throttle,
1178         .unthrottle =           serial_unthrottle,
1179         .break_ctl =            serial_break,
1180         .chars_in_buffer =      serial_chars_in_buffer,
1181         .tiocmget =             serial_tiocmget,
1182         .tiocmset =             serial_tiocmset,
1183         .get_icount =           serial_get_icount,
1184         .cleanup =              serial_cleanup,
1185         .install =              serial_install,
1186         .proc_fops =            &serial_proc_fops,
1187 };
1188
1189
1190 struct tty_driver *usb_serial_tty_driver;
1191
1192 /* Driver structure we register with the USB core */
1193 static struct usb_driver usb_serial_driver = {
1194         .name =         "usbserial",
1195         .probe =        usb_serial_probe,
1196         .disconnect =   usb_serial_disconnect,
1197         .suspend =      usb_serial_suspend,
1198         .resume =       usb_serial_resume,
1199         .no_dynamic_id =        1,
1200         .supports_autosuspend = 1,
1201 };
1202
1203 static int __init usb_serial_init(void)
1204 {
1205         int i;
1206         int result;
1207
1208         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1209         if (!usb_serial_tty_driver)
1210                 return -ENOMEM;
1211
1212         /* Initialize our global data */
1213         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1214                 serial_table[i] = NULL;
1215
1216         result = bus_register(&usb_serial_bus_type);
1217         if (result) {
1218                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1219                        "failed\n", __func__);
1220                 goto exit_bus;
1221         }
1222
1223         usb_serial_tty_driver->driver_name = "usbserial";
1224         usb_serial_tty_driver->name = "ttyUSB";
1225         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1226         usb_serial_tty_driver->minor_start = 0;
1227         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1228         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1229         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1230                                                 TTY_DRIVER_DYNAMIC_DEV;
1231         usb_serial_tty_driver->init_termios = tty_std_termios;
1232         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1233                                                         | HUPCL | CLOCAL;
1234         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1235         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1236         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1237         result = tty_register_driver(usb_serial_tty_driver);
1238         if (result) {
1239                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1240                        __func__);
1241                 goto exit_reg_driver;
1242         }
1243
1244         /* register the USB driver */
1245         result = usb_register(&usb_serial_driver);
1246         if (result < 0) {
1247                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1248                        __func__);
1249                 goto exit_tty;
1250         }
1251
1252         /* register the generic driver, if we should */
1253         result = usb_serial_generic_register(debug);
1254         if (result < 0) {
1255                 printk(KERN_ERR "usb-serial: %s - registering generic "
1256                        "driver failed\n", __func__);
1257                 goto exit_generic;
1258         }
1259
1260         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1261
1262         return result;
1263
1264 exit_generic:
1265         usb_deregister(&usb_serial_driver);
1266
1267 exit_tty:
1268         tty_unregister_driver(usb_serial_tty_driver);
1269
1270 exit_reg_driver:
1271         bus_unregister(&usb_serial_bus_type);
1272
1273 exit_bus:
1274         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1275                __func__, result);
1276         put_tty_driver(usb_serial_tty_driver);
1277         return result;
1278 }
1279
1280
1281 static void __exit usb_serial_exit(void)
1282 {
1283         usb_serial_console_exit();
1284
1285         usb_serial_generic_deregister();
1286
1287         usb_deregister(&usb_serial_driver);
1288         tty_unregister_driver(usb_serial_tty_driver);
1289         put_tty_driver(usb_serial_tty_driver);
1290         bus_unregister(&usb_serial_bus_type);
1291 }
1292
1293
1294 module_init(usb_serial_init);
1295 module_exit(usb_serial_exit);
1296
1297 #define set_to_generic_if_null(type, function)                          \
1298         do {                                                            \
1299                 if (!type->function) {                                  \
1300                         type->function = usb_serial_generic_##function; \
1301                         dbg("Had to override the " #function            \
1302                                 " usb serial operation with the generic one.");\
1303                         }                                               \
1304         } while (0)
1305
1306 static void fixup_generic(struct usb_serial_driver *device)
1307 {
1308         set_to_generic_if_null(device, open);
1309         set_to_generic_if_null(device, write);
1310         set_to_generic_if_null(device, close);
1311         set_to_generic_if_null(device, write_room);
1312         set_to_generic_if_null(device, chars_in_buffer);
1313         set_to_generic_if_null(device, read_bulk_callback);
1314         set_to_generic_if_null(device, write_bulk_callback);
1315         set_to_generic_if_null(device, disconnect);
1316         set_to_generic_if_null(device, release);
1317         set_to_generic_if_null(device, process_read_urb);
1318         set_to_generic_if_null(device, prepare_write_buffer);
1319 }
1320
1321 static int usb_serial_register(struct usb_serial_driver *driver)
1322 {
1323         int retval;
1324
1325         if (usb_disabled())
1326                 return -ENODEV;
1327
1328         fixup_generic(driver);
1329
1330         if (!driver->description)
1331                 driver->description = driver->driver.name;
1332         if (!driver->usb_driver) {
1333                 WARN(1, "Serial driver %s has no usb_driver\n",
1334                                 driver->description);
1335                 return -EINVAL;
1336         }
1337
1338         /* Add this device to our list of devices */
1339         mutex_lock(&table_lock);
1340         list_add(&driver->driver_list, &usb_serial_driver_list);
1341
1342         retval = usb_serial_bus_register(driver);
1343         if (retval) {
1344                 printk(KERN_ERR "usb-serial: problem %d when registering "
1345                        "driver %s\n", retval, driver->description);
1346                 list_del(&driver->driver_list);
1347         } else
1348                 printk(KERN_INFO "USB Serial support registered for %s\n",
1349                                                 driver->description);
1350
1351         mutex_unlock(&table_lock);
1352         return retval;
1353 }
1354
1355 static void usb_serial_deregister(struct usb_serial_driver *device)
1356 {
1357         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1358                device->description);
1359         mutex_lock(&table_lock);
1360         list_del(&device->driver_list);
1361         usb_serial_bus_deregister(device);
1362         mutex_unlock(&table_lock);
1363 }
1364
1365 /**
1366  * usb_serial_register_drivers - register drivers for a usb-serial module
1367  * @udriver: usb_driver used for matching devices/interfaces
1368  * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1369  *
1370  * Registers @udriver and all the drivers in the @serial_drivers array.
1371  * Automatically fills in the .no_dynamic_id and PM fields in @udriver and
1372  * the .usb_driver field in each serial driver.
1373  */
1374 int usb_serial_register_drivers(struct usb_driver *udriver,
1375                 struct usb_serial_driver * const serial_drivers[])
1376 {
1377         int rc;
1378         const struct usb_device_id *saved_id_table;
1379         struct usb_serial_driver * const *sd;
1380
1381         /*
1382          * udriver must be registered before any of the serial drivers,
1383          * because the store_new_id() routine for the serial drivers (in
1384          * bus.c) probes udriver.
1385          *
1386          * Performance hack: We don't want udriver to be probed until
1387          * the serial drivers are registered, because the probe would
1388          * simply fail for lack of a matching serial driver.
1389          * Therefore save off udriver's id_table until we are all set.
1390          *
1391          * Suspend/resume support is implemented in the usb-serial core,
1392          * so fill in the PM-related fields in udriver.
1393          */
1394         saved_id_table = udriver->id_table;
1395         udriver->id_table = NULL;
1396
1397         udriver->no_dynamic_id = 1;
1398         udriver->supports_autosuspend = 1;
1399         udriver->suspend = usb_serial_suspend;
1400         udriver->resume = usb_serial_resume;
1401         udriver->probe = usb_serial_probe;
1402         udriver->disconnect = usb_serial_disconnect;
1403         rc = usb_register(udriver);
1404         if (rc)
1405                 return rc;
1406
1407         for (sd = serial_drivers; *sd; ++sd) {
1408                 (*sd)->usb_driver = udriver;
1409                 rc = usb_serial_register(*sd);
1410                 if (rc)
1411                         goto failed;
1412         }
1413
1414         /* Now restore udriver's id_table and look for matches */
1415         udriver->id_table = saved_id_table;
1416         rc = driver_attach(&udriver->drvwrap.driver);
1417         return 0;
1418
1419  failed:
1420         while (sd-- > serial_drivers)
1421                 usb_serial_deregister(*sd);
1422         usb_deregister(udriver);
1423         return rc;
1424 }
1425 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1426
1427 /**
1428  * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1429  * @udriver: usb_driver to unregister
1430  * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1431  *
1432  * Deregisters @udriver and all the drivers in the @serial_drivers array.
1433  */
1434 void usb_serial_deregister_drivers(struct usb_driver *udriver,
1435                 struct usb_serial_driver * const serial_drivers[])
1436 {
1437         for (; *serial_drivers; ++serial_drivers)
1438                 usb_serial_deregister(*serial_drivers);
1439         usb_deregister(udriver);
1440 }
1441 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1442
1443 /* Module information */
1444 MODULE_AUTHOR(DRIVER_AUTHOR);
1445 MODULE_DESCRIPTION(DRIVER_DESC);
1446 MODULE_LICENSE("GPL");
1447
1448 module_param(debug, bool, S_IRUGO | S_IWUSR);
1449 MODULE_PARM_DESC(debug, "Debug enabled or not");