drivers/usb/serial/keyspan_pda.c

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