drivers/usb/serial/usb-serial.c

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