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