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