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