drivers/usb/serial/usb-serial.c

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