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_release().
 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         dbg("%s", __func__);
 204
 205         serial = usb_serial_get_by_index(idx);
 206         if (!serial)
 207                 return retval;
 208
 209         port = serial->port[idx - serial->minor];
 210         if (!port)
 211                 goto error_no_port;
 212         if (!try_module_get(serial->type->driver.owner))
 213                 goto error_module_get;
 214
 215         /* perform the standard setup */
 216         retval = tty_init_termios(tty);
 217         if (retval)
 218                 goto error_init_termios;
 219
 220         retval = usb_autopm_get_interface(serial->interface);
 221         if (retval)
 222                 goto error_get_interface;
 223
 224         mutex_unlock(&serial->disc_mutex);
 225
 226         /* allow the driver to update the settings */
 227         if (serial->type->init_termios)
 228                 serial->type->init_termios(tty);
 229
 230         tty->driver_data = port;
 231
 232         /* Final install (we use the default method) */
 233         tty_driver_kref_get(driver);
 234         tty->count++;
 235         driver->ttys[idx] = tty;
 236         return retval;
 237
 238  error_get_interface:
 239  error_init_termios:
 240         module_put(serial->type->driver.owner);
 241  error_module_get:
 242  error_no_port:
 243         usb_serial_put(serial);
 244         mutex_unlock(&serial->disc_mutex);
 245         return retval;
 246 }
 247
 248 static int serial_open(struct tty_struct *tty, struct file *filp)
 249 {
 250         struct usb_serial_port *port = tty->driver_data;
 251         struct usb_serial *serial = port->serial;
 252         int retval;
 253
 254         dbg("%s - port %d", __func__, port->number);
 255
 256         spin_lock_irq(&port->port.lock);
 257         if (!tty_hung_up_p(filp))
 258                 ++port->port.count;
 259         spin_unlock_irq(&port->port.lock);
 260         tty_port_tty_set(&port->port, tty);
 261
 262         /* Do the device-specific open only if the hardware isn't
 263          * already initialized.
 264          */
 265         if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
 266                 if (mutex_lock_interruptible(&port->mutex))
 267                         return -ERESTARTSYS;
 268                 mutex_lock(&serial->disc_mutex);
 269                 if (serial->disconnected)
 270                         retval = -ENODEV;
 271                 else
 272                         retval = port->serial->type->open(tty, port);
 273                 mutex_unlock(&serial->disc_mutex);
 274                 mutex_unlock(&port->mutex);
 275                 if (retval)
 276                         return retval;
 277                 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
 278         }
 279
 280         /* Now do the correct tty layer semantics */
 281         retval = tty_port_block_til_ready(&port->port, tty, filp);
 282         return retval;
 283 }
 284
 285 /**
 286  * serial_down - shut down hardware
 287  * @port: port to shut down
 288  *
 289  * Shut down a USB serial port unless it is the console.  We never
 290  * shut down the console hardware as it will always be in use.
 291  */
 292 static void serial_down(struct usb_serial_port *port)
 293 {
 294         struct usb_serial_driver *drv = port->serial->type;
 295         struct usb_serial *serial;
 296         struct module *owner;
 297
 298         /*
 299          * The console is magical.  Do not hang up the console hardware
 300          * or there will be tears.
 301          */
 302         if (port->console)
 303                 return;
 304
 305         /* Don't call the close method if the hardware hasn't been
 306          * initialized.
 307          */
 308         if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
 309                 return;
 310
 311         mutex_lock(&port->mutex);
 312         serial = port->serial;
 313         owner = serial->type->driver.owner;
 314
 315         if (drv->close)
 316                 drv->close(port);
 317
 318         mutex_unlock(&port->mutex);
 319 }
 320
 321 static void serial_hangup(struct tty_struct *tty)
 322 {
 323         struct usb_serial_port *port = tty->driver_data;
 324
 325         dbg("%s - port %d", __func__, port->number);
 326
 327         serial_down(port);
 328         tty_port_hangup(&port->port);
 329 }
 330
 331 static void serial_close(struct tty_struct *tty, struct file *filp)
 332 {
 333         struct usb_serial_port *port = tty->driver_data;
 334
 335         dbg("%s - port %d", __func__, port->number);
 336
 337         if (tty_hung_up_p(filp))
 338                 return;
 339         if (tty_port_close_start(&port->port, tty, filp) == 0)
 340                 return;
 341         serial_down(port);
 342         tty_port_close_end(&port->port, tty);
 343         tty_port_tty_set(&port->port, NULL);
 344 }
 345
 346 /**
 347  * serial_release - free resources post close/hangup
 348  * @port: port to free up
 349  *
 350  * Do the resource freeing and refcount dropping for the port.
 351  * Avoid freeing the console.
 352  *
 353  * Called when the last tty kref is dropped.
 354  */
 355 static void serial_release(struct tty_struct *tty)
 356 {
 357         struct usb_serial_port *port = tty->driver_data;
 358         struct usb_serial *serial;
 359         struct module *owner;
 360
 361         /* The console is magical.  Do not hang up the console hardware
 362          * or there will be tears.
 363          */
 364         if (port->console)
 365                 return;
 366
 367         dbg("%s - port %d", __func__, port->number);
 368
 369         /* Standard shutdown processing */
 370         tty_shutdown(tty);
 371
 372         tty->driver_data = NULL;
 373
 374         serial = port->serial;
 375         owner = serial->type->driver.owner;
 376
 377         mutex_lock(&serial->disc_mutex);
 378         if (!serial->disconnected)
 379                 usb_autopm_put_interface(serial->interface);
 380         mutex_unlock(&serial->disc_mutex);
 381
 382         usb_serial_put(serial);
 383         module_put(owner);
 384 }
 385
 386 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 387                                                                 int count)
 388 {
 389         struct usb_serial_port *port = tty->driver_data;
 390         int retval = -ENODEV;
 391
 392         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 393                 goto exit;
 394
 395         dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
 396
 397         /* count is managed under the mutex lock for the tty so cannot
 398            drop to zero until after the last close completes */
 399         WARN_ON(!port->port.count);
 400
 401         /* pass on to the driver specific version of this function */
 402         retval = port->serial->type->write(tty, port, buf, count);
 403
 404 exit:
 405         return retval;
 406 }
 407
 408 static int serial_write_room(struct tty_struct *tty)
 409 {
 410         struct usb_serial_port *port = tty->driver_data;
 411         dbg("%s - port %d", __func__, port->number);
 412         WARN_ON(!port->port.count);
 413         /* pass on to the driver specific version of this function */
 414         return port->serial->type->write_room(tty);
 415 }
 416
 417 static int serial_chars_in_buffer(struct tty_struct *tty)
 418 {
 419         struct usb_serial_port *port = tty->driver_data;
 420         dbg("%s = port %d", __func__, port->number);
 421
 422         /* if the device was unplugged then any remaining characters
 423            fell out of the connector ;) */
 424         if (port->serial->disconnected)
 425                 return 0;
 426         /* pass on to the driver specific version of this function */
 427         return port->serial->type->chars_in_buffer(tty);
 428 }
 429
 430 static void serial_throttle(struct tty_struct *tty)
 431 {
 432         struct usb_serial_port *port = tty->driver_data;
 433         dbg("%s - port %d", __func__, port->number);
 434
 435         WARN_ON(!port->port.count);
 436         /* pass on to the driver specific version of this function */
 437         if (port->serial->type->throttle)
 438                 port->serial->type->throttle(tty);
 439 }
 440
 441 static void serial_unthrottle(struct tty_struct *tty)
 442 {
 443         struct usb_serial_port *port = tty->driver_data;
 444         dbg("%s - port %d", __func__, port->number);
 445
 446         WARN_ON(!port->port.count);
 447         /* pass on to the driver specific version of this function */
 448         if (port->serial->type->unthrottle)
 449                 port->serial->type->unthrottle(tty);
 450 }
 451
 452 static int serial_ioctl(struct tty_struct *tty, struct file *file,
 453                                         unsigned int cmd, unsigned long arg)
 454 {
 455         struct usb_serial_port *port = tty->driver_data;
 456         int retval = -ENODEV;
 457
 458         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 459
 460         WARN_ON(!port->port.count);
 461
 462         /* pass on to the driver specific version of this function
 463            if it is available */
 464         if (port->serial->type->ioctl) {
 465                 retval = port->serial->type->ioctl(tty, file, cmd, arg);
 466         } else
 467                 retval = -ENOIOCTLCMD;
 468         return retval;
 469 }
 470
 471 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 472 {
 473         struct usb_serial_port *port = tty->driver_data;
 474         dbg("%s - port %d", __func__, port->number);
 475
 476         WARN_ON(!port->port.count);
 477         /* pass on to the driver specific version of this function
 478            if it is available */
 479         if (port->serial->type->set_termios)
 480                 port->serial->type->set_termios(tty, port, old);
 481         else
 482                 tty_termios_copy_hw(tty->termios, old);
 483 }
 484
 485 static int serial_break(struct tty_struct *tty, int break_state)
 486 {
 487         struct usb_serial_port *port = tty->driver_data;
 488
 489         dbg("%s - port %d", __func__, port->number);
 490
 491         WARN_ON(!port->port.count);
 492         /* pass on to the driver specific version of this function
 493            if it is available */
 494         if (port->serial->type->break_ctl)
 495                 port->serial->type->break_ctl(tty, break_state);
 496         return 0;
 497 }
 498
 499 static int serial_proc_show(struct seq_file *m, void *v)
 500 {
 501         struct usb_serial *serial;
 502         int i;
 503         char tmp[40];
 504
 505         dbg("%s", __func__);
 506         seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 507         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
 508                 serial = usb_serial_get_by_index(i);
 509                 if (serial == NULL)
 510                         continue;
 511
 512                 seq_printf(m, "%d:", i);
 513                 if (serial->type->driver.owner)
 514                         seq_printf(m, " module:%s",
 515                                 module_name(serial->type->driver.owner));
 516                 seq_printf(m, " name:\"%s\"",
 517                                 serial->type->description);
 518                 seq_printf(m, " vendor:%04x product:%04x",
 519                         le16_to_cpu(serial->dev->descriptor.idVendor),
 520                         le16_to_cpu(serial->dev->descriptor.idProduct));
 521                 seq_printf(m, " num_ports:%d", serial->num_ports);
 522                 seq_printf(m, " port:%d", i - serial->minor + 1);
 523                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 524                 seq_printf(m, " path:%s", tmp);
 525
 526                 seq_putc(m, '\n');
 527                 usb_serial_put(serial);
 528                 mutex_unlock(&serial->disc_mutex);
 529         }
 530         return 0;
 531 }
 532
 533 static int serial_proc_open(struct inode *inode, struct file *file)
 534 {
 535         return single_open(file, serial_proc_show, NULL);
 536 }
 537
 538 static const struct file_operations serial_proc_fops = {
 539         .owner          = THIS_MODULE,
 540         .open           = serial_proc_open,
 541         .read           = seq_read,
 542         .llseek         = seq_lseek,
 543         .release        = single_release,
 544 };
 545
 546 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 547 {
 548         struct usb_serial_port *port = tty->driver_data;
 549
 550         dbg("%s - port %d", __func__, port->number);
 551
 552         WARN_ON(!port->port.count);
 553         if (port->serial->type->tiocmget)
 554                 return port->serial->type->tiocmget(tty, file);
 555         return -EINVAL;
 556 }
 557
 558 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 559                             unsigned int set, unsigned int clear)
 560 {
 561         struct usb_serial_port *port = tty->driver_data;
 562
 563         dbg("%s - port %d", __func__, port->number);
 564
 565         WARN_ON(!port->port.count);
 566         if (port->serial->type->tiocmset)
 567                 return port->serial->type->tiocmset(tty, file, set, clear);
 568         return -EINVAL;
 569 }
 570
 571 /*
 572  * We would be calling tty_wakeup here, but unfortunately some line
 573  * disciplines have an annoying habit of calling tty->write from
 574  * the write wakeup callback (e.g. n_hdlc.c).
 575  */
 576 void usb_serial_port_softint(struct usb_serial_port *port)
 577 {
 578         schedule_work(&port->work);
 579 }
 580 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 581
 582 static void usb_serial_port_work(struct work_struct *work)
 583 {
 584         struct usb_serial_port *port =
 585                 container_of(work, struct usb_serial_port, work);
 586         struct tty_struct *tty;
 587
 588         dbg("%s - port %d", __func__, port->number);
 589
 590         tty = tty_port_tty_get(&port->port);
 591         if (!tty)
 592                 return;
 593
 594         tty_wakeup(tty);
 595         tty_kref_put(tty);
 596 }
 597
 598 static void kill_traffic(struct usb_serial_port *port)
 599 {
 600         usb_kill_urb(port->read_urb);
 601         usb_kill_urb(port->write_urb);
 602         /*
 603          * This is tricky.
 604          * Some drivers submit the read_urb in the
 605          * handler for the write_urb or vice versa
 606          * this order determines the order in which
 607          * usb_kill_urb() must be used to reliably
 608          * kill the URBs. As it is unknown here,
 609          * both orders must be used in turn.
 610          * The call below is not redundant.
 611          */
 612         usb_kill_urb(port->read_urb);
 613         usb_kill_urb(port->interrupt_in_urb);
 614         usb_kill_urb(port->interrupt_out_urb);
 615 }
 616
 617 static void port_release(struct device *dev)
 618 {
 619         struct usb_serial_port *port = to_usb_serial_port(dev);
 620
 621         dbg ("%s - %s", __func__, dev_name(dev));
 622
 623         /*
 624          * Stop all the traffic before cancelling the work, so that
 625          * nobody will restart it by calling usb_serial_port_softint.
 626          */
 627         kill_traffic(port);
 628         cancel_work_sync(&port->work);
 629
 630         usb_free_urb(port->read_urb);
 631         usb_free_urb(port->write_urb);
 632         usb_free_urb(port->interrupt_in_urb);
 633         usb_free_urb(port->interrupt_out_urb);
 634         kfree(port->bulk_in_buffer);
 635         kfree(port->bulk_out_buffer);
 636         kfree(port->interrupt_in_buffer);
 637         kfree(port->interrupt_out_buffer);
 638         kfree(port);
 639 }
 640
 641 static struct usb_serial *create_serial(struct usb_device *dev,
 642                                         struct usb_interface *interface,
 643                                         struct usb_serial_driver *driver)
 644 {
 645         struct usb_serial *serial;
 646
 647         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 648         if (!serial) {
 649                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
 650                 return NULL;
 651         }
 652         serial->dev = usb_get_dev(dev);
 653         serial->type = driver;
 654         serial->interface = interface;
 655         kref_init(&serial->kref);
 656         mutex_init(&serial->disc_mutex);
 657         serial->minor = SERIAL_TTY_NO_MINOR;
 658
 659         return serial;
 660 }
 661
 662 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 663                                             struct usb_serial_driver *drv)
 664 {
 665         struct usb_dynid *dynid;
 666
 667         spin_lock(&drv->dynids.lock);
 668         list_for_each_entry(dynid, &drv->dynids.list, node) {
 669                 if (usb_match_one_id(intf, &dynid->id)) {
 670                         spin_unlock(&drv->dynids.lock);
 671                         return &dynid->id;
 672                 }
 673         }
 674         spin_unlock(&drv->dynids.lock);
 675         return NULL;
 676 }
 677
 678 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 679                                                 struct usb_interface *intf)
 680 {
 681         const struct usb_device_id *id;
 682
 683         id = usb_match_id(intf, drv->id_table);
 684         if (id) {
 685                 dbg("static descriptor matches");
 686                 goto exit;
 687         }
 688         id = match_dynamic_id(intf, drv);
 689         if (id)
 690                 dbg("dynamic descriptor matches");
 691 exit:
 692         return id;
 693 }
 694
 695 static struct usb_serial_driver *search_serial_device(
 696                                         struct usb_interface *iface)
 697 {
 698         const struct usb_device_id *id;
 699         struct usb_serial_driver *drv;
 700
 701         /* Check if the usb id matches a known device */
 702         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 703                 id = get_iface_id(drv, iface);
 704                 if (id)
 705                         return drv;
 706         }
 707
 708         return NULL;
 709 }
 710
 711 static int serial_carrier_raised(struct tty_port *port)
 712 {
 713         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 714         struct usb_serial_driver *drv = p->serial->type;
 715         if (drv->carrier_raised)
 716                 return drv->carrier_raised(p);
 717         /* No carrier control - don't block */
 718         return 1;
 719 }
 720
 721 static void serial_dtr_rts(struct tty_port *port, int on)
 722 {
 723         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 724         struct usb_serial_driver *drv = p->serial->type;
 725         if (drv->dtr_rts)
 726                 drv->dtr_rts(p, on);
 727 }
 728
 729 static const struct tty_port_operations serial_port_ops = {
 730         .carrier_raised = serial_carrier_raised,
 731         .dtr_rts = serial_dtr_rts,
 732 };
 733
 734 int usb_serial_probe(struct usb_interface *interface,
 735                                const struct usb_device_id *id)
 736 {
 737         struct usb_device *dev = interface_to_usbdev(interface);
 738         struct usb_serial *serial = NULL;
 739         struct usb_serial_port *port;
 740         struct usb_host_interface *iface_desc;
 741         struct usb_endpoint_descriptor *endpoint;
 742         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 743         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 744         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 745         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 746         struct usb_serial_driver *type = NULL;
 747         int retval;
 748         unsigned int minor;
 749         int buffer_size;
 750         int i;
 751         int num_interrupt_in = 0;
 752         int num_interrupt_out = 0;
 753         int num_bulk_in = 0;
 754         int num_bulk_out = 0;
 755         int num_ports = 0;
 756         int max_endpoints;
 757
 758         lock_kernel(); /* guard against unloading a serial driver module */
 759         type = search_serial_device(interface);
 760         if (!type) {
 761                 unlock_kernel();
 762                 dbg("none matched");
 763                 return -ENODEV;
 764         }
 765
 766         serial = create_serial(dev, interface, type);
 767         if (!serial) {
 768                 unlock_kernel();
 769                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
 770                 return -ENOMEM;
 771         }
 772
 773         /* if this device type has a probe function, call it */
 774         if (type->probe) {
 775                 const struct usb_device_id *id;
 776
 777                 if (!try_module_get(type->driver.owner)) {
 778                         unlock_kernel();
 779                         dev_err(&interface->dev,
 780                                 "module get failed, exiting\n");
 781                         kfree(serial);
 782                         return -EIO;
 783                 }
 784
 785                 id = get_iface_id(type, interface);
 786                 retval = type->probe(serial, id);
 787                 module_put(type->driver.owner);
 788
 789                 if (retval) {
 790                         unlock_kernel();
 791                         dbg("sub driver rejected device");
 792                         kfree(serial);
 793                         return retval;
 794                 }
 795         }
 796
 797         /* descriptor matches, let's find the endpoints needed */
 798         /* check out the endpoints */
 799         iface_desc = interface->cur_altsetting;
 800         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 801                 endpoint = &iface_desc->endpoint[i].desc;
 802
 803                 if (usb_endpoint_is_bulk_in(endpoint)) {
 804                         /* we found a bulk in endpoint */
 805                         dbg("found bulk in on endpoint %d", i);
 806                         bulk_in_endpoint[num_bulk_in] = endpoint;
 807                         ++num_bulk_in;
 808                 }
 809
 810                 if (usb_endpoint_is_bulk_out(endpoint)) {
 811                         /* we found a bulk out endpoint */
 812                         dbg("found bulk out on endpoint %d", i);
 813                         bulk_out_endpoint[num_bulk_out] = endpoint;
 814                         ++num_bulk_out;
 815                 }
 816
 817                 if (usb_endpoint_is_int_in(endpoint)) {
 818                         /* we found a interrupt in endpoint */
 819                         dbg("found interrupt in on endpoint %d", i);
 820                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 821                         ++num_interrupt_in;
 822                 }
 823
 824                 if (usb_endpoint_is_int_out(endpoint)) {
 825                         /* we found an interrupt out endpoint */
 826                         dbg("found interrupt out on endpoint %d", i);
 827                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 828                         ++num_interrupt_out;
 829                 }
 830         }
 831
 832 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 833         /* BEGIN HORRIBLE HACK FOR PL2303 */
 834         /* this is needed due to the looney way its endpoints are set up */
 835         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 836              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 837             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 838              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 839             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 840              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 841             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 842              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 843                 if (interface != dev->actconfig->interface[0]) {
 844                         /* check out the endpoints of the other interface*/
 845                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 846                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 847                                 endpoint = &iface_desc->endpoint[i].desc;
 848                                 if (usb_endpoint_is_int_in(endpoint)) {
 849                                         /* we found a interrupt in endpoint */
 850                                         dbg("found interrupt in for Prolific device on separate interface");
 851                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 852                                         ++num_interrupt_in;
 853                                 }
 854                         }
 855                 }
 856
 857                 /* Now make sure the PL-2303 is configured correctly.
 858                  * If not, give up now and hope this hack will work
 859                  * properly during a later invocation of usb_serial_probe
 860                  */
 861                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 862                         unlock_kernel();
 863                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 864                         kfree(serial);
 865                         return -ENODEV;
 866                 }
 867         }
 868         /* END HORRIBLE HACK FOR PL2303 */
 869 #endif
 870
 871 #ifdef CONFIG_USB_SERIAL_GENERIC
 872         if (type == &usb_serial_generic_device) {
 873                 num_ports = num_bulk_out;
 874                 if (num_ports == 0) {
 875                         unlock_kernel();
 876                         dev_err(&interface->dev,
 877                             "Generic device with no bulk out, not allowed.\n");
 878                         kfree(serial);
 879                         return -EIO;
 880                 }
 881         }
 882 #endif
 883         if (!num_ports) {
 884                 /* if this device type has a calc_num_ports function, call it */
 885                 if (type->calc_num_ports) {
 886                         if (!try_module_get(type->driver.owner)) {
 887                                 unlock_kernel();
 888                                 dev_err(&interface->dev,
 889                                         "module get failed, exiting\n");
 890                                 kfree(serial);
 891                                 return -EIO;
 892                         }
 893                         num_ports = type->calc_num_ports(serial);
 894                         module_put(type->driver.owner);
 895                 }
 896                 if (!num_ports)
 897                         num_ports = type->num_ports;
 898         }
 899
 900         serial->num_ports = num_ports;
 901         serial->num_bulk_in = num_bulk_in;
 902         serial->num_bulk_out = num_bulk_out;
 903         serial->num_interrupt_in = num_interrupt_in;
 904         serial->num_interrupt_out = num_interrupt_out;
 905
 906         /* found all that we need */
 907         dev_info(&interface->dev, "%s converter detected\n",
 908                         type->description);
 909
 910         /* create our ports, we need as many as the max endpoints */
 911         /* we don't use num_ports here because some devices have more
 912            endpoint pairs than ports */
 913         max_endpoints = max(num_bulk_in, num_bulk_out);
 914         max_endpoints = max(max_endpoints, num_interrupt_in);
 915         max_endpoints = max(max_endpoints, num_interrupt_out);
 916         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 917         serial->num_port_pointers = max_endpoints;
 918         unlock_kernel();
 919
 920         dbg("%s - setting up %d port structures for this device",
 921                                                 __func__, max_endpoints);
 922         for (i = 0; i < max_endpoints; ++i) {
 923                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 924                 if (!port)
 925                         goto probe_error;
 926                 tty_port_init(&port->port);
 927                 port->port.ops = &serial_port_ops;
 928                 port->serial = serial;
 929                 spin_lock_init(&port->lock);
 930                 mutex_init(&port->mutex);
 931                 INIT_WORK(&port->work, usb_serial_port_work);
 932                 serial->port[i] = port;
 933                 port->dev.parent = &interface->dev;
 934                 port->dev.driver = NULL;
 935                 port->dev.bus = &usb_serial_bus_type;
 936                 port->dev.release = &port_release;
 937                 device_initialize(&port->dev);
 938         }
 939
 940         /* set up the endpoint information */
 941         for (i = 0; i < num_bulk_in; ++i) {
 942                 endpoint = bulk_in_endpoint[i];
 943                 port = serial->port[i];
 944                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 945                 if (!port->read_urb) {
 946                         dev_err(&interface->dev, "No free urbs available\n");
 947                         goto probe_error;
 948                 }
 949                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 950                 port->bulk_in_size = buffer_size;
 951                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 952                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 953                 if (!port->bulk_in_buffer) {
 954                         dev_err(&interface->dev,
 955                                         "Couldn't allocate bulk_in_buffer\n");
 956                         goto probe_error;
 957                 }
 958                 usb_fill_bulk_urb(port->read_urb, dev,
 959                                 usb_rcvbulkpipe(dev,
 960                                                 endpoint->bEndpointAddress),
 961                                 port->bulk_in_buffer, buffer_size,
 962                                 serial->type->read_bulk_callback, port);
 963         }
 964
 965         for (i = 0; i < num_bulk_out; ++i) {
 966                 endpoint = bulk_out_endpoint[i];
 967                 port = serial->port[i];
 968                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 969                 if (!port->write_urb) {
 970                         dev_err(&interface->dev, "No free urbs available\n");
 971                         goto probe_error;
 972                 }
 973                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 974                 port->bulk_out_size = buffer_size;
 975                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 976                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 977                 if (!port->bulk_out_buffer) {
 978                         dev_err(&interface->dev,
 979                                         "Couldn't allocate bulk_out_buffer\n");
 980                         goto probe_error;
 981                 }
 982                 usb_fill_bulk_urb(port->write_urb, dev,
 983                                 usb_sndbulkpipe(dev,
 984                                         endpoint->bEndpointAddress),
 985                                 port->bulk_out_buffer, buffer_size,
 986                                 serial->type->write_bulk_callback, port);
 987         }
 988
 989         if (serial->type->read_int_callback) {
 990                 for (i = 0; i < num_interrupt_in; ++i) {
 991                         endpoint = interrupt_in_endpoint[i];
 992                         port = serial->port[i];
 993                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 994                         if (!port->interrupt_in_urb) {
 995                                 dev_err(&interface->dev,
 996                                                 "No free urbs available\n");
 997                                 goto probe_error;
 998                         }
 999                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1000                         port->interrupt_in_endpointAddress =
1001                                                 endpoint->bEndpointAddress;
1002                         port->interrupt_in_buffer = kmalloc(buffer_size,
1003                                                                 GFP_KERNEL);
1004                         if (!port->interrupt_in_buffer) {
1005                                 dev_err(&interface->dev,
1006                                     "Couldn't allocate interrupt_in_buffer\n");
1007                                 goto probe_error;
1008                         }
1009                         usb_fill_int_urb(port->interrupt_in_urb, dev,
1010                                 usb_rcvintpipe(dev,
1011                                                 endpoint->bEndpointAddress),
1012                                 port->interrupt_in_buffer, buffer_size,
1013                                 serial->type->read_int_callback, port,
1014                                 endpoint->bInterval);
1015                 }
1016         } else if (num_interrupt_in) {
1017                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1018         }
1019
1020         if (serial->type->write_int_callback) {
1021                 for (i = 0; i < num_interrupt_out; ++i) {
1022                         endpoint = interrupt_out_endpoint[i];
1023                         port = serial->port[i];
1024                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1025                         if (!port->interrupt_out_urb) {
1026                                 dev_err(&interface->dev,
1027                                                 "No free urbs available\n");
1028                                 goto probe_error;
1029                         }
1030                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1031                         port->interrupt_out_size = buffer_size;
1032                         port->interrupt_out_endpointAddress =
1033                                                 endpoint->bEndpointAddress;
1034                         port->interrupt_out_buffer = kmalloc(buffer_size,
1035                                                                 GFP_KERNEL);
1036                         if (!port->interrupt_out_buffer) {
1037                                 dev_err(&interface->dev,
1038                                   "Couldn't allocate interrupt_out_buffer\n");
1039                                 goto probe_error;
1040                         }
1041                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1042                                 usb_sndintpipe(dev,
1043                                                   endpoint->bEndpointAddress),
1044                                 port->interrupt_out_buffer, buffer_size,
1045                                 serial->type->write_int_callback, port,
1046                                 endpoint->bInterval);
1047                 }
1048         } else if (num_interrupt_out) {
1049                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1050         }
1051
1052         /* if this device type has an attach function, call it */
1053         if (type->attach) {
1054                 if (!try_module_get(type->driver.owner)) {
1055                         dev_err(&interface->dev,
1056                                         "module get failed, exiting\n");
1057                         goto probe_error;
1058                 }
1059                 retval = type->attach(serial);
1060                 module_put(type->driver.owner);
1061                 if (retval < 0)
1062                         goto probe_error;
1063                 if (retval > 0) {
1064                         /* quietly accept this device, but don't bind to a
1065                            serial port as it's about to disappear */
1066                         serial->num_ports = 0;
1067                         goto exit;
1068                 }
1069         }
1070
1071         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1072                 dev_err(&interface->dev, "No more free serial devices\n");
1073                 goto probe_error;
1074         }
1075         serial->minor = minor;
1076
1077         /* register all of the individual ports with the driver core */
1078         for (i = 0; i < num_ports; ++i) {
1079                 port = serial->port[i];
1080                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1081                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1082                 port->dev_state = PORT_REGISTERING;
1083                 retval = device_add(&port->dev);
1084                 if (retval) {
1085                         dev_err(&port->dev, "Error registering port device, "
1086                                 "continuing\n");
1087                         port->dev_state = PORT_UNREGISTERED;
1088                 } else {
1089                         port->dev_state = PORT_REGISTERED;
1090                 }
1091         }
1092
1093         usb_serial_console_init(debug, minor);
1094
1095 exit:
1096         /* success */
1097         usb_set_intfdata(interface, serial);
1098         return 0;
1099
1100 probe_error:
1101         usb_serial_put(serial);
1102         return -EIO;
1103 }
1104 EXPORT_SYMBOL_GPL(usb_serial_probe);
1105
1106 void usb_serial_disconnect(struct usb_interface *interface)
1107 {
1108         int i;
1109         struct usb_serial *serial = usb_get_intfdata(interface);
1110         struct device *dev = &interface->dev;
1111         struct usb_serial_port *port;
1112
1113         usb_serial_console_disconnect(serial);
1114         dbg("%s", __func__);
1115
1116         mutex_lock(&serial->disc_mutex);
1117         usb_set_intfdata(interface, NULL);
1118         /* must set a flag, to signal subdrivers */
1119         serial->disconnected = 1;
1120         mutex_unlock(&serial->disc_mutex);
1121
1122         for (i = 0; i < serial->num_ports; ++i) {
1123                 port = serial->port[i];
1124                 if (port) {
1125                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1126                         if (tty) {
1127                                 tty_vhangup(tty);
1128                                 tty_kref_put(tty);
1129                         }
1130                         kill_traffic(port);
1131                         cancel_work_sync(&port->work);
1132                         if (port->dev_state == PORT_REGISTERED) {
1133
1134                                 /* Make sure the port is bound so that the
1135                                  * driver's port_remove method is called.
1136                                  */
1137                                 if (!port->dev.driver) {
1138                                         int rc;
1139
1140                                         port->dev.driver =
1141                                                         &serial->type->driver;
1142                                         rc = device_bind_driver(&port->dev);
1143                                 }
1144                                 port->dev_state = PORT_UNREGISTERING;
1145                                 device_del(&port->dev);
1146                                 port->dev_state = PORT_UNREGISTERED;
1147                         }
1148                 }
1149         }
1150         serial->type->disconnect(serial);
1151
1152         /* let the last holder of this object cause it to be cleaned up */
1153         usb_serial_put(serial);
1154         dev_info(dev, "device disconnected\n");
1155 }
1156 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1157
1158 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1159 {
1160         struct usb_serial *serial = usb_get_intfdata(intf);
1161         struct usb_serial_port *port;
1162         int i, r = 0;
1163
1164         serial->suspending = 1;
1165
1166         for (i = 0; i < serial->num_ports; ++i) {
1167                 port = serial->port[i];
1168                 if (port)
1169                         kill_traffic(port);
1170         }
1171
1172         if (serial->type->suspend)
1173                 r = serial->type->suspend(serial, message);
1174
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         .shutdown =             serial_release,
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");