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