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