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         if (serial == NULL)
 126                 return;
 127
 128         for (i = 0; i < serial->num_ports; ++i)
 129                 serial_table[serial->minor + i] = NULL;
 130 }
 131
 132 static void destroy_serial(struct kref *kref)
 133 {
 134         struct usb_serial *serial;
 135         struct usb_serial_port *port;
 136         int i;
 137
 138         serial = to_usb_serial(kref);
 139
 140         dbg("%s - %s", __func__, serial->type->description);
 141
 142         serial->type->shutdown(serial);
 143
 144         /* return the minor range that this device had */
 145         return_serial(serial);
 146
 147         for (i = 0; i < serial->num_ports; ++i)
 148                 serial->port[i]->port.count = 0;
 149
 150         /* the ports are cleaned up and released in port_release() */
 151         for (i = 0; i < serial->num_ports; ++i)
 152                 if (serial->port[i]->dev.parent != NULL) {
 153                         device_unregister(&serial->port[i]->dev);
 154                         serial->port[i] = NULL;
 155                 }
 156
 157         /* If this is a "fake" port, we have to clean it up here, as it will
 158          * not get cleaned up in port_release() as it was never registered with
 159          * the driver core */
 160         if (serial->num_ports < serial->num_port_pointers) {
 161                 for (i = serial->num_ports;
 162                                         i < serial->num_port_pointers; ++i) {
 163                         port = serial->port[i];
 164                         if (!port)
 165                                 continue;
 166                         port_free(port);
 167                 }
 168         }
 169
 170         usb_put_dev(serial->dev);
 171
 172         /* free up any memory that we allocated */
 173         kfree(serial);
 174 }
 175
 176 void usb_serial_put(struct usb_serial *serial)
 177 {
 178         mutex_lock(&table_lock);
 179         kref_put(&serial->kref, destroy_serial);
 180         mutex_unlock(&table_lock);
 181 }
 182
 183 /*****************************************************************************
 184  * Driver tty interface functions
 185  *****************************************************************************/
 186 static int serial_open (struct tty_struct *tty, struct file *filp)
 187 {
 188         struct usb_serial *serial;
 189         struct usb_serial_port *port;
 190         unsigned int portNumber;
 191         int retval;
 192
 193         dbg("%s", __func__);
 194
 195         /* get the serial object associated with this tty pointer */
 196         serial = usb_serial_get_by_index(tty->index);
 197         if (!serial) {
 198                 tty->driver_data = NULL;
 199                 return -ENODEV;
 200         }
 201
 202         portNumber = tty->index - serial->minor;
 203         port = serial->port[portNumber];
 204         if (!port) {
 205                 retval = -ENODEV;
 206                 goto bailout_kref_put;
 207         }
 208
 209         if (mutex_lock_interruptible(&port->mutex)) {
 210                 retval = -ERESTARTSYS;
 211                 goto bailout_kref_put;
 212         }
 213
 214         ++port->port.count;
 215
 216         /* set up our port structure making the tty driver
 217          * remember our port object, and us it */
 218         tty->driver_data = port;
 219         port->port.tty = tty;
 220
 221         if (port->port.count == 1) {
 222
 223                 /* lock this module before we call it
 224                  * this may fail, which means we must bail out,
 225                  * safe because we are called with BKL held */
 226                 if (!try_module_get(serial->type->driver.owner)) {
 227                         retval = -ENODEV;
 228                         goto bailout_mutex_unlock;
 229                 }
 230
 231                 retval = usb_autopm_get_interface(serial->interface);
 232                 if (retval)
 233                         goto bailout_module_put;
 234                 /* only call the device specific open if this
 235                  * is the first time the port is opened */
 236                 retval = serial->type->open(tty, port, filp);
 237                 if (retval)
 238                         goto bailout_interface_put;
 239         }
 240
 241         mutex_unlock(&port->mutex);
 242         return 0;
 243
 244 bailout_interface_put:
 245         usb_autopm_put_interface(serial->interface);
 246 bailout_module_put:
 247         module_put(serial->type->driver.owner);
 248 bailout_mutex_unlock:
 249         port->port.count = 0;
 250         tty->driver_data = NULL;
 251         port->port.tty = NULL;
 252         mutex_unlock(&port->mutex);
 253 bailout_kref_put:
 254         usb_serial_put(serial);
 255         return retval;
 256 }
 257
 258 static void serial_close(struct tty_struct *tty, struct file *filp)
 259 {
 260         struct usb_serial_port *port = tty->driver_data;
 261
 262         if (!port)
 263                 return;
 264
 265         dbg("%s - port %d", __func__, port->number);
 266
 267         mutex_lock(&port->mutex);
 268
 269         if (port->port.count == 0) {
 270                 mutex_unlock(&port->mutex);
 271                 return;
 272         }
 273
 274         --port->port.count;
 275         if (port->port.count == 0)
 276                 /* only call the device specific close if this
 277                  * port is being closed by the last owner */
 278                 port->serial->type->close(tty, port, filp);
 279
 280         if (port->port.count == (port->console? 1 : 0)) {
 281                 if (port->port.tty) {
 282                         if (port->port.tty->driver_data)
 283                                 port->port.tty->driver_data = NULL;
 284                         port->port.tty = NULL;
 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 void 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 }
 413
 414 static int serial_read_proc(char *page, char **start, off_t off, int count,
 415                                                         int *eof, void *data)
 416 {
 417         struct usb_serial *serial;
 418         int length = 0;
 419         int i;
 420         off_t begin = 0;
 421         char tmp[40];
 422
 423         dbg("%s", __func__);
 424         length += sprintf(page, "usbserinfo:1.0 driver:2.0\n");
 425         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
 426                 serial = usb_serial_get_by_index(i);
 427                 if (serial == NULL)
 428                         continue;
 429
 430                 length += sprintf(page+length, "%d:", i);
 431                 if (serial->type->driver.owner)
 432                         length += sprintf(page+length, " module:%s",
 433                                 module_name(serial->type->driver.owner));
 434                 length += sprintf(page+length, " name:\"%s\"",
 435                                 serial->type->description);
 436                 length += sprintf(page+length, " vendor:%04x product:%04x",
 437                         le16_to_cpu(serial->dev->descriptor.idVendor),
 438                         le16_to_cpu(serial->dev->descriptor.idProduct));
 439                 length += sprintf(page+length, " num_ports:%d",
 440                                                         serial->num_ports);
 441                 length += sprintf(page+length, " port:%d",
 442                                                         i - serial->minor + 1);
 443                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 444                 length += sprintf(page+length, " path:%s", tmp);
 445
 446                 length += sprintf(page+length, "\n");
 447                 if ((length + begin) > (off + count)) {
 448                         usb_serial_put(serial);
 449                         goto done;
 450                 }
 451                 if ((length + begin) < off) {
 452                         begin += length;
 453                         length = 0;
 454                 }
 455                 usb_serial_put(serial);
 456         }
 457         *eof = 1;
 458 done:
 459         if (off >= (length + begin))
 460                 return 0;
 461         *start = page + (off-begin);
 462         return (count < begin+length-off) ? count : begin+length-off;
 463 }
 464
 465 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 466 {
 467         struct usb_serial_port *port = tty->driver_data;
 468
 469         dbg("%s - port %d", __func__, port->number);
 470
 471         WARN_ON(!port->port.count);
 472         if (port->serial->type->tiocmget)
 473                 return port->serial->type->tiocmget(tty, file);
 474         return -EINVAL;
 475 }
 476
 477 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 478                             unsigned int set, unsigned int clear)
 479 {
 480         struct usb_serial_port *port = tty->driver_data;
 481
 482         dbg("%s - port %d", __func__, port->number);
 483
 484         WARN_ON(!port->port.count);
 485         if (port->serial->type->tiocmset)
 486                 return port->serial->type->tiocmset(tty, file, set, clear);
 487         return -EINVAL;
 488 }
 489
 490 /*
 491  * We would be calling tty_wakeup here, but unfortunately some line
 492  * disciplines have an annoying habit of calling tty->write from
 493  * the write wakeup callback (e.g. n_hdlc.c).
 494  */
 495 void usb_serial_port_softint(struct usb_serial_port *port)
 496 {
 497         schedule_work(&port->work);
 498 }
 499 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 500
 501 static void usb_serial_port_work(struct work_struct *work)
 502 {
 503         struct usb_serial_port *port =
 504                 container_of(work, struct usb_serial_port, work);
 505         struct tty_struct *tty;
 506
 507         dbg("%s - port %d", __func__, port->number);
 508
 509         if (!port)
 510                 return;
 511
 512         tty = port->port.tty;
 513         if (!tty)
 514                 return;
 515
 516         tty_wakeup(tty);
 517 }
 518
 519 static void port_release(struct device *dev)
 520 {
 521         struct usb_serial_port *port = to_usb_serial_port(dev);
 522
 523         dbg ("%s - %s", __func__, dev_name(dev));
 524         port_free(port);
 525 }
 526
 527 static void kill_traffic(struct usb_serial_port *port)
 528 {
 529         usb_kill_urb(port->read_urb);
 530         usb_kill_urb(port->write_urb);
 531         /*
 532          * This is tricky.
 533          * Some drivers submit the read_urb in the
 534          * handler for the write_urb or vice versa
 535          * this order determines the order in which
 536          * usb_kill_urb() must be used to reliably
 537          * kill the URBs. As it is unknown here,
 538          * both orders must be used in turn.
 539          * The call below is not redundant.
 540          */
 541         usb_kill_urb(port->read_urb);
 542         usb_kill_urb(port->interrupt_in_urb);
 543         usb_kill_urb(port->interrupt_out_urb);
 544 }
 545
 546 static void port_free(struct usb_serial_port *port)
 547 {
 548         kill_traffic(port);
 549         usb_free_urb(port->read_urb);
 550         usb_free_urb(port->write_urb);
 551         usb_free_urb(port->interrupt_in_urb);
 552         usb_free_urb(port->interrupt_out_urb);
 553         kfree(port->bulk_in_buffer);
 554         kfree(port->bulk_out_buffer);
 555         kfree(port->interrupt_in_buffer);
 556         kfree(port->interrupt_out_buffer);
 557         flush_scheduled_work();         /* port->work */
 558         kfree(port);
 559 }
 560
 561 static struct usb_serial *create_serial(struct usb_device *dev,
 562                                         struct usb_interface *interface,
 563                                         struct usb_serial_driver *driver)
 564 {
 565         struct usb_serial *serial;
 566
 567         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 568         if (!serial) {
 569                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
 570                 return NULL;
 571         }
 572         serial->dev = usb_get_dev(dev);
 573         serial->type = driver;
 574         serial->interface = interface;
 575         kref_init(&serial->kref);
 576         mutex_init(&serial->disc_mutex);
 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                 if (interface != dev->actconfig->interface[0]) {
 738                         /* check out the endpoints of the other interface*/
 739                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 740                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 741                                 endpoint = &iface_desc->endpoint[i].desc;
 742                                 if (usb_endpoint_is_int_in(endpoint)) {
 743                                         /* we found a interrupt in endpoint */
 744                                         dbg("found interrupt in for Prolific device on separate interface");
 745                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 746                                         ++num_interrupt_in;
 747                                 }
 748                         }
 749                 }
 750
 751                 /* Now make sure the PL-2303 is configured correctly.
 752                  * If not, give up now and hope this hack will work
 753                  * properly during a later invocation of usb_serial_probe
 754                  */
 755                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 756                         unlock_kernel();
 757                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 758                         kfree(serial);
 759                         return -ENODEV;
 760                 }
 761         }
 762         /* END HORRIBLE HACK FOR PL2303 */
 763 #endif
 764
 765 #ifdef CONFIG_USB_SERIAL_GENERIC
 766         if (type == &usb_serial_generic_device) {
 767                 num_ports = num_bulk_out;
 768                 if (num_ports == 0) {
 769                         unlock_kernel();
 770                         dev_err(&interface->dev,
 771                             "Generic device with no bulk out, not allowed.\n");
 772                         kfree(serial);
 773                         return -EIO;
 774                 }
 775         }
 776 #endif
 777         if (!num_ports) {
 778                 /* if this device type has a calc_num_ports function, call it */
 779                 if (type->calc_num_ports) {
 780                         if (!try_module_get(type->driver.owner)) {
 781                                 unlock_kernel();
 782                                 dev_err(&interface->dev,
 783                                         "module get failed, exiting\n");
 784                                 kfree(serial);
 785                                 return -EIO;
 786                         }
 787                         num_ports = type->calc_num_ports(serial);
 788                         module_put(type->driver.owner);
 789                 }
 790                 if (!num_ports)
 791                         num_ports = type->num_ports;
 792         }
 793
 794         serial->num_ports = num_ports;
 795         serial->num_bulk_in = num_bulk_in;
 796         serial->num_bulk_out = num_bulk_out;
 797         serial->num_interrupt_in = num_interrupt_in;
 798         serial->num_interrupt_out = num_interrupt_out;
 799
 800         /* found all that we need */
 801         dev_info(&interface->dev, "%s converter detected\n",
 802                         type->description);
 803
 804         /* create our ports, we need as many as the max endpoints */
 805         /* we don't use num_ports here because some devices have more
 806            endpoint pairs than ports */
 807         max_endpoints = max(num_bulk_in, num_bulk_out);
 808         max_endpoints = max(max_endpoints, num_interrupt_in);
 809         max_endpoints = max(max_endpoints, num_interrupt_out);
 810         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 811         serial->num_port_pointers = max_endpoints;
 812         unlock_kernel();
 813
 814         dbg("%s - setting up %d port structures for this device",
 815                                                 __func__, max_endpoints);
 816         for (i = 0; i < max_endpoints; ++i) {
 817                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 818                 if (!port)
 819                         goto probe_error;
 820                 port->serial = serial;
 821                 spin_lock_init(&port->lock);
 822                 mutex_init(&port->mutex);
 823                 INIT_WORK(&port->work, usb_serial_port_work);
 824                 serial->port[i] = port;
 825         }
 826
 827         /* set up the endpoint information */
 828         for (i = 0; i < num_bulk_in; ++i) {
 829                 endpoint = bulk_in_endpoint[i];
 830                 port = serial->port[i];
 831                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 832                 if (!port->read_urb) {
 833                         dev_err(&interface->dev, "No free urbs available\n");
 834                         goto probe_error;
 835                 }
 836                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 837                 port->bulk_in_size = buffer_size;
 838                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 839                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 840                 if (!port->bulk_in_buffer) {
 841                         dev_err(&interface->dev,
 842                                         "Couldn't allocate bulk_in_buffer\n");
 843                         goto probe_error;
 844                 }
 845                 usb_fill_bulk_urb(port->read_urb, dev,
 846                                 usb_rcvbulkpipe(dev,
 847                                                 endpoint->bEndpointAddress),
 848                                 port->bulk_in_buffer, buffer_size,
 849                                 serial->type->read_bulk_callback, port);
 850         }
 851
 852         for (i = 0; i < num_bulk_out; ++i) {
 853                 endpoint = bulk_out_endpoint[i];
 854                 port = serial->port[i];
 855                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 856                 if (!port->write_urb) {
 857                         dev_err(&interface->dev, "No free urbs available\n");
 858                         goto probe_error;
 859                 }
 860                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 861                 port->bulk_out_size = buffer_size;
 862                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 863                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 864                 if (!port->bulk_out_buffer) {
 865                         dev_err(&interface->dev,
 866                                         "Couldn't allocate bulk_out_buffer\n");
 867                         goto probe_error;
 868                 }
 869                 usb_fill_bulk_urb(port->write_urb, dev,
 870                                 usb_sndbulkpipe(dev,
 871                                         endpoint->bEndpointAddress),
 872                                 port->bulk_out_buffer, buffer_size,
 873                                 serial->type->write_bulk_callback, port);
 874         }
 875
 876         if (serial->type->read_int_callback) {
 877                 for (i = 0; i < num_interrupt_in; ++i) {
 878                         endpoint = interrupt_in_endpoint[i];
 879                         port = serial->port[i];
 880                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 881                         if (!port->interrupt_in_urb) {
 882                                 dev_err(&interface->dev,
 883                                                 "No free urbs available\n");
 884                                 goto probe_error;
 885                         }
 886                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 887                         port->interrupt_in_endpointAddress =
 888                                                 endpoint->bEndpointAddress;
 889                         port->interrupt_in_buffer = kmalloc(buffer_size,
 890                                                                 GFP_KERNEL);
 891                         if (!port->interrupt_in_buffer) {
 892                                 dev_err(&interface->dev,
 893                                     "Couldn't allocate interrupt_in_buffer\n");
 894                                 goto probe_error;
 895                         }
 896                         usb_fill_int_urb(port->interrupt_in_urb, dev,
 897                                 usb_rcvintpipe(dev,
 898                                                 endpoint->bEndpointAddress),
 899                                 port->interrupt_in_buffer, buffer_size,
 900                                 serial->type->read_int_callback, port,
 901                                 endpoint->bInterval);
 902                 }
 903         } else if (num_interrupt_in) {
 904                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
 905         }
 906
 907         if (serial->type->write_int_callback) {
 908                 for (i = 0; i < num_interrupt_out; ++i) {
 909                         endpoint = interrupt_out_endpoint[i];
 910                         port = serial->port[i];
 911                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 912                         if (!port->interrupt_out_urb) {
 913                                 dev_err(&interface->dev,
 914                                                 "No free urbs available\n");
 915                                 goto probe_error;
 916                         }
 917                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 918                         port->interrupt_out_size = buffer_size;
 919                         port->interrupt_out_endpointAddress =
 920                                                 endpoint->bEndpointAddress;
 921                         port->interrupt_out_buffer = kmalloc(buffer_size,
 922                                                                 GFP_KERNEL);
 923                         if (!port->interrupt_out_buffer) {
 924                                 dev_err(&interface->dev,
 925                                   "Couldn't allocate interrupt_out_buffer\n");
 926                                 goto probe_error;
 927                         }
 928                         usb_fill_int_urb(port->interrupt_out_urb, dev,
 929                                 usb_sndintpipe(dev,
 930                                                   endpoint->bEndpointAddress),
 931                                 port->interrupt_out_buffer, buffer_size,
 932                                 serial->type->write_int_callback, port,
 933                                 endpoint->bInterval);
 934                 }
 935         } else if (num_interrupt_out) {
 936                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
 937         }
 938
 939         /* if this device type has an attach function, call it */
 940         if (type->attach) {
 941                 if (!try_module_get(type->driver.owner)) {
 942                         dev_err(&interface->dev,
 943                                         "module get failed, exiting\n");
 944                         goto probe_error;
 945                 }
 946                 retval = type->attach(serial);
 947                 module_put(type->driver.owner);
 948                 if (retval < 0)
 949                         goto probe_error;
 950                 if (retval > 0) {
 951                         /* quietly accept this device, but don't bind to a
 952                            serial port as it's about to disappear */
 953                         goto exit;
 954                 }
 955         }
 956
 957         if (get_free_serial(serial, num_ports, &minor) == NULL) {
 958                 dev_err(&interface->dev, "No more free serial devices\n");
 959                 goto probe_error;
 960         }
 961         serial->minor = minor;
 962
 963         /* register all of the individual ports with the driver core */
 964         for (i = 0; i < num_ports; ++i) {
 965                 port = serial->port[i];
 966                 port->dev.parent = &interface->dev;
 967                 port->dev.driver = NULL;
 968                 port->dev.bus = &usb_serial_bus_type;
 969                 port->dev.release = &port_release;
 970
 971                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
 972                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
 973                 retval = device_register(&port->dev);
 974                 if (retval)
 975                         dev_err(&port->dev, "Error registering port device, "
 976                                 "continuing\n");
 977         }
 978
 979         usb_serial_console_init(debug, minor);
 980
 981 exit:
 982         /* success */
 983         usb_set_intfdata(interface, serial);
 984         return 0;
 985
 986 probe_error:
 987         for (i = 0; i < num_bulk_in; ++i) {
 988                 port = serial->port[i];
 989                 if (!port)
 990                         continue;
 991                 usb_free_urb(port->read_urb);
 992                 kfree(port->bulk_in_buffer);
 993         }
 994         for (i = 0; i < num_bulk_out; ++i) {
 995                 port = serial->port[i];
 996                 if (!port)
 997                         continue;
 998                 usb_free_urb(port->write_urb);
 999                 kfree(port->bulk_out_buffer);
1000         }
1001         for (i = 0; i < num_interrupt_in; ++i) {
1002                 port = serial->port[i];
1003                 if (!port)
1004                         continue;
1005                 usb_free_urb(port->interrupt_in_urb);
1006                 kfree(port->interrupt_in_buffer);
1007         }
1008         for (i = 0; i < num_interrupt_out; ++i) {
1009                 port = serial->port[i];
1010                 if (!port)
1011                         continue;
1012                 usb_free_urb(port->interrupt_out_urb);
1013                 kfree(port->interrupt_out_buffer);
1014         }
1015
1016         /* free up any memory that we allocated */
1017         for (i = 0; i < serial->num_port_pointers; ++i)
1018                 kfree(serial->port[i]);
1019         kfree(serial);
1020         return -EIO;
1021 }
1022 EXPORT_SYMBOL_GPL(usb_serial_probe);
1023
1024 void usb_serial_disconnect(struct usb_interface *interface)
1025 {
1026         int i;
1027         struct usb_serial *serial = usb_get_intfdata(interface);
1028         struct device *dev = &interface->dev;
1029         struct usb_serial_port *port;
1030
1031         usb_serial_console_disconnect(serial);
1032         dbg("%s", __func__);
1033
1034         mutex_lock(&serial->disc_mutex);
1035         usb_set_intfdata(interface, NULL);
1036         /* must set a flag, to signal subdrivers */
1037         serial->disconnected = 1;
1038         for (i = 0; i < serial->num_ports; ++i) {
1039                 port = serial->port[i];
1040                 if (port) {
1041                         if (port->port.tty)
1042                                 tty_hangup(port->port.tty);
1043                         kill_traffic(port);
1044                 }
1045         }
1046         /* let the last holder of this object
1047          * cause it to be cleaned up */
1048         mutex_unlock(&serial->disc_mutex);
1049         usb_serial_put(serial);
1050         dev_info(dev, "device disconnected\n");
1051 }
1052 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1053
1054 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1055 {
1056         struct usb_serial *serial = usb_get_intfdata(intf);
1057         struct usb_serial_port *port;
1058         int i, r = 0;
1059
1060         for (i = 0; i < serial->num_ports; ++i) {
1061                 port = serial->port[i];
1062                 if (port)
1063                         kill_traffic(port);
1064         }
1065
1066         if (serial->type->suspend)
1067                 r = serial->type->suspend(serial, message);
1068
1069         return r;
1070 }
1071 EXPORT_SYMBOL(usb_serial_suspend);
1072
1073 int usb_serial_resume(struct usb_interface *intf)
1074 {
1075         struct usb_serial *serial = usb_get_intfdata(intf);
1076
1077         if (serial->type->resume)
1078                 return serial->type->resume(serial);
1079         return 0;
1080 }
1081 EXPORT_SYMBOL(usb_serial_resume);
1082
1083 static const struct tty_operations serial_ops = {
1084         .open =                 serial_open,
1085         .close =                serial_close,
1086         .write =                serial_write,
1087         .write_room =           serial_write_room,
1088         .ioctl =                serial_ioctl,
1089         .set_termios =          serial_set_termios,
1090         .throttle =             serial_throttle,
1091         .unthrottle =           serial_unthrottle,
1092         .break_ctl =            serial_break,
1093         .chars_in_buffer =      serial_chars_in_buffer,
1094         .read_proc =            serial_read_proc,
1095         .tiocmget =             serial_tiocmget,
1096         .tiocmset =             serial_tiocmset,
1097 };
1098
1099 struct tty_driver *usb_serial_tty_driver;
1100
1101 static int __init usb_serial_init(void)
1102 {
1103         int i;
1104         int result;
1105
1106         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1107         if (!usb_serial_tty_driver)
1108                 return -ENOMEM;
1109
1110         /* Initialize our global data */
1111         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1112                 serial_table[i] = NULL;
1113
1114         result = bus_register(&usb_serial_bus_type);
1115         if (result) {
1116                 err("%s - registering bus driver failed", __func__);
1117                 goto exit_bus;
1118         }
1119
1120         usb_serial_tty_driver->owner = THIS_MODULE;
1121         usb_serial_tty_driver->driver_name = "usbserial";
1122         usb_serial_tty_driver->name =   "ttyUSB";
1123         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1124         usb_serial_tty_driver->minor_start = 0;
1125         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1126         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1127         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1128                                                 TTY_DRIVER_DYNAMIC_DEV;
1129         usb_serial_tty_driver->init_termios = tty_std_termios;
1130         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1131                                                         | HUPCL | CLOCAL;
1132         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1133         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1134         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1135         result = tty_register_driver(usb_serial_tty_driver);
1136         if (result) {
1137                 err("%s - tty_register_driver failed", __func__);
1138                 goto exit_reg_driver;
1139         }
1140
1141         /* register the USB driver */
1142         result = usb_register(&usb_serial_driver);
1143         if (result < 0) {
1144                 err("%s - usb_register failed", __func__);
1145                 goto exit_tty;
1146         }
1147
1148         /* register the generic driver, if we should */
1149         result = usb_serial_generic_register(debug);
1150         if (result < 0) {
1151                 err("%s - registering generic driver failed", __func__);
1152                 goto exit_generic;
1153         }
1154
1155         info(DRIVER_DESC);
1156
1157         return result;
1158
1159 exit_generic:
1160         usb_deregister(&usb_serial_driver);
1161
1162 exit_tty:
1163         tty_unregister_driver(usb_serial_tty_driver);
1164
1165 exit_reg_driver:
1166         bus_unregister(&usb_serial_bus_type);
1167
1168 exit_bus:
1169         err("%s - returning with error %d", __func__, result);
1170         put_tty_driver(usb_serial_tty_driver);
1171         return result;
1172 }
1173
1174
1175 static void __exit usb_serial_exit(void)
1176 {
1177         usb_serial_console_exit();
1178
1179         usb_serial_generic_deregister();
1180
1181         usb_deregister(&usb_serial_driver);
1182         tty_unregister_driver(usb_serial_tty_driver);
1183         put_tty_driver(usb_serial_tty_driver);
1184         bus_unregister(&usb_serial_bus_type);
1185 }
1186
1187
1188 module_init(usb_serial_init);
1189 module_exit(usb_serial_exit);
1190
1191 #define set_to_generic_if_null(type, function)                          \
1192         do {                                                            \
1193                 if (!type->function) {                                  \
1194                         type->function = usb_serial_generic_##function; \
1195                         dbg("Had to override the " #function            \
1196                                 " usb serial operation with the generic one.");\
1197                         }                                               \
1198         } while (0)
1199
1200 static void fixup_generic(struct usb_serial_driver *device)
1201 {
1202         set_to_generic_if_null(device, open);
1203         set_to_generic_if_null(device, write);
1204         set_to_generic_if_null(device, close);
1205         set_to_generic_if_null(device, write_room);
1206         set_to_generic_if_null(device, chars_in_buffer);
1207         set_to_generic_if_null(device, read_bulk_callback);
1208         set_to_generic_if_null(device, write_bulk_callback);
1209         set_to_generic_if_null(device, shutdown);
1210         set_to_generic_if_null(device, resume);
1211 }
1212
1213 int usb_serial_register(struct usb_serial_driver *driver)
1214 {
1215         /* must be called with BKL held */
1216         int retval;
1217
1218         fixup_generic(driver);
1219
1220         if (!driver->description)
1221                 driver->description = driver->driver.name;
1222
1223         /* Add this device to our list of devices */
1224         list_add(&driver->driver_list, &usb_serial_driver_list);
1225
1226         retval = usb_serial_bus_register(driver);
1227         if (retval) {
1228                 err("problem %d when registering driver %s",
1229                                                 retval, driver->description);
1230                 list_del(&driver->driver_list);
1231         } else
1232                 info("USB Serial support registered for %s",
1233                                                 driver->description);
1234
1235         return retval;
1236 }
1237 EXPORT_SYMBOL_GPL(usb_serial_register);
1238
1239
1240 void usb_serial_deregister(struct usb_serial_driver *device)
1241 {
1242         /* must be called with BKL held */
1243         info("USB Serial deregistering driver %s", device->description);
1244         list_del(&device->driver_list);
1245         usb_serial_bus_deregister(device);
1246 }
1247 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1248
1249 /* Module information */
1250 MODULE_AUTHOR(DRIVER_AUTHOR);
1251 MODULE_DESCRIPTION(DRIVER_DESC);
1252 MODULE_LICENSE("GPL");
1253
1254 module_param(debug, bool, S_IRUGO | S_IWUSR);
1255 MODULE_PARM_DESC(debug, "Debug enabled or not");