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