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