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