drivers/usb/serial/usb-serial.c

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