drivers/usb/serial/usb-serial.c

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