drivers/usb/serial/keyspan_pda.c

   1 /*
   2  * USB Keyspan PDA / Xircom / Entrega Converter driver
   3  *
   4  * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com>
   5  * Copyright (C) 1999, 2000 Brian Warner        <warner@lothar.com>
   6  * Copyright (C) 2000 Al Borchers               <borchers@steinerpoint.com>
   7  *
   8  *      This program is free software; you can redistribute it and/or modify
   9  *      it under the terms of the GNU General Public License as published by
  10  *      the Free Software Foundation; either version 2 of the License, or
  11  *      (at your option) any later version.
  12  *
  13  * See Documentation/usb/usb-serial.txt for more information on using this
  14  * driver
  15  */
  16
  17
  18 #include <linux/kernel.h>
  19 #include <linux/errno.h>
  20 #include <linux/slab.h>
  21 #include <linux/tty.h>
  22 #include <linux/tty_driver.h>
  23 #include <linux/tty_flip.h>
  24 #include <linux/module.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/workqueue.h>
  27 #include <linux/uaccess.h>
  28 #include <linux/usb.h>
  29 #include <linux/usb/serial.h>
  30 #include <linux/usb/ezusb.h>
  31
  32 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */
  33 #if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
  34         #define KEYSPAN
  35 #else
  36         #undef KEYSPAN
  37 #endif
  38 #if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
  39         #define XIRCOM
  40 #else
  41         #undef XIRCOM
  42 #endif
  43
  44 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
  45 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
  46
  47 struct keyspan_pda_private {
  48         int                     tx_room;
  49         int                     tx_throttled;
  50         struct work_struct                      wakeup_work;
  51         struct work_struct                      unthrottle_work;
  52         struct usb_serial       *serial;
  53         struct usb_serial_port  *port;
  54 };
  55
  56
  57 #define KEYSPAN_VENDOR_ID               0x06cd
  58 #define KEYSPAN_PDA_FAKE_ID             0x0103
  59 #define KEYSPAN_PDA_ID                  0x0104 /* no clue */
  60
  61 /* For Xircom PGSDB9 and older Entrega version of the same device */
  62 #define XIRCOM_VENDOR_ID                0x085a
  63 #define XIRCOM_FAKE_ID                  0x8027
  64 #define XIRCOM_FAKE_ID_2                0x8025 /* "PGMFHUB" serial */
  65 #define ENTREGA_VENDOR_ID               0x1645
  66 #define ENTREGA_FAKE_ID                 0x8093
  67
  68 static const struct usb_device_id id_table_combined[] = {
  69 #ifdef KEYSPAN
  70         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
  71 #endif
  72 #ifdef XIRCOM
  73         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
  74         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
  75         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
  76 #endif
  77         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
  78         { }                                             /* Terminating entry */
  79 };
  80
  81 MODULE_DEVICE_TABLE(usb, id_table_combined);
  82
  83 static const struct usb_device_id id_table_std[] = {
  84         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
  85         { }                                             /* Terminating entry */
  86 };
  87
  88 #ifdef KEYSPAN
  89 static const struct usb_device_id id_table_fake[] = {
  90         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
  91         { }                                             /* Terminating entry */
  92 };
  93 #endif
  94
  95 #ifdef XIRCOM
  96 static const struct usb_device_id id_table_fake_xircom[] = {
  97         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
  98         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
  99         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 100         { }
 101 };
 102 #endif
 103
 104 static void keyspan_pda_wakeup_write(struct work_struct *work)
 105 {
 106         struct keyspan_pda_private *priv =
 107                 container_of(work, struct keyspan_pda_private, wakeup_work);
 108         struct usb_serial_port *port = priv->port;
 109
 110         tty_port_tty_wakeup(&port->port);
 111 }
 112
 113 static void keyspan_pda_request_unthrottle(struct work_struct *work)
 114 {
 115         struct keyspan_pda_private *priv =
 116                 container_of(work, struct keyspan_pda_private, unthrottle_work);
 117         struct usb_serial *serial = priv->serial;
 118         int result;
 119
 120         /* ask the device to tell us when the tx buffer becomes
 121            sufficiently empty */
 122         result = usb_control_msg(serial->dev,
 123                                  usb_sndctrlpipe(serial->dev, 0),
 124                                  7, /* request_unthrottle */
 125                                  USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 126                                  | USB_DIR_OUT,
 127                                  16, /* value: threshold */
 128                                  0, /* index */
 129                                  NULL,
 130                                  0,
 131                                  2000);
 132         if (result < 0)
 133                 dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
 134                         __func__, result);
 135 }
 136
 137
 138 static void keyspan_pda_rx_interrupt(struct urb *urb)
 139 {
 140         struct usb_serial_port *port = urb->context;
 141         unsigned char *data = urb->transfer_buffer;
 142         unsigned int len = urb->actual_length;
 143         int retval;
 144         int status = urb->status;
 145         struct keyspan_pda_private *priv;
 146         priv = usb_get_serial_port_data(port);
 147
 148         switch (status) {
 149         case 0:
 150                 /* success */
 151                 break;
 152         case -ECONNRESET:
 153         case -ENOENT:
 154         case -ESHUTDOWN:
 155                 /* this urb is terminated, clean up */
 156                 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
 157                 return;
 158         default:
 159                 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
 160                 goto exit;
 161         }
 162
 163         if (len < 1) {
 164                 dev_warn(&port->dev, "short message received\n");
 165                 goto exit;
 166         }
 167
 168         /* see if the message is data or a status interrupt */
 169         switch (data[0]) {
 170         case 0:
 171                  /* rest of message is rx data */
 172                 if (len < 2)
 173                         break;
 174                 tty_insert_flip_string(&port->port, data + 1, len - 1);
 175                 tty_flip_buffer_push(&port->port);
 176                 break;
 177         case 1:
 178                 /* status interrupt */
 179                 if (len < 3) {
 180                         dev_warn(&port->dev, "short interrupt message received\n");
 181                         break;
 182                 }
 183                 dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
 184                 switch (data[1]) {
 185                 case 1: /* modemline change */
 186                         break;
 187                 case 2: /* tx unthrottle interrupt */
 188                         priv->tx_throttled = 0;
 189                         /* queue up a wakeup at scheduler time */
 190                         schedule_work(&priv->wakeup_work);
 191                         break;
 192                 default:
 193                         break;
 194                 }
 195                 break;
 196         default:
 197                 break;
 198         }
 199
 200 exit:
 201         retval = usb_submit_urb(urb, GFP_ATOMIC);
 202         if (retval)
 203                 dev_err(&port->dev,
 204                         "%s - usb_submit_urb failed with result %d\n",
 205                         __func__, retval);
 206 }
 207
 208
 209 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 210 {
 211         /* stop receiving characters. We just turn off the URB request, and
 212            let chars pile up in the device. If we're doing hardware
 213            flowcontrol, the device will signal the other end when its buffer
 214            fills up. If we're doing XON/XOFF, this would be a good time to
 215            send an XOFF, although it might make sense to foist that off
 216            upon the device too. */
 217         struct usb_serial_port *port = tty->driver_data;
 218
 219         usb_kill_urb(port->interrupt_in_urb);
 220 }
 221
 222
 223 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 224 {
 225         struct usb_serial_port *port = tty->driver_data;
 226         /* just restart the receive interrupt URB */
 227
 228         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
 229                 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
 230 }
 231
 232
 233 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
 234 {
 235         int rc;
 236         int bindex;
 237
 238         switch (baud) {
 239         case 110:
 240                 bindex = 0;
 241                 break;
 242         case 300:
 243                 bindex = 1;
 244                 break;
 245         case 1200:
 246                 bindex = 2;
 247                 break;
 248         case 2400:
 249                 bindex = 3;
 250                 break;
 251         case 4800:
 252                 bindex = 4;
 253                 break;
 254         case 9600:
 255                 bindex = 5;
 256                 break;
 257         case 19200:
 258                 bindex = 6;
 259                 break;
 260         case 38400:
 261                 bindex = 7;
 262                 break;
 263         case 57600:
 264                 bindex = 8;
 265                 break;
 266         case 115200:
 267                 bindex = 9;
 268                 break;
 269         default:
 270                 bindex = 5;     /* Default to 9600 */
 271                 baud = 9600;
 272         }
 273
 274         /* rather than figure out how to sleep while waiting for this
 275            to complete, I just use the "legacy" API. */
 276         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 277                              0, /* set baud */
 278                              USB_TYPE_VENDOR
 279                              | USB_RECIP_INTERFACE
 280                              | USB_DIR_OUT, /* type */
 281                              bindex, /* value */
 282                              0, /* index */
 283                              NULL, /* &data */
 284                              0, /* size */
 285                              2000); /* timeout */
 286         if (rc < 0)
 287                 return 0;
 288         return baud;
 289 }
 290
 291
 292 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 293 {
 294         struct usb_serial_port *port = tty->driver_data;
 295         struct usb_serial *serial = port->serial;
 296         int value;
 297         int result;
 298
 299         if (break_state == -1)
 300                 value = 1; /* start break */
 301         else
 302                 value = 0; /* clear break */
 303         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 304                         4, /* set break */
 305                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
 306                         value, 0, NULL, 0, 2000);
 307         if (result < 0)
 308                 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
 309                         __func__, result);
 310         /* there is something funky about this.. the TCSBRK that 'cu' performs
 311            ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
 312            seconds apart, but it feels like the break sent isn't as long as it
 313            is on /dev/ttyS0 */
 314 }
 315
 316
 317 static void keyspan_pda_set_termios(struct tty_struct *tty,
 318                 struct usb_serial_port *port, struct ktermios *old_termios)
 319 {
 320         struct usb_serial *serial = port->serial;
 321         speed_t speed;
 322
 323         /* cflag specifies lots of stuff: number of stop bits, parity, number
 324            of data bits, baud. What can the device actually handle?:
 325            CSTOPB (1 stop bit or 2)
 326            PARENB (parity)
 327            CSIZE (5bit .. 8bit)
 328            There is minimal hw support for parity (a PSW bit seems to hold the
 329            parity of whatever is in the accumulator). The UART either deals
 330            with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
 331            1 special, stop). So, with firmware changes, we could do:
 332            8N1: 10 bit
 333            8N2: 11 bit, extra bit always (mark?)
 334            8[EOMS]1: 11 bit, extra bit is parity
 335            7[EOMS]1: 10 bit, b0/b7 is parity
 336            7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
 337
 338            HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
 339            bit.
 340
 341            For now, just do baud. */
 342
 343         speed = tty_get_baud_rate(tty);
 344         speed = keyspan_pda_setbaud(serial, speed);
 345
 346         if (speed == 0) {
 347                 dev_dbg(&port->dev, "can't handle requested baud rate\n");
 348                 /* It hasn't changed so.. */
 349                 speed = tty_termios_baud_rate(old_termios);
 350         }
 351         /* Only speed can change so copy the old h/w parameters
 352            then encode the new speed */
 353         tty_termios_copy_hw(&tty->termios, old_termios);
 354         tty_encode_baud_rate(tty, speed, speed);
 355 }
 356
 357
 358 /* modem control pins: DTR and RTS are outputs and can be controlled.
 359    DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
 360    read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
 361
 362 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
 363                                       unsigned char *value)
 364 {
 365         int rc;
 366         u8 *data;
 367
 368         data = kmalloc(1, GFP_KERNEL);
 369         if (!data)
 370                 return -ENOMEM;
 371
 372         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 373                              3, /* get pins */
 374                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
 375                              0, 0, data, 1, 2000);
 376         if (rc == 1)
 377                 *value = *data;
 378         else if (rc >= 0)
 379                 rc = -EIO;
 380
 381         kfree(data);
 382         return rc;
 383 }
 384
 385
 386 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 387                                       unsigned char value)
 388 {
 389         int rc;
 390         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 391                              3, /* set pins */
 392                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 393                              value, 0, NULL, 0, 2000);
 394         return rc;
 395 }
 396
 397 static int keyspan_pda_tiocmget(struct tty_struct *tty)
 398 {
 399         struct usb_serial_port *port = tty->driver_data;
 400         struct usb_serial *serial = port->serial;
 401         int rc;
 402         unsigned char status;
 403         int value;
 404
 405         rc = keyspan_pda_get_modem_info(serial, &status);
 406         if (rc < 0)
 407                 return rc;
 408         value =
 409                 ((status & (1<<7)) ? TIOCM_DTR : 0) |
 410                 ((status & (1<<6)) ? TIOCM_CAR : 0) |
 411                 ((status & (1<<5)) ? TIOCM_RNG : 0) |
 412                 ((status & (1<<4)) ? TIOCM_DSR : 0) |
 413                 ((status & (1<<3)) ? TIOCM_CTS : 0) |
 414                 ((status & (1<<2)) ? TIOCM_RTS : 0);
 415         return value;
 416 }
 417
 418 static int keyspan_pda_tiocmset(struct tty_struct *tty,
 419                                 unsigned int set, unsigned int clear)
 420 {
 421         struct usb_serial_port *port = tty->driver_data;
 422         struct usb_serial *serial = port->serial;
 423         int rc;
 424         unsigned char status;
 425
 426         rc = keyspan_pda_get_modem_info(serial, &status);
 427         if (rc < 0)
 428                 return rc;
 429
 430         if (set & TIOCM_RTS)
 431                 status |= (1<<2);
 432         if (set & TIOCM_DTR)
 433                 status |= (1<<7);
 434
 435         if (clear & TIOCM_RTS)
 436                 status &= ~(1<<2);
 437         if (clear & TIOCM_DTR)
 438                 status &= ~(1<<7);
 439         rc = keyspan_pda_set_modem_info(serial, status);
 440         return rc;
 441 }
 442
 443 static int keyspan_pda_write(struct tty_struct *tty,
 444         struct usb_serial_port *port, const unsigned char *buf, int count)
 445 {
 446         struct usb_serial *serial = port->serial;
 447         int request_unthrottle = 0;
 448         int rc = 0;
 449         struct keyspan_pda_private *priv;
 450
 451         priv = usb_get_serial_port_data(port);
 452         /* guess how much room is left in the device's ring buffer, and if we
 453            want to send more than that, check first, updating our notion of
 454            what is left. If our write will result in no room left, ask the
 455            device to give us an interrupt when the room available rises above
 456            a threshold, and hold off all writers (eventually, those using
 457            select() or poll() too) until we receive that unthrottle interrupt.
 458            Block if we can't write anything at all, otherwise write as much as
 459            we can. */
 460         if (count == 0) {
 461                 dev_dbg(&port->dev, "write request of 0 bytes\n");
 462                 return 0;
 463         }
 464
 465         /* we might block because of:
 466            the TX urb is in-flight (wait until it completes)
 467            the device is full (wait until it says there is room)
 468         */
 469         spin_lock_bh(&port->lock);
 470         if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
 471                 spin_unlock_bh(&port->lock);
 472                 return 0;
 473         }
 474         clear_bit(0, &port->write_urbs_free);
 475         spin_unlock_bh(&port->lock);
 476
 477         /* At this point the URB is in our control, nobody else can submit it
 478            again (the only sudden transition was the one from EINPROGRESS to
 479            finished).  Also, the tx process is not throttled. So we are
 480            ready to write. */
 481
 482         count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
 483
 484         /* Check if we might overrun the Tx buffer.   If so, ask the
 485            device how much room it really has.  This is done only on
 486            scheduler time, since usb_control_msg() sleeps. */
 487         if (count > priv->tx_room && !in_interrupt()) {
 488                 u8 *room;
 489
 490                 room = kmalloc(1, GFP_KERNEL);
 491                 if (!room) {
 492                         rc = -ENOMEM;
 493                         goto exit;
 494                 }
 495
 496                 rc = usb_control_msg(serial->dev,
 497                                      usb_rcvctrlpipe(serial->dev, 0),
 498                                      6, /* write_room */
 499                                      USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 500                                      | USB_DIR_IN,
 501                                      0, /* value: 0 means "remaining room" */
 502                                      0, /* index */
 503                                      room,
 504                                      1,
 505                                      2000);
 506                 if (rc > 0) {
 507                         dev_dbg(&port->dev, "roomquery says %d\n", *room);
 508                         priv->tx_room = *room;
 509                 }
 510                 kfree(room);
 511                 if (rc < 0) {
 512                         dev_dbg(&port->dev, "roomquery failed\n");
 513                         goto exit;
 514                 }
 515                 if (rc == 0) {
 516                         dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
 517                         rc = -EIO; /* device didn't return any data */
 518                         goto exit;
 519                 }
 520         }
 521         if (count > priv->tx_room) {
 522                 /* we're about to completely fill the Tx buffer, so
 523                    we'll be throttled afterwards. */
 524                 count = priv->tx_room;
 525                 request_unthrottle = 1;
 526         }
 527
 528         if (count) {
 529                 /* now transfer data */
 530                 memcpy(port->write_urb->transfer_buffer, buf, count);
 531                 /* send the data out the bulk port */
 532                 port->write_urb->transfer_buffer_length = count;
 533
 534                 priv->tx_room -= count;
 535
 536                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 537                 if (rc) {
 538                         dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
 539                         goto exit;
 540                 }
 541         } else {
 542                 /* There wasn't any room left, so we are throttled until
 543                    the buffer empties a bit */
 544                 request_unthrottle = 1;
 545         }
 546
 547         if (request_unthrottle) {
 548                 priv->tx_throttled = 1; /* block writers */
 549                 schedule_work(&priv->unthrottle_work);
 550         }
 551
 552         rc = count;
 553 exit:
 554         if (rc < 0)
 555                 set_bit(0, &port->write_urbs_free);
 556         return rc;
 557 }
 558
 559
 560 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 561 {
 562         struct usb_serial_port *port = urb->context;
 563         struct keyspan_pda_private *priv;
 564
 565         set_bit(0, &port->write_urbs_free);
 566         priv = usb_get_serial_port_data(port);
 567
 568         /* queue up a wakeup at scheduler time */
 569         schedule_work(&priv->wakeup_work);
 570 }
 571
 572
 573 static int keyspan_pda_write_room(struct tty_struct *tty)
 574 {
 575         struct usb_serial_port *port = tty->driver_data;
 576         struct keyspan_pda_private *priv;
 577         priv = usb_get_serial_port_data(port);
 578         /* used by n_tty.c for processing of tabs and such. Giving it our
 579            conservative guess is probably good enough, but needs testing by
 580            running a console through the device. */
 581         return priv->tx_room;
 582 }
 583
 584
 585 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 586 {
 587         struct usb_serial_port *port = tty->driver_data;
 588         struct keyspan_pda_private *priv;
 589         unsigned long flags;
 590         int ret = 0;
 591
 592         priv = usb_get_serial_port_data(port);
 593
 594         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 595            n_tty.c:normal_poll() ) that we're not writeable. */
 596
 597         spin_lock_irqsave(&port->lock, flags);
 598         if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
 599                 ret = 256;
 600         spin_unlock_irqrestore(&port->lock, flags);
 601         return ret;
 602 }
 603
 604
 605 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 606 {
 607         struct usb_serial *serial = port->serial;
 608
 609         if (on)
 610                 keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
 611         else
 612                 keyspan_pda_set_modem_info(serial, 0);
 613 }
 614
 615
 616 static int keyspan_pda_open(struct tty_struct *tty,
 617                                         struct usb_serial_port *port)
 618 {
 619         struct usb_serial *serial = port->serial;
 620         u8 *room;
 621         int rc = 0;
 622         struct keyspan_pda_private *priv;
 623
 624         /* find out how much room is in the Tx ring */
 625         room = kmalloc(1, GFP_KERNEL);
 626         if (!room)
 627                 return -ENOMEM;
 628
 629         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 630                              6, /* write_room */
 631                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 632                              | USB_DIR_IN,
 633                              0, /* value */
 634                              0, /* index */
 635                              room,
 636                              1,
 637                              2000);
 638         if (rc < 0) {
 639                 dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
 640                 goto error;
 641         }
 642         if (rc == 0) {
 643                 dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
 644                 rc = -EIO;
 645                 goto error;
 646         }
 647         priv = usb_get_serial_port_data(port);
 648         priv->tx_room = *room;
 649         priv->tx_throttled = *room ? 0 : 1;
 650
 651         /*Start reading from the device*/
 652         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 653         if (rc) {
 654                 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
 655                 goto error;
 656         }
 657 error:
 658         kfree(room);
 659         return rc;
 660 }
 661 static void keyspan_pda_close(struct usb_serial_port *port)
 662 {
 663         usb_kill_urb(port->write_urb);
 664         usb_kill_urb(port->interrupt_in_urb);
 665 }
 666
 667
 668 /* download the firmware to a "fake" device (pre-renumeration) */
 669 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 670 {
 671         int response;
 672         const char *fw_name;
 673
 674         /* download the firmware here ... */
 675         response = ezusb_fx1_set_reset(serial->dev, 1);
 676
 677         if (0) { ; }
 678 #ifdef KEYSPAN
 679         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 680                 fw_name = "keyspan_pda/keyspan_pda.fw";
 681 #endif
 682 #ifdef XIRCOM
 683         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 684                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
 685                 fw_name = "keyspan_pda/xircom_pgs.fw";
 686 #endif
 687         else {
 688                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 689                         __func__);
 690                 return -ENODEV;
 691         }
 692
 693         if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
 694                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 695                         fw_name);
 696                 return -ENOENT;
 697         }
 698
 699         /* after downloading firmware Renumeration will occur in a
 700           moment and the new device will bind to the real driver */
 701
 702         /* we want this device to fail to have a driver assigned to it. */
 703         return 1;
 704 }
 705
 706 #ifdef KEYSPAN
 707 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 708 #endif
 709 #ifdef XIRCOM
 710 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 711 #endif
 712
 713 static int keyspan_pda_attach(struct usb_serial *serial)
 714 {
 715         unsigned char num_ports = serial->num_ports;
 716
 717         if (serial->num_bulk_out < num_ports ||
 718                         serial->num_interrupt_in < num_ports) {
 719                 dev_err(&serial->interface->dev, "missing endpoints\n");
 720                 return -ENODEV;
 721         }
 722
 723         return 0;
 724 }
 725
 726 static int keyspan_pda_port_probe(struct usb_serial_port *port)
 727 {
 728
 729         struct keyspan_pda_private *priv;
 730
 731         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 732         if (!priv)
 733                 return -ENOMEM;
 734
 735         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 736         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 737         priv->serial = port->serial;
 738         priv->port = port;
 739
 740         usb_set_serial_port_data(port, priv);
 741
 742         return 0;
 743 }
 744
 745 static int keyspan_pda_port_remove(struct usb_serial_port *port)
 746 {
 747         struct keyspan_pda_private *priv;
 748
 749         priv = usb_get_serial_port_data(port);
 750         kfree(priv);
 751
 752         return 0;
 753 }
 754
 755 #ifdef KEYSPAN
 756 static struct usb_serial_driver keyspan_pda_fake_device = {
 757         .driver = {
 758                 .owner =        THIS_MODULE,
 759                 .name =         "keyspan_pda_pre",
 760         },
 761         .description =          "Keyspan PDA - (prerenumeration)",
 762         .id_table =             id_table_fake,
 763         .num_ports =            1,
 764         .attach =               keyspan_pda_fake_startup,
 765 };
 766 #endif
 767
 768 #ifdef XIRCOM
 769 static struct usb_serial_driver xircom_pgs_fake_device = {
 770         .driver = {
 771                 .owner =        THIS_MODULE,
 772                 .name =         "xircom_no_firm",
 773         },
 774         .description =          "Xircom / Entrega PGS - (prerenumeration)",
 775         .id_table =             id_table_fake_xircom,
 776         .num_ports =            1,
 777         .attach =               keyspan_pda_fake_startup,
 778 };
 779 #endif
 780
 781 static struct usb_serial_driver keyspan_pda_device = {
 782         .driver = {
 783                 .owner =        THIS_MODULE,
 784                 .name =         "keyspan_pda",
 785         },
 786         .description =          "Keyspan PDA",
 787         .id_table =             id_table_std,
 788         .num_ports =            1,
 789         .dtr_rts =              keyspan_pda_dtr_rts,
 790         .open =                 keyspan_pda_open,
 791         .close =                keyspan_pda_close,
 792         .write =                keyspan_pda_write,
 793         .write_room =           keyspan_pda_write_room,
 794         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 795         .read_int_callback =    keyspan_pda_rx_interrupt,
 796         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 797         .throttle =             keyspan_pda_rx_throttle,
 798         .unthrottle =           keyspan_pda_rx_unthrottle,
 799         .set_termios =          keyspan_pda_set_termios,
 800         .break_ctl =            keyspan_pda_break_ctl,
 801         .tiocmget =             keyspan_pda_tiocmget,
 802         .tiocmset =             keyspan_pda_tiocmset,
 803         .attach =               keyspan_pda_attach,
 804         .port_probe =           keyspan_pda_port_probe,
 805         .port_remove =          keyspan_pda_port_remove,
 806 };
 807
 808 static struct usb_serial_driver * const serial_drivers[] = {
 809         &keyspan_pda_device,
 810 #ifdef KEYSPAN
 811         &keyspan_pda_fake_device,
 812 #endif
 813 #ifdef XIRCOM
 814         &xircom_pgs_fake_device,
 815 #endif
 816         NULL
 817 };
 818
 819 module_usb_serial_driver(serial_drivers, id_table_combined);
 820
 821 MODULE_AUTHOR(DRIVER_AUTHOR);
 822 MODULE_DESCRIPTION(DRIVER_DESC);
 823 MODULE_LICENSE("GPL");