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