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