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 /**
 725  *      serial_install          -       install tty
 726  *      @driver: the driver (USB in our case)
 727  *      @tty: the tty being created
 728  *
 729  *      Create the termios objects for this tty. We use the default USB
 730  *      serial ones but permit them to be overriddenby serial->type->termios.
 731  *      This lets us remove all the ugly hackery
 732  */
 733
 734 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 735 {
 736         int idx = tty->index;
 737         struct usb_serial *serial;
 738         int retval;
 739
 740         /* If the termios setup has yet to be done */
 741         if (tty->driver->termios[idx] == NULL) {
 742                 /* perform the standard setup */
 743                 retval = tty_init_termios(tty);
 744                 if (retval)
 745                         return retval;
 746                 /* allow the driver to update it */
 747                 serial = usb_serial_get_by_index(tty->index);
 748                 if (serial->type->init_termios)
 749                         serial->type->init_termios(tty);
 750                 usb_serial_put(serial);
 751         }
 752         /* Final install (we use the default method) */
 753         tty_driver_kref_get(driver);
 754         tty->count++;
 755         driver->ttys[idx] = tty;
 756         return 0;
 757 }
 758
 759 int usb_serial_probe(struct usb_interface *interface,
 760                                const struct usb_device_id *id)
 761 {
 762         struct usb_device *dev = interface_to_usbdev(interface);
 763         struct usb_serial *serial = NULL;
 764         struct usb_serial_port *port;
 765         struct usb_host_interface *iface_desc;
 766         struct usb_endpoint_descriptor *endpoint;
 767         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 768         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 769         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 770         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 771         struct usb_serial_driver *type = NULL;
 772         int retval;
 773         unsigned int minor;
 774         int buffer_size;
 775         int i;
 776         int num_interrupt_in = 0;
 777         int num_interrupt_out = 0;
 778         int num_bulk_in = 0;
 779         int num_bulk_out = 0;
 780         int num_ports = 0;
 781         int max_endpoints;
 782
 783         lock_kernel(); /* guard against unloading a serial driver module */
 784         type = search_serial_device(interface);
 785         if (!type) {
 786                 unlock_kernel();
 787                 dbg("none matched");
 788                 return -ENODEV;
 789         }
 790
 791         serial = create_serial(dev, interface, type);
 792         if (!serial) {
 793                 unlock_kernel();
 794                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
 795                 return -ENOMEM;
 796         }
 797
 798         /* if this device type has a probe function, call it */
 799         if (type->probe) {
 800                 const struct usb_device_id *id;
 801
 802                 if (!try_module_get(type->driver.owner)) {
 803                         unlock_kernel();
 804                         dev_err(&interface->dev,
 805                                 "module get failed, exiting\n");
 806                         kfree(serial);
 807                         return -EIO;
 808                 }
 809
 810                 id = get_iface_id(type, interface);
 811                 retval = type->probe(serial, id);
 812                 module_put(type->driver.owner);
 813
 814                 if (retval) {
 815                         unlock_kernel();
 816                         dbg("sub driver rejected device");
 817                         kfree(serial);
 818                         return retval;
 819                 }
 820         }
 821
 822         /* descriptor matches, let's find the endpoints needed */
 823         /* check out the endpoints */
 824         iface_desc = interface->cur_altsetting;
 825         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 826                 endpoint = &iface_desc->endpoint[i].desc;
 827
 828                 if (usb_endpoint_is_bulk_in(endpoint)) {
 829                         /* we found a bulk in endpoint */
 830                         dbg("found bulk in on endpoint %d", i);
 831                         bulk_in_endpoint[num_bulk_in] = endpoint;
 832                         ++num_bulk_in;
 833                 }
 834
 835                 if (usb_endpoint_is_bulk_out(endpoint)) {
 836                         /* we found a bulk out endpoint */
 837                         dbg("found bulk out on endpoint %d", i);
 838                         bulk_out_endpoint[num_bulk_out] = endpoint;
 839                         ++num_bulk_out;
 840                 }
 841
 842                 if (usb_endpoint_is_int_in(endpoint)) {
 843                         /* we found a interrupt in endpoint */
 844                         dbg("found interrupt in on endpoint %d", i);
 845                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 846                         ++num_interrupt_in;
 847                 }
 848
 849                 if (usb_endpoint_is_int_out(endpoint)) {
 850                         /* we found an interrupt out endpoint */
 851                         dbg("found interrupt out on endpoint %d", i);
 852                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 853                         ++num_interrupt_out;
 854                 }
 855         }
 856
 857 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 858         /* BEGIN HORRIBLE HACK FOR PL2303 */
 859         /* this is needed due to the looney way its endpoints are set up */
 860         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 861              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 862             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 863              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 864             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 865              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 866             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 867              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 868                 if (interface != dev->actconfig->interface[0]) {
 869                         /* check out the endpoints of the other interface*/
 870                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 871                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 872                                 endpoint = &iface_desc->endpoint[i].desc;
 873                                 if (usb_endpoint_is_int_in(endpoint)) {
 874                                         /* we found a interrupt in endpoint */
 875                                         dbg("found interrupt in for Prolific device on separate interface");
 876                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 877                                         ++num_interrupt_in;
 878                                 }
 879                         }
 880                 }
 881
 882                 /* Now make sure the PL-2303 is configured correctly.
 883                  * If not, give up now and hope this hack will work
 884                  * properly during a later invocation of usb_serial_probe
 885                  */
 886                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 887                         unlock_kernel();
 888                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 889                         kfree(serial);
 890                         return -ENODEV;
 891                 }
 892         }
 893         /* END HORRIBLE HACK FOR PL2303 */
 894 #endif
 895
 896 #ifdef CONFIG_USB_SERIAL_GENERIC
 897         if (type == &usb_serial_generic_device) {
 898                 num_ports = num_bulk_out;
 899                 if (num_ports == 0) {
 900                         unlock_kernel();
 901                         dev_err(&interface->dev,
 902                             "Generic device with no bulk out, not allowed.\n");
 903                         kfree(serial);
 904                         return -EIO;
 905                 }
 906         }
 907 #endif
 908         if (!num_ports) {
 909                 /* if this device type has a calc_num_ports function, call it */
 910                 if (type->calc_num_ports) {
 911                         if (!try_module_get(type->driver.owner)) {
 912                                 unlock_kernel();
 913                                 dev_err(&interface->dev,
 914                                         "module get failed, exiting\n");
 915                                 kfree(serial);
 916                                 return -EIO;
 917                         }
 918                         num_ports = type->calc_num_ports(serial);
 919                         module_put(type->driver.owner);
 920                 }
 921                 if (!num_ports)
 922                         num_ports = type->num_ports;
 923         }
 924
 925         serial->num_ports = num_ports;
 926         serial->num_bulk_in = num_bulk_in;
 927         serial->num_bulk_out = num_bulk_out;
 928         serial->num_interrupt_in = num_interrupt_in;
 929         serial->num_interrupt_out = num_interrupt_out;
 930
 931         /* found all that we need */
 932         dev_info(&interface->dev, "%s converter detected\n",
 933                         type->description);
 934
 935         /* create our ports, we need as many as the max endpoints */
 936         /* we don't use num_ports here because some devices have more
 937            endpoint pairs than ports */
 938         max_endpoints = max(num_bulk_in, num_bulk_out);
 939         max_endpoints = max(max_endpoints, num_interrupt_in);
 940         max_endpoints = max(max_endpoints, num_interrupt_out);
 941         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 942         serial->num_port_pointers = max_endpoints;
 943         unlock_kernel();
 944
 945         dbg("%s - setting up %d port structures for this device",
 946                                                 __func__, max_endpoints);
 947         for (i = 0; i < max_endpoints; ++i) {
 948                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 949                 if (!port)
 950                         goto probe_error;
 951                 tty_port_init(&port->port);
 952                 port->port.ops = &serial_port_ops;
 953                 port->serial = serial;
 954                 spin_lock_init(&port->lock);
 955                 mutex_init(&port->mutex);
 956                 INIT_WORK(&port->work, usb_serial_port_work);
 957                 serial->port[i] = port;
 958         }
 959
 960         /* set up the endpoint information */
 961         for (i = 0; i < num_bulk_in; ++i) {
 962                 endpoint = bulk_in_endpoint[i];
 963                 port = serial->port[i];
 964                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 965                 if (!port->read_urb) {
 966                         dev_err(&interface->dev, "No free urbs available\n");
 967                         goto probe_error;
 968                 }
 969                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 970                 port->bulk_in_size = buffer_size;
 971                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 972                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 973                 if (!port->bulk_in_buffer) {
 974                         dev_err(&interface->dev,
 975                                         "Couldn't allocate bulk_in_buffer\n");
 976                         goto probe_error;
 977                 }
 978                 usb_fill_bulk_urb(port->read_urb, dev,
 979                                 usb_rcvbulkpipe(dev,
 980                                                 endpoint->bEndpointAddress),
 981                                 port->bulk_in_buffer, buffer_size,
 982                                 serial->type->read_bulk_callback, port);
 983         }
 984
 985         for (i = 0; i < num_bulk_out; ++i) {
 986                 endpoint = bulk_out_endpoint[i];
 987                 port = serial->port[i];
 988                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 989                 if (!port->write_urb) {
 990                         dev_err(&interface->dev, "No free urbs available\n");
 991                         goto probe_error;
 992                 }
 993                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 994                 port->bulk_out_size = buffer_size;
 995                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 996                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 997                 if (!port->bulk_out_buffer) {
 998                         dev_err(&interface->dev,
 999                                         "Couldn't allocate bulk_out_buffer\n");
1000                         goto probe_error;
1001                 }
1002                 usb_fill_bulk_urb(port->write_urb, dev,
1003                                 usb_sndbulkpipe(dev,
1004                                         endpoint->bEndpointAddress),
1005                                 port->bulk_out_buffer, buffer_size,
1006                                 serial->type->write_bulk_callback, port);
1007         }
1008
1009         if (serial->type->read_int_callback) {
1010                 for (i = 0; i < num_interrupt_in; ++i) {
1011                         endpoint = interrupt_in_endpoint[i];
1012                         port = serial->port[i];
1013                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1014                         if (!port->interrupt_in_urb) {
1015                                 dev_err(&interface->dev,
1016                                                 "No free urbs available\n");
1017                                 goto probe_error;
1018                         }
1019                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1020                         port->interrupt_in_endpointAddress =
1021                                                 endpoint->bEndpointAddress;
1022                         port->interrupt_in_buffer = kmalloc(buffer_size,
1023                                                                 GFP_KERNEL);
1024                         if (!port->interrupt_in_buffer) {
1025                                 dev_err(&interface->dev,
1026                                     "Couldn't allocate interrupt_in_buffer\n");
1027                                 goto probe_error;
1028                         }
1029                         usb_fill_int_urb(port->interrupt_in_urb, dev,
1030                                 usb_rcvintpipe(dev,
1031                                                 endpoint->bEndpointAddress),
1032                                 port->interrupt_in_buffer, buffer_size,
1033                                 serial->type->read_int_callback, port,
1034                                 endpoint->bInterval);
1035                 }
1036         } else if (num_interrupt_in) {
1037                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1038         }
1039
1040         if (serial->type->write_int_callback) {
1041                 for (i = 0; i < num_interrupt_out; ++i) {
1042                         endpoint = interrupt_out_endpoint[i];
1043                         port = serial->port[i];
1044                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1045                         if (!port->interrupt_out_urb) {
1046                                 dev_err(&interface->dev,
1047                                                 "No free urbs available\n");
1048                                 goto probe_error;
1049                         }
1050                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
1051                         port->interrupt_out_size = buffer_size;
1052                         port->interrupt_out_endpointAddress =
1053                                                 endpoint->bEndpointAddress;
1054                         port->interrupt_out_buffer = kmalloc(buffer_size,
1055                                                                 GFP_KERNEL);
1056                         if (!port->interrupt_out_buffer) {
1057                                 dev_err(&interface->dev,
1058                                   "Couldn't allocate interrupt_out_buffer\n");
1059                                 goto probe_error;
1060                         }
1061                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1062                                 usb_sndintpipe(dev,
1063                                                   endpoint->bEndpointAddress),
1064                                 port->interrupt_out_buffer, buffer_size,
1065                                 serial->type->write_int_callback, port,
1066                                 endpoint->bInterval);
1067                 }
1068         } else if (num_interrupt_out) {
1069                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1070         }
1071
1072         /* if this device type has an attach function, call it */
1073         if (type->attach) {
1074                 if (!try_module_get(type->driver.owner)) {
1075                         dev_err(&interface->dev,
1076                                         "module get failed, exiting\n");
1077                         goto probe_error;
1078                 }
1079                 retval = type->attach(serial);
1080                 module_put(type->driver.owner);
1081                 if (retval < 0)
1082                         goto probe_error;
1083                 if (retval > 0) {
1084                         /* quietly accept this device, but don't bind to a
1085                            serial port as it's about to disappear */
1086                         serial->num_ports = 0;
1087                         goto exit;
1088                 }
1089         }
1090
1091         if (get_free_serial(serial, num_ports, &minor) == NULL) {
1092                 dev_err(&interface->dev, "No more free serial devices\n");
1093                 goto probe_error;
1094         }
1095         serial->minor = minor;
1096
1097         /* register all of the individual ports with the driver core */
1098         for (i = 0; i < num_ports; ++i) {
1099                 port = serial->port[i];
1100                 port->dev.parent = &interface->dev;
1101                 port->dev.driver = NULL;
1102                 port->dev.bus = &usb_serial_bus_type;
1103                 port->dev.release = &port_release;
1104
1105                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1106                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1107                 port->dev_state = PORT_REGISTERING;
1108                 retval = device_register(&port->dev);
1109                 if (retval) {
1110                         dev_err(&port->dev, "Error registering port device, "
1111                                 "continuing\n");
1112                         port->dev_state = PORT_UNREGISTERED;
1113                 } else {
1114                         port->dev_state = PORT_REGISTERED;
1115                 }
1116         }
1117
1118         usb_serial_console_init(debug, minor);
1119
1120 exit:
1121         /* success */
1122         usb_set_intfdata(interface, serial);
1123         return 0;
1124
1125 probe_error:
1126         for (i = 0; i < num_bulk_in; ++i) {
1127                 port = serial->port[i];
1128                 if (!port)
1129                         continue;
1130                 usb_free_urb(port->read_urb);
1131                 kfree(port->bulk_in_buffer);
1132         }
1133         for (i = 0; i < num_bulk_out; ++i) {
1134                 port = serial->port[i];
1135                 if (!port)
1136                         continue;
1137                 usb_free_urb(port->write_urb);
1138                 kfree(port->bulk_out_buffer);
1139         }
1140         for (i = 0; i < num_interrupt_in; ++i) {
1141                 port = serial->port[i];
1142                 if (!port)
1143                         continue;
1144                 usb_free_urb(port->interrupt_in_urb);
1145                 kfree(port->interrupt_in_buffer);
1146         }
1147         for (i = 0; i < num_interrupt_out; ++i) {
1148                 port = serial->port[i];
1149                 if (!port)
1150                         continue;
1151                 usb_free_urb(port->interrupt_out_urb);
1152                 kfree(port->interrupt_out_buffer);
1153         }
1154
1155         /* free up any memory that we allocated */
1156         for (i = 0; i < serial->num_port_pointers; ++i)
1157                 kfree(serial->port[i]);
1158         kfree(serial);
1159         return -EIO;
1160 }
1161 EXPORT_SYMBOL_GPL(usb_serial_probe);
1162
1163 void usb_serial_disconnect(struct usb_interface *interface)
1164 {
1165         int i;
1166         struct usb_serial *serial = usb_get_intfdata(interface);
1167         struct device *dev = &interface->dev;
1168         struct usb_serial_port *port;
1169
1170         usb_serial_console_disconnect(serial);
1171         dbg("%s", __func__);
1172
1173         mutex_lock(&serial->disc_mutex);
1174         usb_set_intfdata(interface, NULL);
1175         /* must set a flag, to signal subdrivers */
1176         serial->disconnected = 1;
1177         mutex_unlock(&serial->disc_mutex);
1178
1179         for (i = 0; i < serial->num_ports; ++i) {
1180                 port = serial->port[i];
1181                 if (port) {
1182                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1183                         if (tty) {
1184                                 tty_vhangup(tty);
1185                                 tty_kref_put(tty);
1186                         }
1187                         kill_traffic(port);
1188                         cancel_work_sync(&port->work);
1189                         if (port->dev_state == PORT_REGISTERED) {
1190
1191                                 /* Make sure the port is bound so that the
1192                                  * driver's port_remove method is called.
1193                                  */
1194                                 if (!port->dev.driver) {
1195                                         int rc;
1196
1197                                         port->dev.driver =
1198                                                         &serial->type->driver;
1199                                         rc = device_bind_driver(&port->dev);
1200                                 }
1201                                 port->dev_state = PORT_UNREGISTERING;
1202                                 device_del(&port->dev);
1203                                 port->dev_state = PORT_UNREGISTERED;
1204                         }
1205                 }
1206         }
1207         serial->type->disconnect(serial);
1208
1209         /* let the last holder of this object
1210          * cause it to be cleaned up */
1211         usb_serial_put(serial);
1212         dev_info(dev, "device disconnected\n");
1213 }
1214 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1215
1216 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1217 {
1218         struct usb_serial *serial = usb_get_intfdata(intf);
1219         struct usb_serial_port *port;
1220         int i, r = 0;
1221
1222         serial->suspending = 1;
1223
1224         for (i = 0; i < serial->num_ports; ++i) {
1225                 port = serial->port[i];
1226                 if (port)
1227                         kill_traffic(port);
1228         }
1229
1230         if (serial->type->suspend)
1231                 r = serial->type->suspend(serial, message);
1232
1233         return r;
1234 }
1235 EXPORT_SYMBOL(usb_serial_suspend);
1236
1237 int usb_serial_resume(struct usb_interface *intf)
1238 {
1239         struct usb_serial *serial = usb_get_intfdata(intf);
1240         int rv;
1241
1242         serial->suspending = 0;
1243         if (serial->type->resume)
1244                 rv = serial->type->resume(serial);
1245         else
1246                 rv = usb_serial_generic_resume(serial);
1247
1248         return rv;
1249 }
1250 EXPORT_SYMBOL(usb_serial_resume);
1251
1252 static const struct tty_operations serial_ops = {
1253         .open =                 serial_open,
1254         .close =                serial_close,
1255         .write =                serial_write,
1256         .hangup =               serial_hangup,
1257         .write_room =           serial_write_room,
1258         .ioctl =                serial_ioctl,
1259         .set_termios =          serial_set_termios,
1260         .throttle =             serial_throttle,
1261         .unthrottle =           serial_unthrottle,
1262         .break_ctl =            serial_break,
1263         .chars_in_buffer =      serial_chars_in_buffer,
1264         .tiocmget =             serial_tiocmget,
1265         .tiocmset =             serial_tiocmset,
1266         .shutdown =             serial_do_free,
1267         .install =              serial_install,
1268         .proc_fops =            &serial_proc_fops,
1269 };
1270
1271
1272 struct tty_driver *usb_serial_tty_driver;
1273
1274 static int __init usb_serial_init(void)
1275 {
1276         int i;
1277         int result;
1278
1279         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1280         if (!usb_serial_tty_driver)
1281                 return -ENOMEM;
1282
1283         /* Initialize our global data */
1284         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1285                 serial_table[i] = NULL;
1286
1287         result = bus_register(&usb_serial_bus_type);
1288         if (result) {
1289                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1290                        "failed\n", __func__);
1291                 goto exit_bus;
1292         }
1293
1294         usb_serial_tty_driver->owner = THIS_MODULE;
1295         usb_serial_tty_driver->driver_name = "usbserial";
1296         usb_serial_tty_driver->name =   "ttyUSB";
1297         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1298         usb_serial_tty_driver->minor_start = 0;
1299         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1300         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1301         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1302                                                 TTY_DRIVER_DYNAMIC_DEV;
1303         usb_serial_tty_driver->init_termios = tty_std_termios;
1304         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1305                                                         | HUPCL | CLOCAL;
1306         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1307         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1308         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1309         result = tty_register_driver(usb_serial_tty_driver);
1310         if (result) {
1311                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1312                        __func__);
1313                 goto exit_reg_driver;
1314         }
1315
1316         /* register the USB driver */
1317         result = usb_register(&usb_serial_driver);
1318         if (result < 0) {
1319                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1320                        __func__);
1321                 goto exit_tty;
1322         }
1323
1324         /* register the generic driver, if we should */
1325         result = usb_serial_generic_register(debug);
1326         if (result < 0) {
1327                 printk(KERN_ERR "usb-serial: %s - registering generic "
1328                        "driver failed\n", __func__);
1329                 goto exit_generic;
1330         }
1331
1332         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1333
1334         return result;
1335
1336 exit_generic:
1337         usb_deregister(&usb_serial_driver);
1338
1339 exit_tty:
1340         tty_unregister_driver(usb_serial_tty_driver);
1341
1342 exit_reg_driver:
1343         bus_unregister(&usb_serial_bus_type);
1344
1345 exit_bus:
1346         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1347                __func__, result);
1348         put_tty_driver(usb_serial_tty_driver);
1349         return result;
1350 }
1351
1352
1353 static void __exit usb_serial_exit(void)
1354 {
1355         usb_serial_console_exit();
1356
1357         usb_serial_generic_deregister();
1358
1359         usb_deregister(&usb_serial_driver);
1360         tty_unregister_driver(usb_serial_tty_driver);
1361         put_tty_driver(usb_serial_tty_driver);
1362         bus_unregister(&usb_serial_bus_type);
1363 }
1364
1365
1366 module_init(usb_serial_init);
1367 module_exit(usb_serial_exit);
1368
1369 #define set_to_generic_if_null(type, function)                          \
1370         do {                                                            \
1371                 if (!type->function) {                                  \
1372                         type->function = usb_serial_generic_##function; \
1373                         dbg("Had to override the " #function            \
1374                                 " usb serial operation with the generic one.");\
1375                         }                                               \
1376         } while (0)
1377
1378 static void fixup_generic(struct usb_serial_driver *device)
1379 {
1380         set_to_generic_if_null(device, open);
1381         set_to_generic_if_null(device, write);
1382         set_to_generic_if_null(device, close);
1383         set_to_generic_if_null(device, write_room);
1384         set_to_generic_if_null(device, chars_in_buffer);
1385         set_to_generic_if_null(device, read_bulk_callback);
1386         set_to_generic_if_null(device, write_bulk_callback);
1387         set_to_generic_if_null(device, disconnect);
1388         set_to_generic_if_null(device, release);
1389 }
1390
1391 int usb_serial_register(struct usb_serial_driver *driver)
1392 {
1393         /* must be called with BKL held */
1394         int retval;
1395
1396         if (usb_disabled())
1397                 return -ENODEV;
1398
1399         fixup_generic(driver);
1400
1401         if (!driver->description)
1402                 driver->description = driver->driver.name;
1403
1404         /* Add this device to our list of devices */
1405         list_add(&driver->driver_list, &usb_serial_driver_list);
1406
1407         retval = usb_serial_bus_register(driver);
1408         if (retval) {
1409                 printk(KERN_ERR "usb-serial: problem %d when registering "
1410                        "driver %s\n", retval, driver->description);
1411                 list_del(&driver->driver_list);
1412         } else
1413                 printk(KERN_INFO "USB Serial support registered for %s\n",
1414                                                 driver->description);
1415
1416         return retval;
1417 }
1418 EXPORT_SYMBOL_GPL(usb_serial_register);
1419
1420
1421 void usb_serial_deregister(struct usb_serial_driver *device)
1422 {
1423         /* must be called with BKL held */
1424         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1425                device->description);
1426         list_del(&device->driver_list);
1427         usb_serial_bus_deregister(device);
1428 }
1429 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1430
1431 /* Module information */
1432 MODULE_AUTHOR(DRIVER_AUTHOR);
1433 MODULE_DESCRIPTION(DRIVER_DESC);
1434 MODULE_LICENSE("GPL");
1435
1436 module_param(debug, bool, S_IRUGO | S_IWUSR);
1437 MODULE_PARM_DESC(debug, "Debug enabled or not");