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