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 IS_ENABLED(CONFIG_USB_SERIAL_KEYSPAN_PDA)
  34         #define KEYSPAN
  35 #else
  36         #undef KEYSPAN
  37 #endif
  38 #if IS_ENABLED(CONFIG_USB_SERIAL_XIRCOM)
  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 >= 0)
 377                 *value = *data;
 378
 379         kfree(data);
 380         return rc;
 381 }
 382
 383
 384 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 385                                       unsigned char value)
 386 {
 387         int rc;
 388         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 389                              3, /* set pins */
 390                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 391                              value, 0, NULL, 0, 2000);
 392         return rc;
 393 }
 394
 395 static int keyspan_pda_tiocmget(struct tty_struct *tty)
 396 {
 397         struct usb_serial_port *port = tty->driver_data;
 398         struct usb_serial *serial = port->serial;
 399         int rc;
 400         unsigned char status;
 401         int value;
 402
 403         rc = keyspan_pda_get_modem_info(serial, &status);
 404         if (rc < 0)
 405                 return rc;
 406         value =
 407                 ((status & (1<<7)) ? TIOCM_DTR : 0) |
 408                 ((status & (1<<6)) ? TIOCM_CAR : 0) |
 409                 ((status & (1<<5)) ? TIOCM_RNG : 0) |
 410                 ((status & (1<<4)) ? TIOCM_DSR : 0) |
 411                 ((status & (1<<3)) ? TIOCM_CTS : 0) |
 412                 ((status & (1<<2)) ? TIOCM_RTS : 0);
 413         return value;
 414 }
 415
 416 static int keyspan_pda_tiocmset(struct tty_struct *tty,
 417                                 unsigned int set, unsigned int clear)
 418 {
 419         struct usb_serial_port *port = tty->driver_data;
 420         struct usb_serial *serial = port->serial;
 421         int rc;
 422         unsigned char status;
 423
 424         rc = keyspan_pda_get_modem_info(serial, &status);
 425         if (rc < 0)
 426                 return rc;
 427
 428         if (set & TIOCM_RTS)
 429                 status |= (1<<2);
 430         if (set & TIOCM_DTR)
 431                 status |= (1<<7);
 432
 433         if (clear & TIOCM_RTS)
 434                 status &= ~(1<<2);
 435         if (clear & TIOCM_DTR)
 436                 status &= ~(1<<7);
 437         rc = keyspan_pda_set_modem_info(serial, status);
 438         return rc;
 439 }
 440
 441 static int keyspan_pda_write(struct tty_struct *tty,
 442         struct usb_serial_port *port, const unsigned char *buf, int count)
 443 {
 444         struct usb_serial *serial = port->serial;
 445         int request_unthrottle = 0;
 446         int rc = 0;
 447         struct keyspan_pda_private *priv;
 448
 449         priv = usb_get_serial_port_data(port);
 450         /* guess how much room is left in the device's ring buffer, and if we
 451            want to send more than that, check first, updating our notion of
 452            what is left. If our write will result in no room left, ask the
 453            device to give us an interrupt when the room available rises above
 454            a threshold, and hold off all writers (eventually, those using
 455            select() or poll() too) until we receive that unthrottle interrupt.
 456            Block if we can't write anything at all, otherwise write as much as
 457            we can. */
 458         if (count == 0) {
 459                 dev_dbg(&port->dev, "write request of 0 bytes\n");
 460                 return 0;
 461         }
 462
 463         /* we might block because of:
 464            the TX urb is in-flight (wait until it completes)
 465            the device is full (wait until it says there is room)
 466         */
 467         spin_lock_bh(&port->lock);
 468         if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
 469                 spin_unlock_bh(&port->lock);
 470                 return 0;
 471         }
 472         clear_bit(0, &port->write_urbs_free);
 473         spin_unlock_bh(&port->lock);
 474
 475         /* At this point the URB is in our control, nobody else can submit it
 476            again (the only sudden transition was the one from EINPROGRESS to
 477            finished).  Also, the tx process is not throttled. So we are
 478            ready to write. */
 479
 480         count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
 481
 482         /* Check if we might overrun the Tx buffer.   If so, ask the
 483            device how much room it really has.  This is done only on
 484            scheduler time, since usb_control_msg() sleeps. */
 485         if (count > priv->tx_room && !in_interrupt()) {
 486                 u8 *room;
 487
 488                 room = kmalloc(1, GFP_KERNEL);
 489                 if (!room) {
 490                         rc = -ENOMEM;
 491                         goto exit;
 492                 }
 493
 494                 rc = usb_control_msg(serial->dev,
 495                                      usb_rcvctrlpipe(serial->dev, 0),
 496                                      6, /* write_room */
 497                                      USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 498                                      | USB_DIR_IN,
 499                                      0, /* value: 0 means "remaining room" */
 500                                      0, /* index */
 501                                      room,
 502                                      1,
 503                                      2000);
 504                 if (rc > 0) {
 505                         dev_dbg(&port->dev, "roomquery says %d\n", *room);
 506                         priv->tx_room = *room;
 507                 }
 508                 kfree(room);
 509                 if (rc < 0) {
 510                         dev_dbg(&port->dev, "roomquery failed\n");
 511                         goto exit;
 512                 }
 513                 if (rc == 0) {
 514                         dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
 515                         rc = -EIO; /* device didn't return any data */
 516                         goto exit;
 517                 }
 518         }
 519         if (count > priv->tx_room) {
 520                 /* we're about to completely fill the Tx buffer, so
 521                    we'll be throttled afterwards. */
 522                 count = priv->tx_room;
 523                 request_unthrottle = 1;
 524         }
 525
 526         if (count) {
 527                 /* now transfer data */
 528                 memcpy(port->write_urb->transfer_buffer, buf, count);
 529                 /* send the data out the bulk port */
 530                 port->write_urb->transfer_buffer_length = count;
 531
 532                 priv->tx_room -= count;
 533
 534                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 535                 if (rc) {
 536                         dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
 537                         goto exit;
 538                 }
 539         } else {
 540                 /* There wasn't any room left, so we are throttled until
 541                    the buffer empties a bit */
 542                 request_unthrottle = 1;
 543         }
 544
 545         if (request_unthrottle) {
 546                 priv->tx_throttled = 1; /* block writers */
 547                 schedule_work(&priv->unthrottle_work);
 548         }
 549
 550         rc = count;
 551 exit:
 552         if (rc < 0)
 553                 set_bit(0, &port->write_urbs_free);
 554         return rc;
 555 }
 556
 557
 558 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 559 {
 560         struct usb_serial_port *port = urb->context;
 561         struct keyspan_pda_private *priv;
 562
 563         set_bit(0, &port->write_urbs_free);
 564         priv = usb_get_serial_port_data(port);
 565
 566         /* queue up a wakeup at scheduler time */
 567         schedule_work(&priv->wakeup_work);
 568 }
 569
 570
 571 static int keyspan_pda_write_room(struct tty_struct *tty)
 572 {
 573         struct usb_serial_port *port = tty->driver_data;
 574         struct keyspan_pda_private *priv;
 575         priv = usb_get_serial_port_data(port);
 576         /* used by n_tty.c for processing of tabs and such. Giving it our
 577            conservative guess is probably good enough, but needs testing by
 578            running a console through the device. */
 579         return priv->tx_room;
 580 }
 581
 582
 583 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 584 {
 585         struct usb_serial_port *port = tty->driver_data;
 586         struct keyspan_pda_private *priv;
 587         unsigned long flags;
 588         int ret = 0;
 589
 590         priv = usb_get_serial_port_data(port);
 591
 592         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 593            n_tty.c:normal_poll() ) that we're not writeable. */
 594
 595         spin_lock_irqsave(&port->lock, flags);
 596         if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
 597                 ret = 256;
 598         spin_unlock_irqrestore(&port->lock, flags);
 599         return ret;
 600 }
 601
 602
 603 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 604 {
 605         struct usb_serial *serial = port->serial;
 606
 607         if (on)
 608                 keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
 609         else
 610                 keyspan_pda_set_modem_info(serial, 0);
 611 }
 612
 613
 614 static int keyspan_pda_open(struct tty_struct *tty,
 615                                         struct usb_serial_port *port)
 616 {
 617         struct usb_serial *serial = port->serial;
 618         u8 *room;
 619         int rc = 0;
 620         struct keyspan_pda_private *priv;
 621
 622         /* find out how much room is in the Tx ring */
 623         room = kmalloc(1, GFP_KERNEL);
 624         if (!room)
 625                 return -ENOMEM;
 626
 627         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 628                              6, /* write_room */
 629                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 630                              | USB_DIR_IN,
 631                              0, /* value */
 632                              0, /* index */
 633                              room,
 634                              1,
 635                              2000);
 636         if (rc < 0) {
 637                 dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
 638                 goto error;
 639         }
 640         if (rc == 0) {
 641                 dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
 642                 rc = -EIO;
 643                 goto error;
 644         }
 645         priv = usb_get_serial_port_data(port);
 646         priv->tx_room = *room;
 647         priv->tx_throttled = *room ? 0 : 1;
 648
 649         /*Start reading from the device*/
 650         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 651         if (rc) {
 652                 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
 653                 goto error;
 654         }
 655 error:
 656         kfree(room);
 657         return rc;
 658 }
 659 static void keyspan_pda_close(struct usb_serial_port *port)
 660 {
 661         usb_kill_urb(port->write_urb);
 662         usb_kill_urb(port->interrupt_in_urb);
 663 }
 664
 665
 666 /* download the firmware to a "fake" device (pre-renumeration) */
 667 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 668 {
 669         int response;
 670         const char *fw_name;
 671
 672         /* download the firmware here ... */
 673         response = ezusb_fx1_set_reset(serial->dev, 1);
 674
 675         if (0) { ; }
 676 #ifdef KEYSPAN
 677         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 678                 fw_name = "keyspan_pda/keyspan_pda.fw";
 679 #endif
 680 #ifdef XIRCOM
 681         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 682                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
 683                 fw_name = "keyspan_pda/xircom_pgs.fw";
 684 #endif
 685         else {
 686                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 687                         __func__);
 688                 return -ENODEV;
 689         }
 690
 691         if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
 692                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 693                         fw_name);
 694                 return -ENOENT;
 695         }
 696
 697         /* after downloading firmware Renumeration will occur in a
 698           moment and the new device will bind to the real driver */
 699
 700         /* we want this device to fail to have a driver assigned to it. */
 701         return 1;
 702 }
 703
 704 #ifdef KEYSPAN
 705 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 706 #endif
 707 #ifdef XIRCOM
 708 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 709 #endif
 710
 711 static int keyspan_pda_attach(struct usb_serial *serial)
 712 {
 713         unsigned char num_ports = serial->num_ports;
 714
 715         if (serial->num_bulk_out < num_ports ||
 716                         serial->num_interrupt_in < num_ports) {
 717                 dev_err(&serial->interface->dev, "missing endpoints\n");
 718                 return -ENODEV;
 719         }
 720
 721         return 0;
 722 }
 723
 724 static int keyspan_pda_port_probe(struct usb_serial_port *port)
 725 {
 726
 727         struct keyspan_pda_private *priv;
 728
 729         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 730         if (!priv)
 731                 return -ENOMEM;
 732
 733         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 734         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 735         priv->serial = port->serial;
 736         priv->port = port;
 737
 738         usb_set_serial_port_data(port, priv);
 739
 740         return 0;
 741 }
 742
 743 static int keyspan_pda_port_remove(struct usb_serial_port *port)
 744 {
 745         struct keyspan_pda_private *priv;
 746
 747         priv = usb_get_serial_port_data(port);
 748         kfree(priv);
 749
 750         return 0;
 751 }
 752
 753 #ifdef KEYSPAN
 754 static struct usb_serial_driver keyspan_pda_fake_device = {
 755         .driver = {
 756                 .owner =        THIS_MODULE,
 757                 .name =         "keyspan_pda_pre",
 758         },
 759         .description =          "Keyspan PDA - (prerenumeration)",
 760         .id_table =             id_table_fake,
 761         .num_ports =            1,
 762         .attach =               keyspan_pda_fake_startup,
 763 };
 764 #endif
 765
 766 #ifdef XIRCOM
 767 static struct usb_serial_driver xircom_pgs_fake_device = {
 768         .driver = {
 769                 .owner =        THIS_MODULE,
 770                 .name =         "xircom_no_firm",
 771         },
 772         .description =          "Xircom / Entrega PGS - (prerenumeration)",
 773         .id_table =             id_table_fake_xircom,
 774         .num_ports =            1,
 775         .attach =               keyspan_pda_fake_startup,
 776 };
 777 #endif
 778
 779 static struct usb_serial_driver keyspan_pda_device = {
 780         .driver = {
 781                 .owner =        THIS_MODULE,
 782                 .name =         "keyspan_pda",
 783         },
 784         .description =          "Keyspan PDA",
 785         .id_table =             id_table_std,
 786         .num_ports =            1,
 787         .dtr_rts =              keyspan_pda_dtr_rts,
 788         .open =                 keyspan_pda_open,
 789         .close =                keyspan_pda_close,
 790         .write =                keyspan_pda_write,
 791         .write_room =           keyspan_pda_write_room,
 792         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 793         .read_int_callback =    keyspan_pda_rx_interrupt,
 794         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 795         .throttle =             keyspan_pda_rx_throttle,
 796         .unthrottle =           keyspan_pda_rx_unthrottle,
 797         .set_termios =          keyspan_pda_set_termios,
 798         .break_ctl =            keyspan_pda_break_ctl,
 799         .tiocmget =             keyspan_pda_tiocmget,
 800         .tiocmset =             keyspan_pda_tiocmset,
 801         .attach =               keyspan_pda_attach,
 802         .port_probe =           keyspan_pda_port_probe,
 803         .port_remove =          keyspan_pda_port_remove,
 804 };
 805
 806 static struct usb_serial_driver * const serial_drivers[] = {
 807         &keyspan_pda_device,
 808 #ifdef KEYSPAN
 809         &keyspan_pda_fake_device,
 810 #endif
 811 #ifdef XIRCOM
 812         &xircom_pgs_fake_device,
 813 #endif
 814         NULL
 815 };
 816
 817 module_usb_serial_driver(serial_drivers, id_table_combined);
 818
 819 MODULE_AUTHOR(DRIVER_AUTHOR);
 820 MODULE_DESCRIPTION(DRIVER_DESC);
 821 MODULE_LICENSE("GPL");