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