SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/usb/serial/usb-serial.c

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