usb/serial/keyspan_pda.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * USB Keyspan PDA / Xircom / Entrega Converter driver
0004  *
0005  * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com>
0006  * Copyright (C) 1999, 2000 Brian Warner    <warner@lothar.com>
0007  * Copyright (C) 2000 Al Borchers       <borchers@steinerpoint.com>
0008  * Copyright (C) 2020 Johan Hovold <johan@kernel.org>
0009  *
0010  * See Documentation/usb/usb-serial.rst for more information on using this
0011  * driver
0012  */
0013
0014 #include <linux/kernel.h>
0015 #include <linux/errno.h>
0016 #include <linux/slab.h>
0017 #include <linux/tty.h>
0018 #include <linux/tty_driver.h>
0019 #include <linux/tty_flip.h>
0020 #include <linux/module.h>
0021 #include <linux/spinlock.h>
0022 #include <linux/workqueue.h>
0023 #include <linux/uaccess.h>
0024 #include <linux/usb.h>
0025 #include <linux/usb/serial.h>
0026 #include <linux/usb/ezusb.h>
0027
0028 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>, Johan Hovold <johan@kernel.org>"
0029 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
0030
0031 #define KEYSPAN_TX_THRESHOLD    128
0032
0033 struct keyspan_pda_private {
0034     int         tx_room;
0035     struct work_struct  unthrottle_work;
0036     struct usb_serial   *serial;
0037     struct usb_serial_port  *port;
0038 };
0039
0040 static int keyspan_pda_write_start(struct usb_serial_port *port);
0041
0042 #define KEYSPAN_VENDOR_ID       0x06cd
0043 #define KEYSPAN_PDA_FAKE_ID     0x0103
0044 #define KEYSPAN_PDA_ID          0x0104 /* no clue */
0045
0046 /* For Xircom PGSDB9 and older Entrega version of the same device */
0047 #define XIRCOM_VENDOR_ID        0x085a
0048 #define XIRCOM_FAKE_ID          0x8027
0049 #define XIRCOM_FAKE_ID_2        0x8025 /* "PGMFHUB" serial */
0050 #define ENTREGA_VENDOR_ID       0x1645
0051 #define ENTREGA_FAKE_ID         0x8093
0052
0053 static const struct usb_device_id id_table_combined[] = {
0054     { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
0055     { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
0056     { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
0057     { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
0058     { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
0059     { }                     /* Terminating entry */
0060 };
0061 MODULE_DEVICE_TABLE(usb, id_table_combined);
0062
0063 static const struct usb_device_id id_table_std[] = {
0064     { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
0065     { }                     /* Terminating entry */
0066 };
0067
0068 static const struct usb_device_id id_table_fake[] = {
0069     { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
0070     { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
0071     { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
0072     { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
0073     { }                     /* Terminating entry */
0074 };
0075
0076 static int keyspan_pda_get_write_room(struct keyspan_pda_private *priv)
0077 {
0078     struct usb_serial_port *port = priv->port;
0079     struct usb_serial *serial = port->serial;
0080     u8 room;
0081     int rc;
0082
0083     rc = usb_control_msg_recv(serial->dev,
0084                   0,
0085                   6, /* write_room */
0086                   USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
0087                   0, /* value: 0 means "remaining room" */
0088                   0, /* index */
0089                   &room,
0090                   1,
0091                   2000,
0092                   GFP_KERNEL);
0093     if (rc) {
0094         dev_dbg(&port->dev, "roomquery failed: %d\n", rc);
0095         return rc;
0096     }
0097
0098     dev_dbg(&port->dev, "roomquery says %d\n", room);
0099
0100     return room;
0101 }
0102
0103 static void keyspan_pda_request_unthrottle(struct work_struct *work)
0104 {
0105     struct keyspan_pda_private *priv =
0106         container_of(work, struct keyspan_pda_private, unthrottle_work);
0107     struct usb_serial_port *port = priv->port;
0108     struct usb_serial *serial = port->serial;
0109     unsigned long flags;
0110     int result;
0111
0112     dev_dbg(&port->dev, "%s\n", __func__);
0113
0114     /*
0115      * Ask the device to tell us when the tx buffer becomes
0116      * sufficiently empty.
0117      */
0118     result = usb_control_msg(serial->dev,
0119                  usb_sndctrlpipe(serial->dev, 0),
0120                  7, /* request_unthrottle */
0121                  USB_TYPE_VENDOR | USB_RECIP_INTERFACE
0122                  | USB_DIR_OUT,
0123                  KEYSPAN_TX_THRESHOLD,
0124                  0, /* index */
0125                  NULL,
0126                  0,
0127                  2000);
0128     if (result < 0)
0129         dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
0130             __func__, result);
0131     /*
0132      * Need to check available space after requesting notification in case
0133      * buffer is already empty so that no notification is sent.
0134      */
0135     result = keyspan_pda_get_write_room(priv);
0136     if (result > KEYSPAN_TX_THRESHOLD) {
0137         spin_lock_irqsave(&port->lock, flags);
0138         priv->tx_room = max(priv->tx_room, result);
0139         spin_unlock_irqrestore(&port->lock, flags);
0140
0141         usb_serial_port_softint(port);
0142     }
0143 }
0144
0145 static void keyspan_pda_rx_interrupt(struct urb *urb)
0146 {
0147     struct usb_serial_port *port = urb->context;
0148     unsigned char *data = urb->transfer_buffer;
0149     unsigned int len = urb->actual_length;
0150     int retval;
0151     int status = urb->status;
0152     struct keyspan_pda_private *priv;
0153     unsigned long flags;
0154
0155     priv = usb_get_serial_port_data(port);
0156
0157     switch (status) {
0158     case 0:
0159         /* success */
0160         break;
0161     case -ECONNRESET:
0162     case -ENOENT:
0163     case -ESHUTDOWN:
0164         /* this urb is terminated, clean up */
0165         dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
0166         return;
0167     default:
0168         dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
0169         goto exit;
0170     }
0171
0172     if (len < 1) {
0173         dev_warn(&port->dev, "short message received\n");
0174         goto exit;
0175     }
0176
0177     /* see if the message is data or a status interrupt */
0178     switch (data[0]) {
0179     case 0:
0180          /* rest of message is rx data */
0181         if (len < 2)
0182             break;
0183         tty_insert_flip_string(&port->port, data + 1, len - 1);
0184         tty_flip_buffer_push(&port->port);
0185         break;
0186     case 1:
0187         /* status interrupt */
0188         if (len < 2) {
0189             dev_warn(&port->dev, "short interrupt message received\n");
0190             break;
0191         }
0192         dev_dbg(&port->dev, "rx int, d1=%d\n", data[1]);
0193         switch (data[1]) {
0194         case 1: /* modemline change */
0195             break;
0196         case 2: /* tx unthrottle interrupt */
0197             spin_lock_irqsave(&port->lock, flags);
0198             priv->tx_room = max(priv->tx_room, KEYSPAN_TX_THRESHOLD);
0199             spin_unlock_irqrestore(&port->lock, flags);
0200
0201             keyspan_pda_write_start(port);
0202
0203             usb_serial_port_softint(port);
0204             break;
0205         default:
0206             break;
0207         }
0208         break;
0209     default:
0210         break;
0211     }
0212
0213 exit:
0214     retval = usb_submit_urb(urb, GFP_ATOMIC);
0215     if (retval)
0216         dev_err(&port->dev,
0217             "%s - usb_submit_urb failed with result %d\n",
0218             __func__, retval);
0219 }
0220
0221 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
0222 {
0223     struct usb_serial_port *port = tty->driver_data;
0224
0225     /*
0226      * Stop receiving characters. We just turn off the URB request, and
0227      * let chars pile up in the device. If we're doing hardware
0228      * flowcontrol, the device will signal the other end when its buffer
0229      * fills up. If we're doing XON/XOFF, this would be a good time to
0230      * send an XOFF, although it might make sense to foist that off upon
0231      * the device too.
0232      */
0233     usb_kill_urb(port->interrupt_in_urb);
0234 }
0235
0236 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
0237 {
0238     struct usb_serial_port *port = tty->driver_data;
0239
0240     /* just restart the receive interrupt URB */
0241     if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
0242         dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
0243 }
0244
0245 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
0246 {
0247     int rc;
0248     int bindex;
0249
0250     switch (baud) {
0251     case 110:
0252         bindex = 0;
0253         break;
0254     case 300:
0255         bindex = 1;
0256         break;
0257     case 1200:
0258         bindex = 2;
0259         break;
0260     case 2400:
0261         bindex = 3;
0262         break;
0263     case 4800:
0264         bindex = 4;
0265         break;
0266     case 9600:
0267         bindex = 5;
0268         break;
0269     case 19200:
0270         bindex = 6;
0271         break;
0272     case 38400:
0273         bindex = 7;
0274         break;
0275     case 57600:
0276         bindex = 8;
0277         break;
0278     case 115200:
0279         bindex = 9;
0280         break;
0281     default:
0282         bindex = 5; /* Default to 9600 */
0283         baud = 9600;
0284     }
0285
0286     rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
0287                  0, /* set baud */
0288                  USB_TYPE_VENDOR
0289                  | USB_RECIP_INTERFACE
0290                  | USB_DIR_OUT, /* type */
0291                  bindex, /* value */
0292                  0, /* index */
0293                  NULL, /* &data */
0294                  0, /* size */
0295                  2000); /* timeout */
0296     if (rc < 0)
0297         return 0;
0298
0299     return baud;
0300 }
0301
0302 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
0303 {
0304     struct usb_serial_port *port = tty->driver_data;
0305     struct usb_serial *serial = port->serial;
0306     int value;
0307     int result;
0308
0309     if (break_state == -1)
0310         value = 1; /* start break */
0311     else
0312         value = 0; /* clear break */
0313
0314     result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
0315             4, /* set break */
0316             USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
0317             value, 0, NULL, 0, 2000);
0318     if (result < 0)
0319         dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
0320             __func__, result);
0321 }
0322
0323 static void keyspan_pda_set_termios(struct tty_struct *tty,
0324         struct usb_serial_port *port, struct ktermios *old_termios)
0325 {
0326     struct usb_serial *serial = port->serial;
0327     speed_t speed;
0328
0329     /*
0330      * cflag specifies lots of stuff: number of stop bits, parity, number
0331      * of data bits, baud. What can the device actually handle?:
0332      * CSTOPB (1 stop bit or 2)
0333      * PARENB (parity)
0334      * CSIZE (5bit .. 8bit)
0335      * There is minimal hw support for parity (a PSW bit seems to hold the
0336      * parity of whatever is in the accumulator). The UART either deals
0337      * with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
0338      * 1 special, stop). So, with firmware changes, we could do:
0339      * 8N1: 10 bit
0340      * 8N2: 11 bit, extra bit always (mark?)
0341      * 8[EOMS]1: 11 bit, extra bit is parity
0342      * 7[EOMS]1: 10 bit, b0/b7 is parity
0343      * 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
0344      *
0345      * HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
0346      * bit.
0347      *
0348      * For now, just do baud.
0349      */
0350     speed = tty_get_baud_rate(tty);
0351     speed = keyspan_pda_setbaud(serial, speed);
0352
0353     if (speed == 0) {
0354         dev_dbg(&port->dev, "can't handle requested baud rate\n");
0355         /* It hasn't changed so.. */
0356         speed = tty_termios_baud_rate(old_termios);
0357     }
0358     /*
0359      * Only speed can change so copy the old h/w parameters then encode
0360      * the new speed.
0361      */
0362     tty_termios_copy_hw(&tty->termios, old_termios);
0363     tty_encode_baud_rate(tty, speed, speed);
0364 }
0365
0366 /*
0367  * Modem control pins: DTR and RTS are outputs and can be controlled.
0368  * DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
0369  * read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused.
0370  */
0371 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
0372                       unsigned char *value)
0373 {
0374     int rc;
0375     u8 data;
0376
0377     rc = usb_control_msg_recv(serial->dev, 0,
0378                   3, /* get pins */
0379                   USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
0380                   0,
0381                   0,
0382                   &data,
0383                   1,
0384                   2000,
0385                   GFP_KERNEL);
0386     if (rc == 0)
0387         *value = data;
0388
0389     return rc;
0390 }
0391
0392 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
0393                       unsigned char value)
0394 {
0395     int rc;
0396     rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
0397                  3, /* set pins */
0398                  USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
0399                  value, 0, NULL, 0, 2000);
0400     return rc;
0401 }
0402
0403 static int keyspan_pda_tiocmget(struct tty_struct *tty)
0404 {
0405     struct usb_serial_port *port = tty->driver_data;
0406     struct usb_serial *serial = port->serial;
0407     int rc;
0408     unsigned char status;
0409     int value;
0410
0411     rc = keyspan_pda_get_modem_info(serial, &status);
0412     if (rc < 0)
0413         return rc;
0414
0415     value = ((status & BIT(7)) ? TIOCM_DTR : 0) |
0416         ((status & BIT(6)) ? TIOCM_CAR : 0) |
0417         ((status & BIT(5)) ? TIOCM_RNG : 0) |
0418         ((status & BIT(4)) ? TIOCM_DSR : 0) |
0419         ((status & BIT(3)) ? TIOCM_CTS : 0) |
0420         ((status & BIT(2)) ? TIOCM_RTS : 0);
0421
0422     return value;
0423 }
0424
0425 static int keyspan_pda_tiocmset(struct tty_struct *tty,
0426                 unsigned int set, unsigned int clear)
0427 {
0428     struct usb_serial_port *port = tty->driver_data;
0429     struct usb_serial *serial = port->serial;
0430     int rc;
0431     unsigned char status;
0432
0433     rc = keyspan_pda_get_modem_info(serial, &status);
0434     if (rc < 0)
0435         return rc;
0436
0437     if (set & TIOCM_RTS)
0438         status |= BIT(2);
0439     if (set & TIOCM_DTR)
0440         status |= BIT(7);
0441
0442     if (clear & TIOCM_RTS)
0443         status &= ~BIT(2);
0444     if (clear & TIOCM_DTR)
0445         status &= ~BIT(7);
0446     rc = keyspan_pda_set_modem_info(serial, status);
0447     return rc;
0448 }
0449
0450 static int keyspan_pda_write_start(struct usb_serial_port *port)
0451 {
0452     struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
0453     unsigned long flags;
0454     struct urb *urb;
0455     int count;
0456     int room;
0457     int rc;
0458
0459     /*
0460      * Guess how much room is left in the device's ring buffer. If our
0461      * write will result in no room left, ask the device to give us an
0462      * interrupt when the room available rises above a threshold but also
0463      * query how much room is currently available (in case our guess was
0464      * too conservative and the buffer is already empty when the
0465      * unthrottle work is scheduled).
0466      */
0467
0468     /*
0469      * We might block because of:
0470      * the TX urb is in-flight (wait until it completes)
0471      * the device is full (wait until it says there is room)
0472      */
0473     spin_lock_irqsave(&port->lock, flags);
0474
0475     room = priv->tx_room;
0476     count = kfifo_len(&port->write_fifo);
0477
0478     if (!test_bit(0, &port->write_urbs_free) || count == 0 || room == 0) {
0479         spin_unlock_irqrestore(&port->lock, flags);
0480         return 0;
0481     }
0482     __clear_bit(0, &port->write_urbs_free);
0483
0484     if (count > room)
0485         count = room;
0486     if (count > port->bulk_out_size)
0487         count = port->bulk_out_size;
0488
0489     urb = port->write_urb;
0490     count = kfifo_out(&port->write_fifo, urb->transfer_buffer, count);
0491     urb->transfer_buffer_length = count;
0492
0493     port->tx_bytes += count;
0494     priv->tx_room -= count;
0495
0496     spin_unlock_irqrestore(&port->lock, flags);
0497
0498     dev_dbg(&port->dev, "%s - count = %d, txroom = %d\n", __func__, count, room);
0499
0500     rc = usb_submit_urb(urb, GFP_ATOMIC);
0501     if (rc) {
0502         dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
0503
0504         spin_lock_irqsave(&port->lock, flags);
0505         port->tx_bytes -= count;
0506         priv->tx_room = max(priv->tx_room, room + count);
0507         __set_bit(0, &port->write_urbs_free);
0508         spin_unlock_irqrestore(&port->lock, flags);
0509
0510         return rc;
0511     }
0512
0513     if (count == room)
0514         schedule_work(&priv->unthrottle_work);
0515
0516     return count;
0517 }
0518
0519 static void keyspan_pda_write_bulk_callback(struct urb *urb)
0520 {
0521     struct usb_serial_port *port = urb->context;
0522     unsigned long flags;
0523
0524     spin_lock_irqsave(&port->lock, flags);
0525     port->tx_bytes -= urb->transfer_buffer_length;
0526     __set_bit(0, &port->write_urbs_free);
0527     spin_unlock_irqrestore(&port->lock, flags);
0528
0529     keyspan_pda_write_start(port);
0530
0531     usb_serial_port_softint(port);
0532 }
0533
0534 static int keyspan_pda_write(struct tty_struct *tty, struct usb_serial_port *port,
0535         const unsigned char *buf, int count)
0536 {
0537     int rc;
0538
0539     dev_dbg(&port->dev, "%s - count = %d\n", __func__, count);
0540
0541     if (!count)
0542         return 0;
0543
0544     count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
0545
0546     rc = keyspan_pda_write_start(port);
0547     if (rc)
0548         return rc;
0549
0550     return count;
0551 }
0552
0553 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
0554 {
0555     struct usb_serial *serial = port->serial;
0556
0557     if (on)
0558         keyspan_pda_set_modem_info(serial, BIT(7) | BIT(2));
0559     else
0560         keyspan_pda_set_modem_info(serial, 0);
0561 }
0562
0563
0564 static int keyspan_pda_open(struct tty_struct *tty,
0565                     struct usb_serial_port *port)
0566 {
0567     struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
0568     int rc;
0569
0570     /* find out how much room is in the Tx ring */
0571     rc = keyspan_pda_get_write_room(priv);
0572     if (rc < 0)
0573         return rc;
0574
0575     spin_lock_irq(&port->lock);
0576     priv->tx_room = rc;
0577     spin_unlock_irq(&port->lock);
0578
0579     rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
0580     if (rc) {
0581         dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
0582         return rc;
0583     }
0584
0585     return 0;
0586 }
0587
0588 static void keyspan_pda_close(struct usb_serial_port *port)
0589 {
0590     struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
0591
0592     /*
0593      * Stop the interrupt URB first as its completion handler may submit
0594      * the write URB.
0595      */
0596     usb_kill_urb(port->interrupt_in_urb);
0597     usb_kill_urb(port->write_urb);
0598
0599     cancel_work_sync(&priv->unthrottle_work);
0600
0601     spin_lock_irq(&port->lock);
0602     kfifo_reset(&port->write_fifo);
0603     spin_unlock_irq(&port->lock);
0604 }
0605
0606 /* download the firmware to a "fake" device (pre-renumeration) */
0607 static int keyspan_pda_fake_startup(struct usb_serial *serial)
0608 {
0609     unsigned int vid = le16_to_cpu(serial->dev->descriptor.idVendor);
0610     const char *fw_name;
0611
0612     /* download the firmware here ... */
0613     ezusb_fx1_set_reset(serial->dev, 1);
0614
0615     switch (vid) {
0616     case KEYSPAN_VENDOR_ID:
0617         fw_name = "keyspan_pda/keyspan_pda.fw";
0618         break;
0619     case XIRCOM_VENDOR_ID:
0620     case ENTREGA_VENDOR_ID:
0621         fw_name = "keyspan_pda/xircom_pgs.fw";
0622         break;
0623     default:
0624         dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
0625             __func__);
0626         return -ENODEV;
0627     }
0628
0629     if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
0630         dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
0631             fw_name);
0632         return -ENOENT;
0633     }
0634
0635     /*
0636      * After downloading firmware renumeration will occur in a moment and
0637      * the new device will bind to the real driver.
0638      */
0639
0640     /* We want this device to fail to have a driver assigned to it. */
0641     return 1;
0642 }
0643
0644 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
0645 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
0646
0647 static int keyspan_pda_port_probe(struct usb_serial_port *port)
0648 {
0649
0650     struct keyspan_pda_private *priv;
0651
0652     priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
0653     if (!priv)
0654         return -ENOMEM;
0655
0656     INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
0657     priv->port = port;
0658
0659     usb_set_serial_port_data(port, priv);
0660
0661     return 0;
0662 }
0663
0664 static void keyspan_pda_port_remove(struct usb_serial_port *port)
0665 {
0666     struct keyspan_pda_private *priv;
0667
0668     priv = usb_get_serial_port_data(port);
0669     kfree(priv);
0670 }
0671
0672 static struct usb_serial_driver keyspan_pda_fake_device = {
0673     .driver = {
0674         .owner =    THIS_MODULE,
0675         .name =     "keyspan_pda_pre",
0676     },
0677     .description =      "Keyspan PDA - (prerenumeration)",
0678     .id_table =     id_table_fake,
0679     .num_ports =        1,
0680     .attach =       keyspan_pda_fake_startup,
0681 };
0682
0683 static struct usb_serial_driver keyspan_pda_device = {
0684     .driver = {
0685         .owner =    THIS_MODULE,
0686         .name =     "keyspan_pda",
0687     },
0688     .description =      "Keyspan PDA",
0689     .id_table =     id_table_std,
0690     .num_ports =        1,
0691     .num_bulk_out =     1,
0692     .num_interrupt_in = 1,
0693     .dtr_rts =      keyspan_pda_dtr_rts,
0694     .open =         keyspan_pda_open,
0695     .close =        keyspan_pda_close,
0696     .write =        keyspan_pda_write,
0697     .write_bulk_callback =  keyspan_pda_write_bulk_callback,
0698     .read_int_callback =    keyspan_pda_rx_interrupt,
0699     .throttle =     keyspan_pda_rx_throttle,
0700     .unthrottle =       keyspan_pda_rx_unthrottle,
0701     .set_termios =      keyspan_pda_set_termios,
0702     .break_ctl =        keyspan_pda_break_ctl,
0703     .tiocmget =     keyspan_pda_tiocmget,
0704     .tiocmset =     keyspan_pda_tiocmset,
0705     .port_probe =       keyspan_pda_port_probe,
0706     .port_remove =      keyspan_pda_port_remove,
0707 };
0708
0709 static struct usb_serial_driver * const serial_drivers[] = {
0710     &keyspan_pda_device,
0711     &keyspan_pda_fake_device,
0712     NULL
0713 };
0714
0715 module_usb_serial_driver(serial_drivers, id_table_combined);
0716
0717 MODULE_AUTHOR(DRIVER_AUTHOR);
0718 MODULE_DESCRIPTION(DRIVER_DESC);
0719 MODULE_LICENSE("GPL");