drivers/usb/serial/usb-serial.c

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