drivers/usb/serial/usb-serial.c

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