SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/usb/serial/usb-serial.c

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