drivers/usb/serial/keyspan_pda.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * USB Keyspan PDA / Xircom / Entrega Converter driver
   4  *
   5  * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <[email protected]>
   6  * Copyright (C) 1999, 2000 Brian Warner        <[email protected]>
   7  * Copyright (C) 2000 Al Borchers               <[email protected]>
   8  * Copyright (C) 2020 Johan Hovold <[email protected]>
   9  *
  10  * See Documentation/usb/usb-serial.rst for more information on using this
  11  * driver
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/errno.h>
  16 #include <linux/slab.h>
  17 #include <linux/tty.h>
  18 #include <linux/tty_driver.h>
  19 #include <linux/tty_flip.h>
  20 #include <linux/module.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/workqueue.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/usb.h>
  25 #include <linux/usb/serial.h>
  26 #include <linux/usb/ezusb.h>
  27
  28 #define DRIVER_AUTHOR "Brian Warner <[email protected]>, Johan Hovold <[email protected]>"
  29 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
  30
  31 #define KEYSPAN_TX_THRESHOLD    128
  32
  33 struct keyspan_pda_private {
  34         int                     tx_room;
  35         struct work_struct      unthrottle_work;
  36         struct usb_serial       *serial;
  37         struct usb_serial_port  *port;
  38 };
  39
  40 static int keyspan_pda_write_start(struct usb_serial_port *port);
  41
  42 #define KEYSPAN_VENDOR_ID               0x06cd
  43 #define KEYSPAN_PDA_FAKE_ID             0x0103
  44 #define KEYSPAN_PDA_ID                  0x0104 /* no clue */
  45
  46 /* For Xircom PGSDB9 and older Entrega version of the same device */
  47 #define XIRCOM_VENDOR_ID                0x085a
  48 #define XIRCOM_FAKE_ID                  0x8027
  49 #define XIRCOM_FAKE_ID_2                0x8025 /* "PGMFHUB" serial */
  50 #define ENTREGA_VENDOR_ID               0x1645
  51 #define ENTREGA_FAKE_ID                 0x8093
  52
  53 static const struct usb_device_id id_table_combined[] = {
  54         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
  55         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
  56         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
  57         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
  58         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
  59         { }                                             /* Terminating entry */
  60 };
  61 MODULE_DEVICE_TABLE(usb, id_table_combined);
  62
  63 static const struct usb_device_id id_table_std[] = {
  64         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
  65         { }                                             /* Terminating entry */
  66 };
  67
  68 static const struct usb_device_id id_table_fake[] = {
  69         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
  70         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
  71         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
  72         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
  73         { }                                             /* Terminating entry */
  74 };
  75
  76 static int keyspan_pda_get_write_room(struct keyspan_pda_private *priv)
  77 {
  78         struct usb_serial_port *port = priv->port;
  79         struct usb_serial *serial = port->serial;
  80         u8 room;
  81         int rc;
  82
  83         rc = usb_control_msg_recv(serial->dev,
  84                                   0,
  85                                   6, /* write_room */
  86                                   USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
  87                                   0, /* value: 0 means "remaining room" */
  88                                   0, /* index */
  89                                   &room,
  90                                   1,
  91                                   2000,
  92                                   GFP_KERNEL);
  93         if (rc) {
  94                 dev_dbg(&port->dev, "roomquery failed: %d\n", rc);
  95                 return rc;
  96         }
  97
  98         dev_dbg(&port->dev, "roomquery says %d\n", room);
  99
 100         return room;
 101 }
 102
 103 static void keyspan_pda_request_unthrottle(struct work_struct *work)
 104 {
 105         struct keyspan_pda_private *priv =
 106                 container_of(work, struct keyspan_pda_private, unthrottle_work);
 107         struct usb_serial_port *port = priv->port;
 108         struct usb_serial *serial = port->serial;
 109         unsigned long flags;
 110         int result;
 111
 112         dev_dbg(&port->dev, "%s\n", __func__);
 113
 114         /*
 115          * Ask the device to tell us when the tx buffer becomes
 116          * sufficiently empty.
 117          */
 118         result = usb_control_msg(serial->dev,
 119                                  usb_sndctrlpipe(serial->dev, 0),
 120                                  7, /* request_unthrottle */
 121                                  USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 122                                  | USB_DIR_OUT,
 123                                  KEYSPAN_TX_THRESHOLD,
 124                                  0, /* index */
 125                                  NULL,
 126                                  0,
 127                                  2000);
 128         if (result < 0)
 129                 dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
 130                         __func__, result);
 131         /*
 132          * Need to check available space after requesting notification in case
 133          * buffer is already empty so that no notification is sent.
 134          */
 135         result = keyspan_pda_get_write_room(priv);
 136         if (result > KEYSPAN_TX_THRESHOLD) {
 137                 spin_lock_irqsave(&port->lock, flags);
 138                 priv->tx_room = max(priv->tx_room, result);
 139                 spin_unlock_irqrestore(&port->lock, flags);
 140
 141                 usb_serial_port_softint(port);
 142         }
 143 }
 144
 145 static void keyspan_pda_rx_interrupt(struct urb *urb)
 146 {
 147         struct usb_serial_port *port = urb->context;
 148         unsigned char *data = urb->transfer_buffer;
 149         unsigned int len = urb->actual_length;
 150         int retval;
 151         int status = urb->status;
 152         struct keyspan_pda_private *priv;
 153         unsigned long flags;
 154
 155         priv = usb_get_serial_port_data(port);
 156
 157         switch (status) {
 158         case 0:
 159                 /* success */
 160                 break;
 161         case -ECONNRESET:
 162         case -ENOENT:
 163         case -ESHUTDOWN:
 164                 /* this urb is terminated, clean up */
 165                 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
 166                 return;
 167         default:
 168                 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
 169                 goto exit;
 170         }
 171
 172         if (len < 1) {
 173                 dev_warn(&port->dev, "short message received\n");
 174                 goto exit;
 175         }
 176
 177         /* see if the message is data or a status interrupt */
 178         switch (data[0]) {
 179         case 0:
 180                  /* rest of message is rx data */
 181                 if (len < 2)
 182                         break;
 183                 tty_insert_flip_string(&port->port, data + 1, len - 1);
 184                 tty_flip_buffer_push(&port->port);
 185                 break;
 186         case 1:
 187                 /* status interrupt */
 188                 if (len < 2) {
 189                         dev_warn(&port->dev, "short interrupt message received\n");
 190                         break;
 191                 }
 192                 dev_dbg(&port->dev, "rx int, d1=%d\n", data[1]);
 193                 switch (data[1]) {
 194                 case 1: /* modemline change */
 195                         break;
 196                 case 2: /* tx unthrottle interrupt */
 197                         spin_lock_irqsave(&port->lock, flags);
 198                         priv->tx_room = max(priv->tx_room, KEYSPAN_TX_THRESHOLD);
 199                         spin_unlock_irqrestore(&port->lock, flags);
 200
 201                         keyspan_pda_write_start(port);
 202
 203                         usb_serial_port_softint(port);
 204                         break;
 205                 default:
 206                         break;
 207                 }
 208                 break;
 209         default:
 210                 break;
 211         }
 212
 213 exit:
 214         retval = usb_submit_urb(urb, GFP_ATOMIC);
 215         if (retval)
 216                 dev_err(&port->dev,
 217                         "%s - usb_submit_urb failed with result %d\n",
 218                         __func__, retval);
 219 }
 220
 221 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 222 {
 223         struct usb_serial_port *port = tty->driver_data;
 224
 225         /*
 226          * Stop receiving characters. We just turn off the URB request, and
 227          * let chars pile up in the device. If we're doing hardware
 228          * flowcontrol, the device will signal the other end when its buffer
 229          * fills up. If we're doing XON/XOFF, this would be a good time to
 230          * send an XOFF, although it might make sense to foist that off upon
 231          * the device too.
 232          */
 233         usb_kill_urb(port->interrupt_in_urb);
 234 }
 235
 236 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 237 {
 238         struct usb_serial_port *port = tty->driver_data;
 239
 240         /* just restart the receive interrupt URB */
 241         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
 242                 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
 243 }
 244
 245 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
 246 {
 247         int rc;
 248         int bindex;
 249
 250         switch (baud) {
 251         case 110:
 252                 bindex = 0;
 253                 break;
 254         case 300:
 255                 bindex = 1;
 256                 break;
 257         case 1200:
 258                 bindex = 2;
 259                 break;
 260         case 2400:
 261                 bindex = 3;
 262                 break;
 263         case 4800:
 264                 bindex = 4;
 265                 break;
 266         case 9600:
 267                 bindex = 5;
 268                 break;
 269         case 19200:
 270                 bindex = 6;
 271                 break;
 272         case 38400:
 273                 bindex = 7;
 274                 break;
 275         case 57600:
 276                 bindex = 8;
 277                 break;
 278         case 115200:
 279                 bindex = 9;
 280                 break;
 281         default:
 282                 bindex = 5;     /* Default to 9600 */
 283                 baud = 9600;
 284         }
 285
 286         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 287                              0, /* set baud */
 288                              USB_TYPE_VENDOR
 289                              | USB_RECIP_INTERFACE
 290                              | USB_DIR_OUT, /* type */
 291                              bindex, /* value */
 292                              0, /* index */
 293                              NULL, /* &data */
 294                              0, /* size */
 295                              2000); /* timeout */
 296         if (rc < 0)
 297                 return 0;
 298
 299         return baud;
 300 }
 301
 302 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 303 {
 304         struct usb_serial_port *port = tty->driver_data;
 305         struct usb_serial *serial = port->serial;
 306         int value;
 307         int result;
 308
 309         if (break_state == -1)
 310                 value = 1; /* start break */
 311         else
 312                 value = 0; /* clear break */
 313
 314         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 315                         4, /* set break */
 316                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
 317                         value, 0, NULL, 0, 2000);
 318         if (result < 0)
 319                 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
 320                         __func__, result);
 321 }
 322
 323 static void keyspan_pda_set_termios(struct tty_struct *tty,
 324                                     struct usb_serial_port *port,
 325                                     const struct ktermios *old_termios)
 326 {
 327         struct usb_serial *serial = port->serial;
 328         speed_t speed;
 329
 330         /*
 331          * cflag specifies lots of stuff: number of stop bits, parity, number
 332          * of data bits, baud. What can the device actually handle?:
 333          * CSTOPB (1 stop bit or 2)
 334          * PARENB (parity)
 335          * CSIZE (5bit .. 8bit)
 336          * There is minimal hw support for parity (a PSW bit seems to hold the
 337          * parity of whatever is in the accumulator). The UART either deals
 338          * with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
 339          * 1 special, stop). So, with firmware changes, we could do:
 340          * 8N1: 10 bit
 341          * 8N2: 11 bit, extra bit always (mark?)
 342          * 8[EOMS]1: 11 bit, extra bit is parity
 343          * 7[EOMS]1: 10 bit, b0/b7 is parity
 344          * 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
 345          *
 346          * HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
 347          * bit.
 348          *
 349          * For now, just do baud.
 350          */
 351         speed = tty_get_baud_rate(tty);
 352         speed = keyspan_pda_setbaud(serial, speed);
 353
 354         if (speed == 0) {
 355                 dev_dbg(&port->dev, "can't handle requested baud rate\n");
 356                 /* It hasn't changed so.. */
 357                 speed = tty_termios_baud_rate(old_termios);
 358         }
 359         /*
 360          * Only speed can change so copy the old h/w parameters then encode
 361          * the new speed.
 362          */
 363         tty_termios_copy_hw(&tty->termios, old_termios);
 364         tty_encode_baud_rate(tty, speed, speed);
 365 }
 366
 367 /*
 368  * Modem control pins: DTR and RTS are outputs and can be controlled.
 369  * DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
 370  * read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused.
 371  */
 372 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
 373                                       unsigned char *value)
 374 {
 375         int rc;
 376         u8 data;
 377
 378         rc = usb_control_msg_recv(serial->dev, 0,
 379                                   3, /* get pins */
 380                                   USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
 381                                   0,
 382                                   0,
 383                                   &data,
 384                                   1,
 385                                   2000,
 386                                   GFP_KERNEL);
 387         if (rc == 0)
 388                 *value = data;
 389
 390         return rc;
 391 }
 392
 393 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 394                                       unsigned char value)
 395 {
 396         int rc;
 397         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 398                              3, /* set pins */
 399                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 400                              value, 0, NULL, 0, 2000);
 401         return rc;
 402 }
 403
 404 static int keyspan_pda_tiocmget(struct tty_struct *tty)
 405 {
 406         struct usb_serial_port *port = tty->driver_data;
 407         struct usb_serial *serial = port->serial;
 408         int rc;
 409         unsigned char status;
 410         int value;
 411
 412         rc = keyspan_pda_get_modem_info(serial, &status);
 413         if (rc < 0)
 414                 return rc;
 415
 416         value = ((status & BIT(7)) ? TIOCM_DTR : 0) |
 417                 ((status & BIT(6)) ? TIOCM_CAR : 0) |
 418                 ((status & BIT(5)) ? TIOCM_RNG : 0) |
 419                 ((status & BIT(4)) ? TIOCM_DSR : 0) |
 420                 ((status & BIT(3)) ? TIOCM_CTS : 0) |
 421                 ((status & BIT(2)) ? TIOCM_RTS : 0);
 422
 423         return value;
 424 }
 425
 426 static int keyspan_pda_tiocmset(struct tty_struct *tty,
 427                                 unsigned int set, unsigned int clear)
 428 {
 429         struct usb_serial_port *port = tty->driver_data;
 430         struct usb_serial *serial = port->serial;
 431         int rc;
 432         unsigned char status;
 433
 434         rc = keyspan_pda_get_modem_info(serial, &status);
 435         if (rc < 0)
 436                 return rc;
 437
 438         if (set & TIOCM_RTS)
 439                 status |= BIT(2);
 440         if (set & TIOCM_DTR)
 441                 status |= BIT(7);
 442
 443         if (clear & TIOCM_RTS)
 444                 status &= ~BIT(2);
 445         if (clear & TIOCM_DTR)
 446                 status &= ~BIT(7);
 447         rc = keyspan_pda_set_modem_info(serial, status);
 448         return rc;
 449 }
 450
 451 static int keyspan_pda_write_start(struct usb_serial_port *port)
 452 {
 453         struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
 454         unsigned long flags;
 455         struct urb *urb;
 456         int count;
 457         int room;
 458         int rc;
 459
 460         /*
 461          * Guess how much room is left in the device's ring buffer. If our
 462          * write will result in no room left, ask the device to give us an
 463          * interrupt when the room available rises above a threshold but also
 464          * query how much room is currently available (in case our guess was
 465          * too conservative and the buffer is already empty when the
 466          * unthrottle work is scheduled).
 467          */
 468
 469         /*
 470          * We might block because of:
 471          * the TX urb is in-flight (wait until it completes)
 472          * the device is full (wait until it says there is room)
 473          */
 474         spin_lock_irqsave(&port->lock, flags);
 475
 476         room = priv->tx_room;
 477         count = kfifo_len(&port->write_fifo);
 478
 479         if (!test_bit(0, &port->write_urbs_free) || count == 0 || room == 0) {
 480                 spin_unlock_irqrestore(&port->lock, flags);
 481                 return 0;
 482         }
 483         __clear_bit(0, &port->write_urbs_free);
 484
 485         if (count > room)
 486                 count = room;
 487         if (count > port->bulk_out_size)
 488                 count = port->bulk_out_size;
 489
 490         urb = port->write_urb;
 491         count = kfifo_out(&port->write_fifo, urb->transfer_buffer, count);
 492         urb->transfer_buffer_length = count;
 493
 494         port->tx_bytes += count;
 495         priv->tx_room -= count;
 496
 497         spin_unlock_irqrestore(&port->lock, flags);
 498
 499         dev_dbg(&port->dev, "%s - count = %d, txroom = %d\n", __func__, count, room);
 500
 501         rc = usb_submit_urb(urb, GFP_ATOMIC);
 502         if (rc) {
 503                 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
 504
 505                 spin_lock_irqsave(&port->lock, flags);
 506                 port->tx_bytes -= count;
 507                 priv->tx_room = max(priv->tx_room, room + count);
 508                 __set_bit(0, &port->write_urbs_free);
 509                 spin_unlock_irqrestore(&port->lock, flags);
 510
 511                 return rc;
 512         }
 513
 514         if (count == room)
 515                 schedule_work(&priv->unthrottle_work);
 516
 517         return count;
 518 }
 519
 520 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 521 {
 522         struct usb_serial_port *port = urb->context;
 523         unsigned long flags;
 524
 525         spin_lock_irqsave(&port->lock, flags);
 526         port->tx_bytes -= urb->transfer_buffer_length;
 527         __set_bit(0, &port->write_urbs_free);
 528         spin_unlock_irqrestore(&port->lock, flags);
 529
 530         keyspan_pda_write_start(port);
 531
 532         usb_serial_port_softint(port);
 533 }
 534
 535 static int keyspan_pda_write(struct tty_struct *tty, struct usb_serial_port *port,
 536                 const unsigned char *buf, int count)
 537 {
 538         int rc;
 539
 540         dev_dbg(&port->dev, "%s - count = %d\n", __func__, count);
 541
 542         if (!count)
 543                 return 0;
 544
 545         count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
 546
 547         rc = keyspan_pda_write_start(port);
 548         if (rc)
 549                 return rc;
 550
 551         return count;
 552 }
 553
 554 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 555 {
 556         struct usb_serial *serial = port->serial;
 557
 558         if (on)
 559                 keyspan_pda_set_modem_info(serial, BIT(7) | BIT(2));
 560         else
 561                 keyspan_pda_set_modem_info(serial, 0);
 562 }
 563
 564
 565 static int keyspan_pda_open(struct tty_struct *tty,
 566                                         struct usb_serial_port *port)
 567 {
 568         struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
 569         int rc;
 570
 571         /* find out how much room is in the Tx ring */
 572         rc = keyspan_pda_get_write_room(priv);
 573         if (rc < 0)
 574                 return rc;
 575
 576         spin_lock_irq(&port->lock);
 577         priv->tx_room = rc;
 578         spin_unlock_irq(&port->lock);
 579
 580         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 581         if (rc) {
 582                 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
 583                 return rc;
 584         }
 585
 586         return 0;
 587 }
 588
 589 static void keyspan_pda_close(struct usb_serial_port *port)
 590 {
 591         struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
 592
 593         /*
 594          * Stop the interrupt URB first as its completion handler may submit
 595          * the write URB.
 596          */
 597         usb_kill_urb(port->interrupt_in_urb);
 598         usb_kill_urb(port->write_urb);
 599
 600         cancel_work_sync(&priv->unthrottle_work);
 601
 602         spin_lock_irq(&port->lock);
 603         kfifo_reset(&port->write_fifo);
 604         spin_unlock_irq(&port->lock);
 605 }
 606
 607 /* download the firmware to a "fake" device (pre-renumeration) */
 608 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 609 {
 610         unsigned int vid = le16_to_cpu(serial->dev->descriptor.idVendor);
 611         const char *fw_name;
 612
 613         /* download the firmware here ... */
 614         ezusb_fx1_set_reset(serial->dev, 1);
 615
 616         switch (vid) {
 617         case KEYSPAN_VENDOR_ID:
 618                 fw_name = "keyspan_pda/keyspan_pda.fw";
 619                 break;
 620         case XIRCOM_VENDOR_ID:
 621         case ENTREGA_VENDOR_ID:
 622                 fw_name = "keyspan_pda/xircom_pgs.fw";
 623                 break;
 624         default:
 625                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 626                         __func__);
 627                 return -ENODEV;
 628         }
 629
 630         if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
 631                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 632                         fw_name);
 633                 return -ENOENT;
 634         }
 635
 636         /*
 637          * After downloading firmware renumeration will occur in a moment and
 638          * the new device will bind to the real driver.
 639          */
 640
 641         /* We want this device to fail to have a driver assigned to it. */
 642         return 1;
 643 }
 644
 645 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 646 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 647
 648 static int keyspan_pda_port_probe(struct usb_serial_port *port)
 649 {
 650
 651         struct keyspan_pda_private *priv;
 652
 653         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 654         if (!priv)
 655                 return -ENOMEM;
 656
 657         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 658         priv->port = port;
 659
 660         usb_set_serial_port_data(port, priv);
 661
 662         return 0;
 663 }
 664
 665 static void keyspan_pda_port_remove(struct usb_serial_port *port)
 666 {
 667         struct keyspan_pda_private *priv;
 668
 669         priv = usb_get_serial_port_data(port);
 670         kfree(priv);
 671 }
 672
 673 static struct usb_serial_driver keyspan_pda_fake_device = {
 674         .driver = {
 675                 .owner =        THIS_MODULE,
 676                 .name =         "keyspan_pda_pre",
 677         },
 678         .description =          "Keyspan PDA - (prerenumeration)",
 679         .id_table =             id_table_fake,
 680         .num_ports =            1,
 681         .attach =               keyspan_pda_fake_startup,
 682 };
 683
 684 static struct usb_serial_driver keyspan_pda_device = {
 685         .driver = {
 686                 .owner =        THIS_MODULE,
 687                 .name =         "keyspan_pda",
 688         },
 689         .description =          "Keyspan PDA",
 690         .id_table =             id_table_std,
 691         .num_ports =            1,
 692         .num_bulk_out =         1,
 693         .num_interrupt_in =     1,
 694         .dtr_rts =              keyspan_pda_dtr_rts,
 695         .open =                 keyspan_pda_open,
 696         .close =                keyspan_pda_close,
 697         .write =                keyspan_pda_write,
 698         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 699         .read_int_callback =    keyspan_pda_rx_interrupt,
 700         .throttle =             keyspan_pda_rx_throttle,
 701         .unthrottle =           keyspan_pda_rx_unthrottle,
 702         .set_termios =          keyspan_pda_set_termios,
 703         .break_ctl =            keyspan_pda_break_ctl,
 704         .tiocmget =             keyspan_pda_tiocmget,
 705         .tiocmset =             keyspan_pda_tiocmset,
 706         .port_probe =           keyspan_pda_port_probe,
 707         .port_remove =          keyspan_pda_port_remove,
 708 };
 709
 710 static struct usb_serial_driver * const serial_drivers[] = {
 711         &keyspan_pda_device,
 712         &keyspan_pda_fake_device,
 713         NULL
 714 };
 715
 716 module_usb_serial_driver(serial_drivers, id_table_combined);
 717
 718 MODULE_AUTHOR(DRIVER_AUTHOR);
 719 MODULE_DESCRIPTION(DRIVER_DESC);
 720 MODULE_LICENSE("GPL");