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