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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22 #include <linux/kernel.h>
  23 #include <linux/errno.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/tty.h>
  27 #include <linux/tty_driver.h>
  28 #include <linux/tty_flip.h>
  29 #include <linux/module.h>
  30 #include <linux/moduleparam.h>
  31 #include <linux/seq_file.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/mutex.h>
  34 #include <linux/list.h>
  35 #include <linux/uaccess.h>
  36 #include <linux/serial.h>
  37 #include <linux/usb.h>
  38 #include <linux/usb/serial.h>
  39 #include <linux/kfifo.h>
  40 #include "pl2303.h"
  41
  42 #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
  43 #define DRIVER_DESC "USB Serial Driver core"
  44
  45 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  46    the MODULE_DEVICE_TABLE declarations in each serial driver
  47    cause the "hotplug" program to pull in whatever module is necessary
  48    via modprobe, and modprobe will load usbserial because the serial
  49    drivers depend on it.
  50 */
  51
  52 /* initially all NULL */
  53 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
  54 static DEFINE_MUTEX(table_lock);
  55 static LIST_HEAD(usb_serial_driver_list);
  56
  57 /*
  58  * Look up the serial structure.  If it is found and it hasn't been
  59  * disconnected, return with its disc_mutex held and its refcount
  60  * incremented.  Otherwise return NULL.
  61  */
  62 struct usb_serial *usb_serial_get_by_index(unsigned index)
  63 {
  64         struct usb_serial *serial;
  65
  66         mutex_lock(&table_lock);
  67         serial = serial_table[index];
  68
  69         if (serial) {
  70                 mutex_lock(&serial->disc_mutex);
  71                 if (serial->disconnected) {
  72                         mutex_unlock(&serial->disc_mutex);
  73                         serial = NULL;
  74                 } else {
  75                         kref_get(&serial->kref);
  76                 }
  77         }
  78         mutex_unlock(&table_lock);
  79         return serial;
  80 }
  81
  82 static struct usb_serial *get_free_serial(struct usb_serial *serial,
  83                                         int num_ports, unsigned int *minor)
  84 {
  85         unsigned int i, j;
  86         int good_spot;
  87
  88         dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
  89
  90         *minor = 0;
  91         mutex_lock(&table_lock);
  92         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
  93                 if (serial_table[i])
  94                         continue;
  95
  96                 good_spot = 1;
  97                 for (j = 1; j <= num_ports-1; ++j)
  98                         if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
  99                                 good_spot = 0;
 100                                 i += j;
 101                                 break;
 102                         }
 103                 if (good_spot == 0)
 104                         continue;
 105
 106                 *minor = i;
 107                 j = 0;
 108                 dev_dbg(&serial->interface->dev, "%s - minor base = %d\n", __func__, *minor);
 109                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
 110                         serial_table[i] = serial;
 111                         serial->port[j++]->number = i;
 112                 }
 113                 mutex_unlock(&table_lock);
 114                 return serial;
 115         }
 116         mutex_unlock(&table_lock);
 117         return NULL;
 118 }
 119
 120 static void return_serial(struct usb_serial *serial)
 121 {
 122         int i;
 123
 124         mutex_lock(&table_lock);
 125         for (i = 0; i < serial->num_ports; ++i)
 126                 serial_table[serial->minor + i] = NULL;
 127         mutex_unlock(&table_lock);
 128 }
 129
 130 static void destroy_serial(struct kref *kref)
 131 {
 132         struct usb_serial *serial;
 133         struct usb_serial_port *port;
 134         int i;
 135
 136         serial = to_usb_serial(kref);
 137
 138         /* return the minor range that this device had */
 139         if (serial->minor != SERIAL_TTY_NO_MINOR)
 140                 return_serial(serial);
 141
 142         if (serial->attached)
 143                 serial->type->release(serial);
 144
 145         /* Now that nothing is using the ports, they can be freed */
 146         for (i = 0; i < serial->num_port_pointers; ++i) {
 147                 port = serial->port[i];
 148                 if (port) {
 149                         port->serial = NULL;
 150                         put_device(&port->dev);
 151                 }
 152         }
 153
 154         usb_put_dev(serial->dev);
 155         kfree(serial);
 156 }
 157
 158 void usb_serial_put(struct usb_serial *serial)
 159 {
 160         kref_put(&serial->kref, destroy_serial);
 161 }
 162
 163 /*****************************************************************************
 164  * Driver tty interface functions
 165  *****************************************************************************/
 166
 167 /**
 168  * serial_install - install tty
 169  * @driver: the driver (USB in our case)
 170  * @tty: the tty being created
 171  *
 172  * Create the termios objects for this tty.  We use the default
 173  * USB serial settings but permit them to be overridden by
 174  * serial->type->init_termios.
 175  *
 176  * This is the first place a new tty gets used.  Hence this is where we
 177  * acquire references to the usb_serial structure and the driver module,
 178  * where we store a pointer to the port, and where we do an autoresume.
 179  * All these actions are reversed in serial_cleanup().
 180  */
 181 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 182 {
 183         int idx = tty->index;
 184         struct usb_serial *serial;
 185         struct usb_serial_port *port;
 186         int retval = -ENODEV;
 187
 188         serial = usb_serial_get_by_index(idx);
 189         if (!serial)
 190                 return retval;
 191
 192         port = serial->port[idx - serial->minor];
 193         if (!port)
 194                 goto error_no_port;
 195         if (!try_module_get(serial->type->driver.owner))
 196                 goto error_module_get;
 197
 198         retval = usb_autopm_get_interface(serial->interface);
 199         if (retval)
 200                 goto error_get_interface;
 201
 202         retval = tty_port_install(&port->port, driver, tty);
 203         if (retval)
 204                 goto error_init_termios;
 205
 206         mutex_unlock(&serial->disc_mutex);
 207
 208         /* allow the driver to update the settings */
 209         if (serial->type->init_termios)
 210                 serial->type->init_termios(tty);
 211
 212         tty->driver_data = port;
 213
 214         return retval;
 215
 216  error_init_termios:
 217         usb_autopm_put_interface(serial->interface);
 218  error_get_interface:
 219         module_put(serial->type->driver.owner);
 220  error_module_get:
 221  error_no_port:
 222         usb_serial_put(serial);
 223         mutex_unlock(&serial->disc_mutex);
 224         return retval;
 225 }
 226
 227 static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
 228 {
 229         struct usb_serial_port *port =
 230                 container_of(tport, struct usb_serial_port, port);
 231         struct usb_serial *serial = port->serial;
 232         int retval;
 233
 234         mutex_lock(&serial->disc_mutex);
 235         if (serial->disconnected)
 236                 retval = -ENODEV;
 237         else
 238                 retval = port->serial->type->open(tty, port);
 239         mutex_unlock(&serial->disc_mutex);
 240
 241         if (retval < 0)
 242                 retval = usb_translate_errors(retval);
 243
 244         return retval;
 245 }
 246
 247 static int serial_open(struct tty_struct *tty, struct file *filp)
 248 {
 249         struct usb_serial_port *port = tty->driver_data;
 250
 251         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 252         return tty_port_open(&port->port, tty, filp);
 253 }
 254
 255 /**
 256  * serial_down - shut down hardware
 257  * @tport: tty port to shut down
 258  *
 259  * Shut down a USB serial port unless it is the console.  We never
 260  * shut down the console hardware as it will always be in use. Serialized
 261  * against activate by the tport mutex and kept to matching open/close pairs
 262  * of calls by the ASYNCB_INITIALIZED flag.
 263  */
 264 static void serial_down(struct tty_port *tport)
 265 {
 266         struct usb_serial_port *port =
 267                 container_of(tport, struct usb_serial_port, port);
 268         struct usb_serial_driver *drv = port->serial->type;
 269         /*
 270          * The console is magical.  Do not hang up the console hardware
 271          * or there will be tears.
 272          */
 273         if (port->port.console)
 274                 return;
 275         if (drv->close)
 276                 drv->close(port);
 277 }
 278
 279 static void serial_hangup(struct tty_struct *tty)
 280 {
 281         struct usb_serial_port *port = tty->driver_data;
 282
 283         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 284         tty_port_hangup(&port->port);
 285 }
 286
 287 static void serial_close(struct tty_struct *tty, struct file *filp)
 288 {
 289         struct usb_serial_port *port = tty->driver_data;
 290
 291         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 292         tty_port_close(&port->port, tty, filp);
 293 }
 294
 295 /**
 296  * serial_cleanup - free resources post close/hangup
 297  * @port: port to free up
 298  *
 299  * Do the resource freeing and refcount dropping for the port.
 300  * Avoid freeing the console.
 301  *
 302  * Called asynchronously after the last tty kref is dropped.
 303  */
 304 static void serial_cleanup(struct tty_struct *tty)
 305 {
 306         struct usb_serial_port *port = tty->driver_data;
 307         struct usb_serial *serial;
 308         struct module *owner;
 309
 310         /* The console is magical.  Do not hang up the console hardware
 311          * or there will be tears.
 312          */
 313         if (port->port.console)
 314                 return;
 315
 316         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 317
 318         tty->driver_data = NULL;
 319
 320         serial = port->serial;
 321         owner = serial->type->driver.owner;
 322
 323         mutex_lock(&serial->disc_mutex);
 324         if (!serial->disconnected)
 325                 usb_autopm_put_interface(serial->interface);
 326         mutex_unlock(&serial->disc_mutex);
 327
 328         usb_serial_put(serial);
 329         module_put(owner);
 330 }
 331
 332 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 333                                                                 int count)
 334 {
 335         struct usb_serial_port *port = tty->driver_data;
 336         int retval = -ENODEV;
 337
 338         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 339                 goto exit;
 340
 341         dev_dbg(tty->dev, "%s - port %d, %d byte(s)\n", __func__,
 342                 port->number, count);
 343
 344         /* pass on to the driver specific version of this function */
 345         retval = port->serial->type->write(tty, port, buf, count);
 346         if (retval < 0)
 347                 retval = usb_translate_errors(retval);
 348 exit:
 349         return retval;
 350 }
 351
 352 static int serial_write_room(struct tty_struct *tty)
 353 {
 354         struct usb_serial_port *port = tty->driver_data;
 355
 356         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 357         /* pass on to the driver specific version of this function */
 358         return port->serial->type->write_room(tty);
 359 }
 360
 361 static int serial_chars_in_buffer(struct tty_struct *tty)
 362 {
 363         struct usb_serial_port *port = tty->driver_data;
 364
 365         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 366
 367         /* if the device was unplugged then any remaining characters
 368            fell out of the connector ;) */
 369         if (port->serial->disconnected)
 370                 return 0;
 371         /* pass on to the driver specific version of this function */
 372         return port->serial->type->chars_in_buffer(tty);
 373 }
 374
 375 static void serial_throttle(struct tty_struct *tty)
 376 {
 377         struct usb_serial_port *port = tty->driver_data;
 378
 379         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 380
 381         /* pass on to the driver specific version of this function */
 382         if (port->serial->type->throttle)
 383                 port->serial->type->throttle(tty);
 384 }
 385
 386 static void serial_unthrottle(struct tty_struct *tty)
 387 {
 388         struct usb_serial_port *port = tty->driver_data;
 389
 390         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 391
 392         /* pass on to the driver specific version of this function */
 393         if (port->serial->type->unthrottle)
 394                 port->serial->type->unthrottle(tty);
 395 }
 396
 397 static int serial_ioctl(struct tty_struct *tty,
 398                                         unsigned int cmd, unsigned long arg)
 399 {
 400         struct usb_serial_port *port = tty->driver_data;
 401         int retval = -ENODEV;
 402
 403         dev_dbg(tty->dev, "%s - port %d, cmd 0x%.4x\n", __func__,
 404                 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
 419         dev_dbg(tty->dev, "%s - port %d\n", __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         dev_dbg(tty->dev, "%s - port %d\n", __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         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         dev_dbg(tty->dev, "%s - port %d\n", __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         dev_dbg(tty->dev, "%s - port %d\n", __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         dev_dbg(tty->dev, "%s - port %d\n", __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         tty = tty_port_tty_get(&port->port);
 541         if (!tty)
 542                 return;
 543
 544         dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 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         dev_dbg(dev, "%s\n", __func__);
 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                 dev_dbg(&intf->dev, "static descriptor matches\n");
 648                 goto exit;
 649         }
 650         id = match_dynamic_id(intf, drv);
 651         if (id)
 652                 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
 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 device *ddev = &interface->dev;
 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                 dev_dbg(ddev, "none matched\n");
 734                 return -ENODEV;
 735         }
 736
 737         if (!try_module_get(type->driver.owner)) {
 738                 mutex_unlock(&table_lock);
 739                 dev_err(ddev, "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(ddev, "%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                         dev_dbg(ddev, "sub driver rejected device\n");
 760                         usb_serial_put(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                         dev_dbg(ddev, "found bulk in on endpoint %d\n", 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                         dev_dbg(ddev, "found bulk out on endpoint %d\n", 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                         dev_dbg(ddev, "found interrupt in on endpoint %d\n", 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                         dev_dbg(ddev, "found interrupt out on endpoint %d\n", 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                                         dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
 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(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 832                         usb_serial_put(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(ddev, "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(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
 850                 dev_info(ddev, "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(ddev, "%s converter detected\n", type->description);
 869
 870         /* create our ports, we need as many as the max endpoints */
 871         /* we don't use num_ports here because some devices have more
 872            endpoint pairs than ports */
 873         max_endpoints = max(num_bulk_in, num_bulk_out);
 874         max_endpoints = max(max_endpoints, num_interrupt_in);
 875         max_endpoints = max(max_endpoints, num_interrupt_out);
 876         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 877         serial->num_port_pointers = max_endpoints;
 878
 879         dev_dbg(ddev, "setting up %d port structures for this device", max_endpoints);
 880         for (i = 0; i < max_endpoints; ++i) {
 881                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 882                 if (!port)
 883                         goto probe_error;
 884                 tty_port_init(&port->port);
 885                 port->port.ops = &serial_port_ops;
 886                 port->serial = serial;
 887                 spin_lock_init(&port->lock);
 888                 /* Keep this for private driver use for the moment but
 889                    should probably go away */
 890                 INIT_WORK(&port->work, usb_serial_port_work);
 891                 serial->port[i] = port;
 892                 port->dev.parent = &interface->dev;
 893                 port->dev.driver = NULL;
 894                 port->dev.bus = &usb_serial_bus_type;
 895                 port->dev.release = &port_release;
 896                 device_initialize(&port->dev);
 897         }
 898
 899         /* set up the endpoint information */
 900         for (i = 0; i < num_bulk_in; ++i) {
 901                 endpoint = bulk_in_endpoint[i];
 902                 port = serial->port[i];
 903                 buffer_size = max_t(int, serial->type->bulk_in_size,
 904                                 usb_endpoint_maxp(endpoint));
 905                 port->bulk_in_size = buffer_size;
 906                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 907
 908                 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
 909                         set_bit(j, &port->read_urbs_free);
 910                         port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 911                         if (!port->read_urbs[j]) {
 912                                 dev_err(ddev, "No free urbs available\n");
 913                                 goto probe_error;
 914                         }
 915                         port->bulk_in_buffers[j] = kmalloc(buffer_size,
 916                                                                 GFP_KERNEL);
 917                         if (!port->bulk_in_buffers[j]) {
 918                                 dev_err(ddev, "Couldn't allocate bulk_in_buffer\n");
 919                                 goto probe_error;
 920                         }
 921                         usb_fill_bulk_urb(port->read_urbs[j], dev,
 922                                         usb_rcvbulkpipe(dev,
 923                                                 endpoint->bEndpointAddress),
 924                                         port->bulk_in_buffers[j], buffer_size,
 925                                         serial->type->read_bulk_callback,
 926                                         port);
 927                 }
 928
 929                 port->read_urb = port->read_urbs[0];
 930                 port->bulk_in_buffer = port->bulk_in_buffers[0];
 931         }
 932
 933         for (i = 0; i < num_bulk_out; ++i) {
 934                 endpoint = bulk_out_endpoint[i];
 935                 port = serial->port[i];
 936                 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 937                         goto probe_error;
 938                 buffer_size = serial->type->bulk_out_size;
 939                 if (!buffer_size)
 940                         buffer_size = usb_endpoint_maxp(endpoint);
 941                 port->bulk_out_size = buffer_size;
 942                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 943
 944                 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
 945                         set_bit(j, &port->write_urbs_free);
 946                         port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 947                         if (!port->write_urbs[j]) {
 948                                 dev_err(ddev, "No free urbs available\n");
 949                                 goto probe_error;
 950                         }
 951                         port->bulk_out_buffers[j] = kmalloc(buffer_size,
 952                                                                 GFP_KERNEL);
 953                         if (!port->bulk_out_buffers[j]) {
 954                                 dev_err(ddev, "Couldn't allocate bulk_out_buffer\n");
 955                                 goto probe_error;
 956                         }
 957                         usb_fill_bulk_urb(port->write_urbs[j], dev,
 958                                         usb_sndbulkpipe(dev,
 959                                                 endpoint->bEndpointAddress),
 960                                         port->bulk_out_buffers[j], buffer_size,
 961                                         serial->type->write_bulk_callback,
 962                                         port);
 963                 }
 964
 965                 port->write_urb = port->write_urbs[0];
 966                 port->bulk_out_buffer = port->bulk_out_buffers[0];
 967         }
 968
 969         if (serial->type->read_int_callback) {
 970                 for (i = 0; i < num_interrupt_in; ++i) {
 971                         endpoint = interrupt_in_endpoint[i];
 972                         port = serial->port[i];
 973                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 974                         if (!port->interrupt_in_urb) {
 975                                 dev_err(ddev, "No free urbs available\n");
 976                                 goto probe_error;
 977                         }
 978                         buffer_size = usb_endpoint_maxp(endpoint);
 979                         port->interrupt_in_endpointAddress =
 980                                                 endpoint->bEndpointAddress;
 981                         port->interrupt_in_buffer = kmalloc(buffer_size,
 982                                                                 GFP_KERNEL);
 983                         if (!port->interrupt_in_buffer) {
 984                                 dev_err(ddev, "Couldn't allocate interrupt_in_buffer\n");
 985                                 goto probe_error;
 986                         }
 987                         usb_fill_int_urb(port->interrupt_in_urb, dev,
 988                                 usb_rcvintpipe(dev,
 989                                                 endpoint->bEndpointAddress),
 990                                 port->interrupt_in_buffer, buffer_size,
 991                                 serial->type->read_int_callback, port,
 992                                 endpoint->bInterval);
 993                 }
 994         } else if (num_interrupt_in) {
 995                 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
 996         }
 997
 998         if (serial->type->write_int_callback) {
 999                 for (i = 0; i < num_interrupt_out; ++i) {
1000                         endpoint = interrupt_out_endpoint[i];
1001                         port = serial->port[i];
1002                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1003                         if (!port->interrupt_out_urb) {
1004                                 dev_err(ddev, "No free urbs available\n");
1005                                 goto probe_error;
1006                         }
1007                         buffer_size = usb_endpoint_maxp(endpoint);
1008                         port->interrupt_out_size = buffer_size;
1009                         port->interrupt_out_endpointAddress =
1010                                                 endpoint->bEndpointAddress;
1011                         port->interrupt_out_buffer = kmalloc(buffer_size,
1012                                                                 GFP_KERNEL);
1013                         if (!port->interrupt_out_buffer) {
1014                                 dev_err(ddev, "Couldn't allocate interrupt_out_buffer\n");
1015                                 goto probe_error;
1016                         }
1017                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1018                                 usb_sndintpipe(dev,
1019                                                   endpoint->bEndpointAddress),
1020                                 port->interrupt_out_buffer, buffer_size,
1021                                 serial->type->write_int_callback, port,
1022                                 endpoint->bInterval);
1023                 }
1024         } else if (num_interrupt_out) {
1025                 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1026         }
1027
1028         usb_set_intfdata(interface, serial);
1029
1030         /* if this device type has an attach function, call it */
1031         if (type->attach) {
1032                 retval = type->attach(serial);
1033                 if (retval < 0)
1034                         goto probe_error;
1035                 serial->attached = 1;
1036                 if (retval > 0) {
1037                         /* quietly accept this device, but don't bind to a
1038                            serial port as it's about to disappear */
1039                         serial->num_ports = 0;
1040                         goto exit;
1041                 }
1042         } else {
1043                 serial->attached = 1;
1044         }
1045
1046         /* Avoid race with tty_open and serial_install by setting the
1047          * disconnected flag and not clearing it until all ports have been
1048          * registered.
1049          */
1050         serial->disconnected = 1;
1051
1052         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1053                 dev_err(ddev, "No more free serial devices\n");
1054                 goto probe_error;
1055         }
1056         serial->minor = minor;
1057
1058         /* register all of the individual ports with the driver core */
1059         for (i = 0; i < num_ports; ++i) {
1060                 port = serial->port[i];
1061                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1062                 dev_dbg(ddev, "registering %s", dev_name(&port->dev));
1063                 device_enable_async_suspend(&port->dev);
1064
1065                 retval = device_add(&port->dev);
1066                 if (retval)
1067                         dev_err(ddev, "Error registering port device, continuing\n");
1068         }
1069
1070         serial->disconnected = 0;
1071
1072         usb_serial_console_init(minor);
1073 exit:
1074         module_put(type->driver.owner);
1075         return 0;
1076
1077 probe_error:
1078         usb_serial_put(serial);
1079         module_put(type->driver.owner);
1080         return -EIO;
1081 }
1082
1083 static void usb_serial_disconnect(struct usb_interface *interface)
1084 {
1085         int i;
1086         struct usb_serial *serial = usb_get_intfdata(interface);
1087         struct device *dev = &interface->dev;
1088         struct usb_serial_port *port;
1089
1090         usb_serial_console_disconnect(serial);
1091
1092         mutex_lock(&serial->disc_mutex);
1093         /* must set a flag, to signal subdrivers */
1094         serial->disconnected = 1;
1095         mutex_unlock(&serial->disc_mutex);
1096
1097         for (i = 0; i < serial->num_ports; ++i) {
1098                 port = serial->port[i];
1099                 if (port) {
1100                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1101                         if (tty) {
1102                                 tty_vhangup(tty);
1103                                 tty_kref_put(tty);
1104                         }
1105                         kill_traffic(port);
1106                         cancel_work_sync(&port->work);
1107                         if (device_is_registered(&port->dev))
1108                                 device_del(&port->dev);
1109                 }
1110         }
1111         serial->type->disconnect(serial);
1112
1113         /* let the last holder of this object cause it to be cleaned up */
1114         usb_serial_put(serial);
1115         dev_info(dev, "device disconnected\n");
1116 }
1117
1118 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1119 {
1120         struct usb_serial *serial = usb_get_intfdata(intf);
1121         struct usb_serial_port *port;
1122         int i, r = 0;
1123
1124         serial->suspending = 1;
1125
1126         if (serial->type->suspend) {
1127                 r = serial->type->suspend(serial, message);
1128                 if (r < 0) {
1129                         serial->suspending = 0;
1130                         goto err_out;
1131                 }
1132         }
1133
1134         for (i = 0; i < serial->num_ports; ++i) {
1135                 port = serial->port[i];
1136                 if (port)
1137                         kill_traffic(port);
1138         }
1139
1140 err_out:
1141         return r;
1142 }
1143 EXPORT_SYMBOL(usb_serial_suspend);
1144
1145 int usb_serial_resume(struct usb_interface *intf)
1146 {
1147         struct usb_serial *serial = usb_get_intfdata(intf);
1148         int rv;
1149
1150         serial->suspending = 0;
1151         if (serial->type->resume)
1152                 rv = serial->type->resume(serial);
1153         else
1154                 rv = usb_serial_generic_resume(serial);
1155
1156         return rv;
1157 }
1158 EXPORT_SYMBOL(usb_serial_resume);
1159
1160 static int usb_serial_reset_resume(struct usb_interface *intf)
1161 {
1162         struct usb_serial *serial = usb_get_intfdata(intf);
1163         int rv;
1164
1165         serial->suspending = 0;
1166         if (serial->type->reset_resume)
1167                 rv = serial->type->reset_resume(serial);
1168         else {
1169                 rv = -EOPNOTSUPP;
1170                 intf->needs_binding = 1;
1171         }
1172
1173         return rv;
1174 }
1175
1176 static const struct tty_operations serial_ops = {
1177         .open =                 serial_open,
1178         .close =                serial_close,
1179         .write =                serial_write,
1180         .hangup =               serial_hangup,
1181         .write_room =           serial_write_room,
1182         .ioctl =                serial_ioctl,
1183         .set_termios =          serial_set_termios,
1184         .throttle =             serial_throttle,
1185         .unthrottle =           serial_unthrottle,
1186         .break_ctl =            serial_break,
1187         .chars_in_buffer =      serial_chars_in_buffer,
1188         .tiocmget =             serial_tiocmget,
1189         .tiocmset =             serial_tiocmset,
1190         .get_icount =           serial_get_icount,
1191         .cleanup =              serial_cleanup,
1192         .install =              serial_install,
1193         .proc_fops =            &serial_proc_fops,
1194 };
1195
1196
1197 struct tty_driver *usb_serial_tty_driver;
1198
1199 /* Driver structure we register with the USB core */
1200 static struct usb_driver usb_serial_driver = {
1201         .name =         "usbserial",
1202         .probe =        usb_serial_probe,
1203         .disconnect =   usb_serial_disconnect,
1204         .suspend =      usb_serial_suspend,
1205         .resume =       usb_serial_resume,
1206         .no_dynamic_id =        1,
1207         .supports_autosuspend = 1,
1208 };
1209
1210 static int __init usb_serial_init(void)
1211 {
1212         int i;
1213         int result;
1214
1215         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1216         if (!usb_serial_tty_driver)
1217                 return -ENOMEM;
1218
1219         /* Initialize our global data */
1220         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1221                 serial_table[i] = NULL;
1222
1223         result = bus_register(&usb_serial_bus_type);
1224         if (result) {
1225                 pr_err("%s - registering bus driver failed\n", __func__);
1226                 goto exit_bus;
1227         }
1228
1229         usb_serial_tty_driver->driver_name = "usbserial";
1230         usb_serial_tty_driver->name = "ttyUSB";
1231         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1232         usb_serial_tty_driver->minor_start = 0;
1233         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1234         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1235         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1236                                                 TTY_DRIVER_DYNAMIC_DEV;
1237         usb_serial_tty_driver->init_termios = tty_std_termios;
1238         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1239                                                         | HUPCL | CLOCAL;
1240         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1241         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1242         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1243         result = tty_register_driver(usb_serial_tty_driver);
1244         if (result) {
1245                 pr_err("%s - tty_register_driver failed\n", __func__);
1246                 goto exit_reg_driver;
1247         }
1248
1249         /* register the USB driver */
1250         result = usb_register(&usb_serial_driver);
1251         if (result < 0) {
1252                 pr_err("%s - usb_register failed\n", __func__);
1253                 goto exit_tty;
1254         }
1255
1256         /* register the generic driver, if we should */
1257         result = usb_serial_generic_register();
1258         if (result < 0) {
1259                 pr_err("%s - registering generic driver failed\n", __func__);
1260                 goto exit_generic;
1261         }
1262
1263         return result;
1264
1265 exit_generic:
1266         usb_deregister(&usb_serial_driver);
1267
1268 exit_tty:
1269         tty_unregister_driver(usb_serial_tty_driver);
1270
1271 exit_reg_driver:
1272         bus_unregister(&usb_serial_bus_type);
1273
1274 exit_bus:
1275         pr_err("%s - returning with error %d\n", __func__, result);
1276         put_tty_driver(usb_serial_tty_driver);
1277         return result;
1278 }
1279
1280
1281 static void __exit usb_serial_exit(void)
1282 {
1283         usb_serial_console_exit();
1284
1285         usb_serial_generic_deregister();
1286
1287         usb_deregister(&usb_serial_driver);
1288         tty_unregister_driver(usb_serial_tty_driver);
1289         put_tty_driver(usb_serial_tty_driver);
1290         bus_unregister(&usb_serial_bus_type);
1291 }
1292
1293
1294 module_init(usb_serial_init);
1295 module_exit(usb_serial_exit);
1296
1297 #define set_to_generic_if_null(type, function)                          \
1298         do {                                                            \
1299                 if (!type->function) {                                  \
1300                         type->function = usb_serial_generic_##function; \
1301                         pr_debug("Had to override the " #function       \
1302                                 " usb serial operation with the generic one.");\
1303                         }                                               \
1304         } while (0)
1305
1306 static void fixup_generic(struct usb_serial_driver *device)
1307 {
1308         set_to_generic_if_null(device, open);
1309         set_to_generic_if_null(device, write);
1310         set_to_generic_if_null(device, close);
1311         set_to_generic_if_null(device, write_room);
1312         set_to_generic_if_null(device, chars_in_buffer);
1313         set_to_generic_if_null(device, read_bulk_callback);
1314         set_to_generic_if_null(device, write_bulk_callback);
1315         set_to_generic_if_null(device, disconnect);
1316         set_to_generic_if_null(device, release);
1317         set_to_generic_if_null(device, process_read_urb);
1318         set_to_generic_if_null(device, prepare_write_buffer);
1319 }
1320
1321 static int usb_serial_register(struct usb_serial_driver *driver)
1322 {
1323         int retval;
1324
1325         if (usb_disabled())
1326                 return -ENODEV;
1327
1328         fixup_generic(driver);
1329
1330         if (!driver->description)
1331                 driver->description = driver->driver.name;
1332         if (!driver->usb_driver) {
1333                 WARN(1, "Serial driver %s has no usb_driver\n",
1334                                 driver->description);
1335                 return -EINVAL;
1336         }
1337
1338         /* Add this device to our list of devices */
1339         mutex_lock(&table_lock);
1340         list_add(&driver->driver_list, &usb_serial_driver_list);
1341
1342         retval = usb_serial_bus_register(driver);
1343         if (retval) {
1344                 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1345                 list_del(&driver->driver_list);
1346         } else
1347                 pr_info("USB Serial support registered for %s\n", driver->description);
1348
1349         mutex_unlock(&table_lock);
1350         return retval;
1351 }
1352
1353 static void usb_serial_deregister(struct usb_serial_driver *device)
1354 {
1355         pr_info("USB Serial deregistering driver %s\n", device->description);
1356         mutex_lock(&table_lock);
1357         list_del(&device->driver_list);
1358         usb_serial_bus_deregister(device);
1359         mutex_unlock(&table_lock);
1360 }
1361
1362 /**
1363  * usb_serial_register_drivers - register drivers for a usb-serial module
1364  * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1365  * @name: name of the usb_driver for this set of @serial_drivers
1366  * @id_table: list of all devices this @serial_drivers set binds to
1367  *
1368  * Registers all the drivers in the @serial_drivers array, and dynamically
1369  * creates a struct usb_driver with the name @name and id_table of @id_table.
1370  */
1371 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1372                                 const char *name,
1373                                 const struct usb_device_id *id_table)
1374 {
1375         int rc;
1376         struct usb_driver *udriver;
1377         struct usb_serial_driver * const *sd;
1378
1379         /*
1380          * udriver must be registered before any of the serial drivers,
1381          * because the store_new_id() routine for the serial drivers (in
1382          * bus.c) probes udriver.
1383          *
1384          * Performance hack: We don't want udriver to be probed until
1385          * the serial drivers are registered, because the probe would
1386          * simply fail for lack of a matching serial driver.
1387          * So we leave udriver's id_table set to NULL until we are all set.
1388          *
1389          * Suspend/resume support is implemented in the usb-serial core,
1390          * so fill in the PM-related fields in udriver.
1391          */
1392         udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1393         if (!udriver)
1394                 return -ENOMEM;
1395
1396         udriver->name = name;
1397         udriver->no_dynamic_id = 1;
1398         udriver->supports_autosuspend = 1;
1399         udriver->suspend = usb_serial_suspend;
1400         udriver->resume = usb_serial_resume;
1401         udriver->probe = usb_serial_probe;
1402         udriver->disconnect = usb_serial_disconnect;
1403
1404         /* we only set the reset_resume field if the serial_driver has one */
1405         for (sd = serial_drivers; *sd; ++sd) {
1406                 if ((*sd)->reset_resume) {
1407                         udriver->reset_resume = usb_serial_reset_resume;
1408                         break;
1409                 }
1410         }
1411
1412         rc = usb_register(udriver);
1413         if (rc)
1414                 return rc;
1415
1416         for (sd = serial_drivers; *sd; ++sd) {
1417                 (*sd)->usb_driver = udriver;
1418                 rc = usb_serial_register(*sd);
1419                 if (rc)
1420                         goto failed;
1421         }
1422
1423         /* Now set udriver's id_table and look for matches */
1424         udriver->id_table = id_table;
1425         rc = driver_attach(&udriver->drvwrap.driver);
1426         return 0;
1427
1428  failed:
1429         while (sd-- > serial_drivers)
1430                 usb_serial_deregister(*sd);
1431         usb_deregister(udriver);
1432         return rc;
1433 }
1434 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1435
1436 /**
1437  * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1438  * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1439  *
1440  * Deregisters all the drivers in the @serial_drivers array and deregisters and
1441  * frees the struct usb_driver that was created by the call to
1442  * usb_serial_register_drivers().
1443  */
1444 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1445 {
1446         struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1447
1448         for (; *serial_drivers; ++serial_drivers)
1449                 usb_serial_deregister(*serial_drivers);
1450         usb_deregister(udriver);
1451         kfree(udriver);
1452 }
1453 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1454
1455 /* Module information */
1456 MODULE_AUTHOR(DRIVER_AUTHOR);
1457 MODULE_DESCRIPTION(DRIVER_DESC);
1458 MODULE_LICENSE("GPL");