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