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