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