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_release().
 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_release - 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 when the last tty kref is dropped.
 349  */
 350 static void serial_release(struct tty_struct *tty)
 351 {
 352         struct usb_serial_port *port = tty->driver_data;
 353         struct usb_serial *serial;
 354         struct module *owner;
 355
 356         /* The console is magical.  Do not hang up the console hardware
 357          * or there will be tears.
 358          */
 359         if (port->console)
 360                 return;
 361
 362         dbg("%s - port %d", __func__, port->number);
 363
 364         /* Standard shutdown processing */
 365         tty_shutdown(tty);
 366
 367         tty->driver_data = NULL;
 368
 369         serial = port->serial;
 370         owner = serial->type->driver.owner;
 371
 372         mutex_lock(&serial->disc_mutex);
 373         if (!serial->disconnected)
 374                 usb_autopm_put_interface(serial->interface);
 375         mutex_unlock(&serial->disc_mutex);
 376
 377         usb_serial_put(serial);
 378         module_put(owner);
 379 }
 380
 381 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 382                                                                 int count)
 383 {
 384         struct usb_serial_port *port = tty->driver_data;
 385         int retval = -ENODEV;
 386
 387         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 388                 goto exit;
 389
 390         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 391
 392         /* count is managed under the mutex lock for the tty so cannot
 393            drop to zero until after the last close completes */
 394         WARN_ON(!port->port.count);
 395
 396         /* pass on to the driver specific version of this function */
 397         retval = port->serial->type->write(tty, port, buf, count);
 398
 399 exit:
 400         return retval;
 401 }
 402
 403 static int serial_write_room(struct tty_struct *tty)
 404 {
 405         struct usb_serial_port *port = tty->driver_data;
 406         dbg("%s - port %d", __func__, port->number);
 407         WARN_ON(!port->port.count);
 408         /* pass on to the driver specific version of this function */
 409         return port->serial->type->write_room(tty);
 410 }
 411
 412 static int serial_chars_in_buffer(struct tty_struct *tty)
 413 {
 414         struct usb_serial_port *port = tty->driver_data;
 415         dbg("%s = port %d", __func__, port->number);
 416
 417         /* if the device was unplugged then any remaining characters
 418            fell out of the connector ;) */
 419         if (port->serial->disconnected)
 420                 return 0;
 421         /* pass on to the driver specific version of this function */
 422         return port->serial->type->chars_in_buffer(tty);
 423 }
 424
 425 static void serial_throttle(struct tty_struct *tty)
 426 {
 427         struct usb_serial_port *port = tty->driver_data;
 428         dbg("%s - port %d", __func__, port->number);
 429
 430         WARN_ON(!port->port.count);
 431         /* pass on to the driver specific version of this function */
 432         if (port->serial->type->throttle)
 433                 port->serial->type->throttle(tty);
 434 }
 435
 436 static void serial_unthrottle(struct tty_struct *tty)
 437 {
 438         struct usb_serial_port *port = tty->driver_data;
 439         dbg("%s - port %d", __func__, port->number);
 440
 441         WARN_ON(!port->port.count);
 442         /* pass on to the driver specific version of this function */
 443         if (port->serial->type->unthrottle)
 444                 port->serial->type->unthrottle(tty);
 445 }
 446
 447 static int serial_ioctl(struct tty_struct *tty, struct file *file,
 448                                         unsigned int cmd, unsigned long arg)
 449 {
 450         struct usb_serial_port *port = tty->driver_data;
 451         int retval = -ENODEV;
 452
 453         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 454
 455         WARN_ON(!port->port.count);
 456
 457         /* pass on to the driver specific version of this function
 458            if it is available */
 459         if (port->serial->type->ioctl) {
 460                 retval = port->serial->type->ioctl(tty, file, cmd, arg);
 461         } else
 462                 retval = -ENOIOCTLCMD;
 463         return retval;
 464 }
 465
 466 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 467 {
 468         struct usb_serial_port *port = tty->driver_data;
 469         dbg("%s - port %d", __func__, port->number);
 470
 471         WARN_ON(!port->port.count);
 472         /* pass on to the driver specific version of this function
 473            if it is available */
 474         if (port->serial->type->set_termios)
 475                 port->serial->type->set_termios(tty, port, old);
 476         else
 477                 tty_termios_copy_hw(tty->termios, old);
 478 }
 479
 480 static int serial_break(struct tty_struct *tty, int break_state)
 481 {
 482         struct usb_serial_port *port = tty->driver_data;
 483
 484         dbg("%s - port %d", __func__, port->number);
 485
 486         WARN_ON(!port->port.count);
 487         /* pass on to the driver specific version of this function
 488            if it is available */
 489         if (port->serial->type->break_ctl)
 490                 port->serial->type->break_ctl(tty, break_state);
 491         return 0;
 492 }
 493
 494 static int serial_proc_show(struct seq_file *m, void *v)
 495 {
 496         struct usb_serial *serial;
 497         int i;
 498         char tmp[40];
 499
 500         dbg("%s", __func__);
 501         seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 502         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 503                 serial = usb_serial_get_by_index(i);
 504                 if (serial == NULL)
 505                         continue;
 506
 507                 seq_printf(m, "%d:", i);
 508                 if (serial->type->driver.owner)
 509                         seq_printf(m, " module:%s",
 510                                 module_name(serial->type->driver.owner));
 511                 seq_printf(m, " name:\"%s\"",
 512                                 serial->type->description);
 513                 seq_printf(m, " vendor:%04x product:%04x",
 514                         le16_to_cpu(serial->dev->descriptor.idVendor),
 515                         le16_to_cpu(serial->dev->descriptor.idProduct));
 516                 seq_printf(m, " num_ports:%d", serial->num_ports);
 517                 seq_printf(m, " port:%d", i - serial->minor + 1);
 518                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 519                 seq_printf(m, " path:%s", tmp);
 520
 521                 seq_putc(m, '\n');
 522                 usb_serial_put(serial);
 523                 mutex_unlock(&serial->disc_mutex);
 524         }
 525         return 0;
 526 }
 527
 528 static int serial_proc_open(struct inode *inode, struct file *file)
 529 {
 530         return single_open(file, serial_proc_show, NULL);
 531 }
 532
 533 static const struct file_operations serial_proc_fops = {
 534         .owner          = THIS_MODULE,
 535         .open           = serial_proc_open,
 536         .read           = seq_read,
 537         .llseek         = seq_lseek,
 538         .release        = single_release,
 539 };
 540
 541 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 542 {
 543         struct usb_serial_port *port = tty->driver_data;
 544
 545         dbg("%s - port %d", __func__, port->number);
 546
 547         WARN_ON(!port->port.count);
 548         if (port->serial->type->tiocmget)
 549                 return port->serial->type->tiocmget(tty, file);
 550         return -EINVAL;
 551 }
 552
 553 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 554                             unsigned int set, unsigned int clear)
 555 {
 556         struct usb_serial_port *port = tty->driver_data;
 557
 558         dbg("%s - port %d", __func__, port->number);
 559
 560         WARN_ON(!port->port.count);
 561         if (port->serial->type->tiocmset)
 562                 return port->serial->type->tiocmset(tty, file, set, clear);
 563         return -EINVAL;
 564 }
 565
 566 /*
 567  * We would be calling tty_wakeup here, but unfortunately some line
 568  * disciplines have an annoying habit of calling tty->write from
 569  * the write wakeup callback (e.g. n_hdlc.c).
 570  */
 571 void usb_serial_port_softint(struct usb_serial_port *port)
 572 {
 573         schedule_work(&port->work);
 574 }
 575 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 576
 577 static void usb_serial_port_work(struct work_struct *work)
 578 {
 579         struct usb_serial_port *port =
 580                 container_of(work, struct usb_serial_port, work);
 581         struct tty_struct *tty;
 582
 583         dbg("%s - port %d", __func__, port->number);
 584
 585         tty = tty_port_tty_get(&port->port);
 586         if (!tty)
 587                 return;
 588
 589         tty_wakeup(tty);
 590         tty_kref_put(tty);
 591 }
 592
 593 static void kill_traffic(struct usb_serial_port *port)
 594 {
 595         usb_kill_urb(port->read_urb);
 596         usb_kill_urb(port->write_urb);
 597         /*
 598          * This is tricky.
 599          * Some drivers submit the read_urb in the
 600          * handler for the write_urb or vice versa
 601          * this order determines the order in which
 602          * usb_kill_urb() must be used to reliably
 603          * kill the URBs. As it is unknown here,
 604          * both orders must be used in turn.
 605          * The call below is not redundant.
 606          */
 607         usb_kill_urb(port->read_urb);
 608         usb_kill_urb(port->interrupt_in_urb);
 609         usb_kill_urb(port->interrupt_out_urb);
 610 }
 611
 612 static void port_release(struct device *dev)
 613 {
 614         struct usb_serial_port *port = to_usb_serial_port(dev);
 615
 616         dbg ("%s - %s", __func__, dev_name(dev));
 617
 618         /*
 619          * Stop all the traffic before cancelling the work, so that
 620          * nobody will restart it by calling usb_serial_port_softint.
 621          */
 622         kill_traffic(port);
 623         cancel_work_sync(&port->work);
 624
 625         usb_free_urb(port->read_urb);
 626         usb_free_urb(port->write_urb);
 627         usb_free_urb(port->interrupt_in_urb);
 628         usb_free_urb(port->interrupt_out_urb);
 629         if (!IS_ERR(port->write_fifo) && port->write_fifo)
 630                 kfifo_free(port->write_fifo);
 631         kfree(port->bulk_in_buffer);
 632         kfree(port->bulk_out_buffer);
 633         kfree(port->interrupt_in_buffer);
 634         kfree(port->interrupt_out_buffer);
 635         kfree(port);
 636 }
 637
 638 static struct usb_serial *create_serial(struct usb_device *dev,
 639                                         struct usb_interface *interface,
 640                                         struct usb_serial_driver *driver)
 641 {
 642         struct usb_serial *serial;
 643
 644         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 645         if (!serial) {
 646                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
 647                 return NULL;
 648         }
 649         serial->dev = usb_get_dev(dev);
 650         serial->type = driver;
 651         serial->interface = interface;
 652         kref_init(&serial->kref);
 653         mutex_init(&serial->disc_mutex);
 654         serial->minor = SERIAL_TTY_NO_MINOR;
 655
 656         return serial;
 657 }
 658
 659 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 660                                             struct usb_serial_driver *drv)
 661 {
 662         struct usb_dynid *dynid;
 663
 664         spin_lock(&drv->dynids.lock);
 665         list_for_each_entry(dynid, &drv->dynids.list, node) {
 666                 if (usb_match_one_id(intf, &dynid->id)) {
 667                         spin_unlock(&drv->dynids.lock);
 668                         return &dynid->id;
 669                 }
 670         }
 671         spin_unlock(&drv->dynids.lock);
 672         return NULL;
 673 }
 674
 675 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 676                                                 struct usb_interface *intf)
 677 {
 678         const struct usb_device_id *id;
 679
 680         id = usb_match_id(intf, drv->id_table);
 681         if (id) {
 682                 dbg("static descriptor matches");
 683                 goto exit;
 684         }
 685         id = match_dynamic_id(intf, drv);
 686         if (id)
 687                 dbg("dynamic descriptor matches");
 688 exit:
 689         return id;
 690 }
 691
 692 static struct usb_serial_driver *search_serial_device(
 693                                         struct usb_interface *iface)
 694 {
 695         const struct usb_device_id *id;
 696         struct usb_serial_driver *drv;
 697
 698         /* Check if the usb id matches a known device */
 699         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 700                 id = get_iface_id(drv, iface);
 701                 if (id)
 702                         return drv;
 703         }
 704
 705         return NULL;
 706 }
 707
 708 static int serial_carrier_raised(struct tty_port *port)
 709 {
 710         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 711         struct usb_serial_driver *drv = p->serial->type;
 712         if (drv->carrier_raised)
 713                 return drv->carrier_raised(p);
 714         /* No carrier control - don't block */
 715         return 1;
 716 }
 717
 718 static void serial_dtr_rts(struct tty_port *port, int on)
 719 {
 720         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 721         struct usb_serial_driver *drv = p->serial->type;
 722         if (drv->dtr_rts)
 723                 drv->dtr_rts(p, on);
 724 }
 725
 726 static const struct tty_port_operations serial_port_ops = {
 727         .carrier_raised = serial_carrier_raised,
 728         .dtr_rts = serial_dtr_rts,
 729 };
 730
 731 int usb_serial_probe(struct usb_interface *interface,
 732                                const struct usb_device_id *id)
 733 {
 734         struct usb_device *dev = interface_to_usbdev(interface);
 735         struct usb_serial *serial = NULL;
 736         struct usb_serial_port *port;
 737         struct usb_host_interface *iface_desc;
 738         struct usb_endpoint_descriptor *endpoint;
 739         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 740         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 741         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 742         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 743         struct usb_serial_driver *type = NULL;
 744         int retval;
 745         unsigned int minor;
 746         int buffer_size;
 747         int i;
 748         int num_interrupt_in = 0;
 749         int num_interrupt_out = 0;
 750         int num_bulk_in = 0;
 751         int num_bulk_out = 0;
 752         int num_ports = 0;
 753         int max_endpoints;
 754
 755         lock_kernel(); /* guard against unloading a serial driver module */
 756         type = search_serial_device(interface);
 757         if (!type) {
 758                 unlock_kernel();
 759                 dbg("none matched");
 760                 return -ENODEV;
 761         }
 762
 763         serial = create_serial(dev, interface, type);
 764         if (!serial) {
 765                 unlock_kernel();
 766                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
 767                 return -ENOMEM;
 768         }
 769
 770         /* if this device type has a probe function, call it */
 771         if (type->probe) {
 772                 const struct usb_device_id *id;
 773
 774                 if (!try_module_get(type->driver.owner)) {
 775                         unlock_kernel();
 776                         dev_err(&interface->dev,
 777                                 "module get failed, exiting\n");
 778                         kfree(serial);
 779                         return -EIO;
 780                 }
 781
 782                 id = get_iface_id(type, interface);
 783                 retval = type->probe(serial, id);
 784                 module_put(type->driver.owner);
 785
 786                 if (retval) {
 787                         unlock_kernel();
 788                         dbg("sub driver rejected device");
 789                         kfree(serial);
 790                         return retval;
 791                 }
 792         }
 793
 794         /* descriptor matches, let's find the endpoints needed */
 795         /* check out the endpoints */
 796         iface_desc = interface->cur_altsetting;
 797         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 798                 endpoint = &iface_desc->endpoint[i].desc;
 799
 800                 if (usb_endpoint_is_bulk_in(endpoint)) {
 801                         /* we found a bulk in endpoint */
 802                         dbg("found bulk in on endpoint %d", i);
 803                         bulk_in_endpoint[num_bulk_in] = endpoint;
 804                         ++num_bulk_in;
 805                 }
 806
 807                 if (usb_endpoint_is_bulk_out(endpoint)) {
 808                         /* we found a bulk out endpoint */
 809                         dbg("found bulk out on endpoint %d", i);
 810                         bulk_out_endpoint[num_bulk_out] = endpoint;
 811                         ++num_bulk_out;
 812                 }
 813
 814                 if (usb_endpoint_is_int_in(endpoint)) {
 815                         /* we found a interrupt in endpoint */
 816                         dbg("found interrupt in on endpoint %d", i);
 817                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 818                         ++num_interrupt_in;
 819                 }
 820
 821                 if (usb_endpoint_is_int_out(endpoint)) {
 822                         /* we found an interrupt out endpoint */
 823                         dbg("found interrupt out on endpoint %d", i);
 824                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 825                         ++num_interrupt_out;
 826                 }
 827         }
 828
 829 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 830         /* BEGIN HORRIBLE HACK FOR PL2303 */
 831         /* this is needed due to the looney way its endpoints are set up */
 832         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 833              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 834             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 835              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 836             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 837              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 838             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 839              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 840                 if (interface != dev->actconfig->interface[0]) {
 841                         /* check out the endpoints of the other interface*/
 842                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 843                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 844                                 endpoint = &iface_desc->endpoint[i].desc;
 845                                 if (usb_endpoint_is_int_in(endpoint)) {
 846                                         /* we found a interrupt in endpoint */
 847                                         dbg("found interrupt in for Prolific device on separate interface");
 848                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 849                                         ++num_interrupt_in;
 850                                 }
 851                         }
 852                 }
 853
 854                 /* Now make sure the PL-2303 is configured correctly.
 855                  * If not, give up now and hope this hack will work
 856                  * properly during a later invocation of usb_serial_probe
 857                  */
 858                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 859                         unlock_kernel();
 860                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 861                         kfree(serial);
 862                         return -ENODEV;
 863                 }
 864         }
 865         /* END HORRIBLE HACK FOR PL2303 */
 866 #endif
 867
 868 #ifdef CONFIG_USB_SERIAL_GENERIC
 869         if (type == &usb_serial_generic_device) {
 870                 num_ports = num_bulk_out;
 871                 if (num_ports == 0) {
 872                         unlock_kernel();
 873                         dev_err(&interface->dev,
 874                             "Generic device with no bulk out, not allowed.\n");
 875                         kfree(serial);
 876                         return -EIO;
 877                 }
 878         }
 879 #endif
 880         if (!num_ports) {
 881                 /* if this device type has a calc_num_ports function, call it */
 882                 if (type->calc_num_ports) {
 883                         if (!try_module_get(type->driver.owner)) {
 884                                 unlock_kernel();
 885                                 dev_err(&interface->dev,
 886                                         "module get failed, exiting\n");
 887                                 kfree(serial);
 888                                 return -EIO;
 889                         }
 890                         num_ports = type->calc_num_ports(serial);
 891                         module_put(type->driver.owner);
 892                 }
 893                 if (!num_ports)
 894                         num_ports = type->num_ports;
 895         }
 896
 897         serial->num_ports = num_ports;
 898         serial->num_bulk_in = num_bulk_in;
 899         serial->num_bulk_out = num_bulk_out;
 900         serial->num_interrupt_in = num_interrupt_in;
 901         serial->num_interrupt_out = num_interrupt_out;
 902
 903         /* found all that we need */
 904         dev_info(&interface->dev, "%s converter detected\n",
 905                         type->description);
 906
 907         /* create our ports, we need as many as the max endpoints */
 908         /* we don't use num_ports here because some devices have more
 909            endpoint pairs than ports */
 910         max_endpoints = max(num_bulk_in, num_bulk_out);
 911         max_endpoints = max(max_endpoints, num_interrupt_in);
 912         max_endpoints = max(max_endpoints, num_interrupt_out);
 913         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 914         serial->num_port_pointers = max_endpoints;
 915         unlock_kernel();
 916
 917         dbg("%s - setting up %d port structures for this device",
 918                                                 __func__, max_endpoints);
 919         for (i = 0; i < max_endpoints; ++i) {
 920                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 921                 if (!port)
 922                         goto probe_error;
 923                 tty_port_init(&port->port);
 924                 port->port.ops = &serial_port_ops;
 925                 port->serial = serial;
 926                 spin_lock_init(&port->lock);
 927                 mutex_init(&port->mutex);
 928                 INIT_WORK(&port->work, usb_serial_port_work);
 929                 serial->port[i] = port;
 930                 port->dev.parent = &interface->dev;
 931                 port->dev.driver = NULL;
 932                 port->dev.bus = &usb_serial_bus_type;
 933                 port->dev.release = &port_release;
 934                 device_initialize(&port->dev);
 935         }
 936
 937         /* set up the endpoint information */
 938         for (i = 0; i < num_bulk_in; ++i) {
 939                 endpoint = bulk_in_endpoint[i];
 940                 port = serial->port[i];
 941                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 942                 if (!port->read_urb) {
 943                         dev_err(&interface->dev, "No free urbs available\n");
 944                         goto probe_error;
 945                 }
 946                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 947                 port->bulk_in_size = buffer_size;
 948                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 949                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 950                 if (!port->bulk_in_buffer) {
 951                         dev_err(&interface->dev,
 952                                         "Couldn't allocate bulk_in_buffer\n");
 953                         goto probe_error;
 954                 }
 955                 usb_fill_bulk_urb(port->read_urb, dev,
 956                                 usb_rcvbulkpipe(dev,
 957                                                 endpoint->bEndpointAddress),
 958                                 port->bulk_in_buffer, buffer_size,
 959                                 serial->type->read_bulk_callback, port);
 960         }
 961
 962         for (i = 0; i < num_bulk_out; ++i) {
 963                 endpoint = bulk_out_endpoint[i];
 964                 port = serial->port[i];
 965                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 966                 if (!port->write_urb) {
 967                         dev_err(&interface->dev, "No free urbs available\n");
 968                         goto probe_error;
 969                 }
 970                 port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
 971                         &port->lock);
 972                 if (IS_ERR(port->write_fifo))
 973                         goto probe_error;
 974                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 975                 port->bulk_out_size = buffer_size;
 976                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 977                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 978                 if (!port->bulk_out_buffer) {
 979                         dev_err(&interface->dev,
 980                                         "Couldn't allocate bulk_out_buffer\n");
 981                         goto probe_error;
 982                 }
 983                 usb_fill_bulk_urb(port->write_urb, dev,
 984                                 usb_sndbulkpipe(dev,
 985                                         endpoint->bEndpointAddress),
 986                                 port->bulk_out_buffer, buffer_size,
 987                                 serial->type->write_bulk_callback, port);
 988         }
 989
 990         if (serial->type->read_int_callback) {
 991                 for (i = 0; i < num_interrupt_in; ++i) {
 992                         endpoint = interrupt_in_endpoint[i];
 993                         port = serial->port[i];
 994                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 995                         if (!port->interrupt_in_urb) {
 996                                 dev_err(&interface->dev,
 997                                                 "No free urbs available\n");
 998                                 goto probe_error;
 999                         }
1000                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1001                         port->interrupt_in_endpointAddress =
1002                                                 endpoint->bEndpointAddress;
1003                         port->interrupt_in_buffer = kmalloc(buffer_size,
1004                                                                 GFP_KERNEL);
1005                         if (!port->interrupt_in_buffer) {
1006                                 dev_err(&interface->dev,
1007                                     "Couldn't allocate interrupt_in_buffer\n");
1008                                 goto probe_error;
1009                         }
1010                         usb_fill_int_urb(port->interrupt_in_urb, dev,
1011                                 usb_rcvintpipe(dev,
1012                                                 endpoint->bEndpointAddress),
1013                                 port->interrupt_in_buffer, buffer_size,
1014                                 serial->type->read_int_callback, port,
1015                                 endpoint->bInterval);
1016                 }
1017         } else if (num_interrupt_in) {
1018                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1019         }
1020
1021         if (serial->type->write_int_callback) {
1022                 for (i = 0; i < num_interrupt_out; ++i) {
1023                         endpoint = interrupt_out_endpoint[i];
1024                         port = serial->port[i];
1025                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1026                         if (!port->interrupt_out_urb) {
1027                                 dev_err(&interface->dev,
1028                                                 "No free urbs available\n");
1029                                 goto probe_error;
1030                         }
1031                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1032                         port->interrupt_out_size = buffer_size;
1033                         port->interrupt_out_endpointAddress =
1034                                                 endpoint->bEndpointAddress;
1035                         port->interrupt_out_buffer = kmalloc(buffer_size,
1036                                                                 GFP_KERNEL);
1037                         if (!port->interrupt_out_buffer) {
1038                                 dev_err(&interface->dev,
1039                                   "Couldn't allocate interrupt_out_buffer\n");
1040                                 goto probe_error;
1041                         }
1042                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1043                                 usb_sndintpipe(dev,
1044                                                   endpoint->bEndpointAddress),
1045                                 port->interrupt_out_buffer, buffer_size,
1046                                 serial->type->write_int_callback, port,
1047                                 endpoint->bInterval);
1048                 }
1049         } else if (num_interrupt_out) {
1050                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1051         }
1052
1053         /* if this device type has an attach function, call it */
1054         if (type->attach) {
1055                 if (!try_module_get(type->driver.owner)) {
1056                         dev_err(&interface->dev,
1057                                         "module get failed, exiting\n");
1058                         goto probe_error;
1059                 }
1060                 retval = type->attach(serial);
1061                 module_put(type->driver.owner);
1062                 if (retval < 0)
1063                         goto probe_error;
1064                 if (retval > 0) {
1065                         /* quietly accept this device, but don't bind to a
1066                            serial port as it's about to disappear */
1067                         serial->num_ports = 0;
1068                         goto exit;
1069                 }
1070         }
1071
1072         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1073                 dev_err(&interface->dev, "No more free serial devices\n");
1074                 goto probe_error;
1075         }
1076         serial->minor = minor;
1077
1078         /* register all of the individual ports with the driver core */
1079         for (i = 0; i < num_ports; ++i) {
1080                 port = serial->port[i];
1081                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1082                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1083                 port->dev_state = PORT_REGISTERING;
1084                 retval = device_add(&port->dev);
1085                 if (retval) {
1086                         dev_err(&port->dev, "Error registering port device, "
1087                                 "continuing\n");
1088                         port->dev_state = PORT_UNREGISTERED;
1089                 } else {
1090                         port->dev_state = PORT_REGISTERED;
1091                 }
1092         }
1093
1094         usb_serial_console_init(debug, minor);
1095
1096 exit:
1097         /* success */
1098         usb_set_intfdata(interface, serial);
1099         return 0;
1100
1101 probe_error:
1102         usb_serial_put(serial);
1103         return -EIO;
1104 }
1105 EXPORT_SYMBOL_GPL(usb_serial_probe);
1106
1107 void usb_serial_disconnect(struct usb_interface *interface)
1108 {
1109         int i;
1110         struct usb_serial *serial = usb_get_intfdata(interface);
1111         struct device *dev = &interface->dev;
1112         struct usb_serial_port *port;
1113
1114         usb_serial_console_disconnect(serial);
1115         dbg("%s", __func__);
1116
1117         mutex_lock(&serial->disc_mutex);
1118         usb_set_intfdata(interface, NULL);
1119         /* must set a flag, to signal subdrivers */
1120         serial->disconnected = 1;
1121         mutex_unlock(&serial->disc_mutex);
1122
1123         for (i = 0; i < serial->num_ports; ++i) {
1124                 port = serial->port[i];
1125                 if (port) {
1126                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1127                         if (tty) {
1128                                 tty_vhangup(tty);
1129                                 tty_kref_put(tty);
1130                         }
1131                         kill_traffic(port);
1132                         cancel_work_sync(&port->work);
1133                         if (port->dev_state == PORT_REGISTERED) {
1134
1135                                 /* Make sure the port is bound so that the
1136                                  * driver's port_remove method is called.
1137                                  */
1138                                 if (!port->dev.driver) {
1139                                         int rc;
1140
1141                                         port->dev.driver =
1142                                                         &serial->type->driver;
1143                                         rc = device_bind_driver(&port->dev);
1144                                 }
1145                                 port->dev_state = PORT_UNREGISTERING;
1146                                 device_del(&port->dev);
1147                                 port->dev_state = PORT_UNREGISTERED;
1148                         }
1149                 }
1150         }
1151         serial->type->disconnect(serial);
1152
1153         /* let the last holder of this object cause it to be cleaned up */
1154         usb_serial_put(serial);
1155         dev_info(dev, "device disconnected\n");
1156 }
1157 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1158
1159 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1160 {
1161         struct usb_serial *serial = usb_get_intfdata(intf);
1162         struct usb_serial_port *port;
1163         int i, r = 0;
1164
1165         serial->suspending = 1;
1166
1167         if (serial->type->suspend) {
1168                 r = serial->type->suspend(serial, message);
1169                 if (r < 0)
1170                         goto err_out;
1171         }
1172
1173         for (i = 0; i < serial->num_ports; ++i) {
1174                 port = serial->port[i];
1175                 if (port)
1176                         kill_traffic(port);
1177         }
1178
1179 err_out:
1180         return r;
1181 }
1182 EXPORT_SYMBOL(usb_serial_suspend);
1183
1184 int usb_serial_resume(struct usb_interface *intf)
1185 {
1186         struct usb_serial *serial = usb_get_intfdata(intf);
1187         int rv;
1188
1189         serial->suspending = 0;
1190         if (serial->type->resume)
1191                 rv = serial->type->resume(serial);
1192         else
1193                 rv = usb_serial_generic_resume(serial);
1194
1195         return rv;
1196 }
1197 EXPORT_SYMBOL(usb_serial_resume);
1198
1199 static const struct tty_operations serial_ops = {
1200         .open =                 serial_open,
1201         .close =                serial_close,
1202         .write =                serial_write,
1203         .hangup =               serial_hangup,
1204         .write_room =           serial_write_room,
1205         .ioctl =                serial_ioctl,
1206         .set_termios =          serial_set_termios,
1207         .throttle =             serial_throttle,
1208         .unthrottle =           serial_unthrottle,
1209         .break_ctl =            serial_break,
1210         .chars_in_buffer =      serial_chars_in_buffer,
1211         .tiocmget =             serial_tiocmget,
1212         .tiocmset =             serial_tiocmset,
1213         .shutdown =             serial_release,
1214         .install =              serial_install,
1215         .proc_fops =            &serial_proc_fops,
1216 };
1217
1218
1219 struct tty_driver *usb_serial_tty_driver;
1220
1221 static int __init usb_serial_init(void)
1222 {
1223         int i;
1224         int result;
1225
1226         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1227         if (!usb_serial_tty_driver)
1228                 return -ENOMEM;
1229
1230         /* Initialize our global data */
1231         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1232                 serial_table[i] = NULL;
1233
1234         result = bus_register(&usb_serial_bus_type);
1235         if (result) {
1236                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1237                        "failed\n", __func__);
1238                 goto exit_bus;
1239         }
1240
1241         usb_serial_tty_driver->owner = THIS_MODULE;
1242         usb_serial_tty_driver->driver_name = "usbserial";
1243         usb_serial_tty_driver->name =   "ttyUSB";
1244         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1245         usb_serial_tty_driver->minor_start = 0;
1246         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1247         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1248         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1249                                                 TTY_DRIVER_DYNAMIC_DEV;
1250         usb_serial_tty_driver->init_termios = tty_std_termios;
1251         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1252                                                         | HUPCL | CLOCAL;
1253         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1254         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1255         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1256         result = tty_register_driver(usb_serial_tty_driver);
1257         if (result) {
1258                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1259                        __func__);
1260                 goto exit_reg_driver;
1261         }
1262
1263         /* register the USB driver */
1264         result = usb_register(&usb_serial_driver);
1265         if (result < 0) {
1266                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1267                        __func__);
1268                 goto exit_tty;
1269         }
1270
1271         /* register the generic driver, if we should */
1272         result = usb_serial_generic_register(debug);
1273         if (result < 0) {
1274                 printk(KERN_ERR "usb-serial: %s - registering generic "
1275                        "driver failed\n", __func__);
1276                 goto exit_generic;
1277         }
1278
1279         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1280
1281         return result;
1282
1283 exit_generic:
1284         usb_deregister(&usb_serial_driver);
1285
1286 exit_tty:
1287         tty_unregister_driver(usb_serial_tty_driver);
1288
1289 exit_reg_driver:
1290         bus_unregister(&usb_serial_bus_type);
1291
1292 exit_bus:
1293         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1294                __func__, result);
1295         put_tty_driver(usb_serial_tty_driver);
1296         return result;
1297 }
1298
1299
1300 static void __exit usb_serial_exit(void)
1301 {
1302         usb_serial_console_exit();
1303
1304         usb_serial_generic_deregister();
1305
1306         usb_deregister(&usb_serial_driver);
1307         tty_unregister_driver(usb_serial_tty_driver);
1308         put_tty_driver(usb_serial_tty_driver);
1309         bus_unregister(&usb_serial_bus_type);
1310 }
1311
1312
1313 module_init(usb_serial_init);
1314 module_exit(usb_serial_exit);
1315
1316 #define set_to_generic_if_null(type, function)                          \
1317         do {                                                            \
1318                 if (!type->function) {                                  \
1319                         type->function = usb_serial_generic_##function; \
1320                         dbg("Had to override the " #function            \
1321                                 " usb serial operation with the generic one.");\
1322                         }                                               \
1323         } while (0)
1324
1325 static void fixup_generic(struct usb_serial_driver *device)
1326 {
1327         set_to_generic_if_null(device, open);
1328         set_to_generic_if_null(device, write);
1329         set_to_generic_if_null(device, close);
1330         set_to_generic_if_null(device, write_room);
1331         set_to_generic_if_null(device, chars_in_buffer);
1332         set_to_generic_if_null(device, read_bulk_callback);
1333         set_to_generic_if_null(device, write_bulk_callback);
1334         set_to_generic_if_null(device, disconnect);
1335         set_to_generic_if_null(device, release);
1336 }
1337
1338 int usb_serial_register(struct usb_serial_driver *driver)
1339 {
1340         /* must be called with BKL held */
1341         int retval;
1342
1343         if (usb_disabled())
1344                 return -ENODEV;
1345
1346         fixup_generic(driver);
1347
1348         if (!driver->description)
1349                 driver->description = driver->driver.name;
1350
1351         /* Add this device to our list of devices */
1352         list_add(&driver->driver_list, &usb_serial_driver_list);
1353
1354         retval = usb_serial_bus_register(driver);
1355         if (retval) {
1356                 printk(KERN_ERR "usb-serial: problem %d when registering "
1357                        "driver %s\n", retval, driver->description);
1358                 list_del(&driver->driver_list);
1359         } else
1360                 printk(KERN_INFO "USB Serial support registered for %s\n",
1361                                                 driver->description);
1362
1363         return retval;
1364 }
1365 EXPORT_SYMBOL_GPL(usb_serial_register);
1366
1367
1368 void usb_serial_deregister(struct usb_serial_driver *device)
1369 {
1370         /* must be called with BKL held */
1371         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1372                device->description);
1373         list_del(&device->driver_list);
1374         usb_serial_bus_deregister(device);
1375 }
1376 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1377
1378 /* Module information */
1379 MODULE_AUTHOR(DRIVER_AUTHOR);
1380 MODULE_DESCRIPTION(DRIVER_DESC);
1381 MODULE_LICENSE("GPL");
1382
1383 module_param(debug, bool, S_IRUGO | S_IWUSR);
1384 MODULE_PARM_DESC(debug, "Debug enabled or not");