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