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