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