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
keyspan_pda_get_write_room(struct keyspan_pda_private * priv)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
keyspan_pda_request_unthrottle(struct work_struct * work)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
keyspan_pda_rx_interrupt(struct urb * urb)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
keyspan_pda_rx_throttle(struct tty_struct * tty)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
keyspan_pda_rx_unthrottle(struct tty_struct * tty)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
keyspan_pda_setbaud(struct usb_serial * serial,speed_t baud)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
keyspan_pda_break_ctl(struct tty_struct * tty,int break_state)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
keyspan_pda_set_termios(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)323 static void keyspan_pda_set_termios(struct tty_struct *tty,
324 struct usb_serial_port *port, struct ktermios *old_termios)
325 {
326 struct usb_serial *serial = port->serial;
327 speed_t speed;
328
329 /*
330 * cflag specifies lots of stuff: number of stop bits, parity, number
331 * of data bits, baud. What can the device actually handle?:
332 * CSTOPB (1 stop bit or 2)
333 * PARENB (parity)
334 * CSIZE (5bit .. 8bit)
335 * There is minimal hw support for parity (a PSW bit seems to hold the
336 * parity of whatever is in the accumulator). The UART either deals
337 * with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
338 * 1 special, stop). So, with firmware changes, we could do:
339 * 8N1: 10 bit
340 * 8N2: 11 bit, extra bit always (mark?)
341 * 8[EOMS]1: 11 bit, extra bit is parity
342 * 7[EOMS]1: 10 bit, b0/b7 is parity
343 * 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
344 *
345 * HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
346 * bit.
347 *
348 * For now, just do baud.
349 */
350 speed = tty_get_baud_rate(tty);
351 speed = keyspan_pda_setbaud(serial, speed);
352
353 if (speed == 0) {
354 dev_dbg(&port->dev, "can't handle requested baud rate\n");
355 /* It hasn't changed so.. */
356 speed = tty_termios_baud_rate(old_termios);
357 }
358 /*
359 * Only speed can change so copy the old h/w parameters then encode
360 * the new speed.
361 */
362 tty_termios_copy_hw(&tty->termios, old_termios);
363 tty_encode_baud_rate(tty, speed, speed);
364 }
365
366 /*
367 * Modem control pins: DTR and RTS are outputs and can be controlled.
368 * DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
369 * read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused.
370 */
keyspan_pda_get_modem_info(struct usb_serial * serial,unsigned char * value)371 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
372 unsigned char *value)
373 {
374 int rc;
375 u8 data;
376
377 rc = usb_control_msg_recv(serial->dev, 0,
378 3, /* get pins */
379 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
380 0,
381 0,
382 &data,
383 1,
384 2000,
385 GFP_KERNEL);
386 if (rc == 0)
387 *value = data;
388
389 return rc;
390 }
391
keyspan_pda_set_modem_info(struct usb_serial * serial,unsigned char value)392 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
393 unsigned char value)
394 {
395 int rc;
396 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
397 3, /* set pins */
398 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
399 value, 0, NULL, 0, 2000);
400 return rc;
401 }
402
keyspan_pda_tiocmget(struct tty_struct * tty)403 static int keyspan_pda_tiocmget(struct tty_struct *tty)
404 {
405 struct usb_serial_port *port = tty->driver_data;
406 struct usb_serial *serial = port->serial;
407 int rc;
408 unsigned char status;
409 int value;
410
411 rc = keyspan_pda_get_modem_info(serial, &status);
412 if (rc < 0)
413 return rc;
414
415 value = ((status & BIT(7)) ? TIOCM_DTR : 0) |
416 ((status & BIT(6)) ? TIOCM_CAR : 0) |
417 ((status & BIT(5)) ? TIOCM_RNG : 0) |
418 ((status & BIT(4)) ? TIOCM_DSR : 0) |
419 ((status & BIT(3)) ? TIOCM_CTS : 0) |
420 ((status & BIT(2)) ? TIOCM_RTS : 0);
421
422 return value;
423 }
424
keyspan_pda_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)425 static int keyspan_pda_tiocmset(struct tty_struct *tty,
426 unsigned int set, unsigned int clear)
427 {
428 struct usb_serial_port *port = tty->driver_data;
429 struct usb_serial *serial = port->serial;
430 int rc;
431 unsigned char status;
432
433 rc = keyspan_pda_get_modem_info(serial, &status);
434 if (rc < 0)
435 return rc;
436
437 if (set & TIOCM_RTS)
438 status |= BIT(2);
439 if (set & TIOCM_DTR)
440 status |= BIT(7);
441
442 if (clear & TIOCM_RTS)
443 status &= ~BIT(2);
444 if (clear & TIOCM_DTR)
445 status &= ~BIT(7);
446 rc = keyspan_pda_set_modem_info(serial, status);
447 return rc;
448 }
449
keyspan_pda_write_start(struct usb_serial_port * port)450 static int keyspan_pda_write_start(struct usb_serial_port *port)
451 {
452 struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
453 unsigned long flags;
454 struct urb *urb;
455 int count;
456 int room;
457 int rc;
458
459 /*
460 * Guess how much room is left in the device's ring buffer. If our
461 * write will result in no room left, ask the device to give us an
462 * interrupt when the room available rises above a threshold but also
463 * query how much room is currently available (in case our guess was
464 * too conservative and the buffer is already empty when the
465 * unthrottle work is scheduled).
466 */
467
468 /*
469 * We might block because of:
470 * the TX urb is in-flight (wait until it completes)
471 * the device is full (wait until it says there is room)
472 */
473 spin_lock_irqsave(&port->lock, flags);
474
475 room = priv->tx_room;
476 count = kfifo_len(&port->write_fifo);
477
478 if (!test_bit(0, &port->write_urbs_free) || count == 0 || room == 0) {
479 spin_unlock_irqrestore(&port->lock, flags);
480 return 0;
481 }
482 __clear_bit(0, &port->write_urbs_free);
483
484 if (count > room)
485 count = room;
486 if (count > port->bulk_out_size)
487 count = port->bulk_out_size;
488
489 urb = port->write_urb;
490 count = kfifo_out(&port->write_fifo, urb->transfer_buffer, count);
491 urb->transfer_buffer_length = count;
492
493 port->tx_bytes += count;
494 priv->tx_room -= count;
495
496 spin_unlock_irqrestore(&port->lock, flags);
497
498 dev_dbg(&port->dev, "%s - count = %d, txroom = %d\n", __func__, count, room);
499
500 rc = usb_submit_urb(urb, GFP_ATOMIC);
501 if (rc) {
502 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
503
504 spin_lock_irqsave(&port->lock, flags);
505 port->tx_bytes -= count;
506 priv->tx_room = max(priv->tx_room, room + count);
507 __set_bit(0, &port->write_urbs_free);
508 spin_unlock_irqrestore(&port->lock, flags);
509
510 return rc;
511 }
512
513 if (count == room)
514 schedule_work(&priv->unthrottle_work);
515
516 return count;
517 }
518
keyspan_pda_write_bulk_callback(struct urb * urb)519 static void keyspan_pda_write_bulk_callback(struct urb *urb)
520 {
521 struct usb_serial_port *port = urb->context;
522 unsigned long flags;
523
524 spin_lock_irqsave(&port->lock, flags);
525 port->tx_bytes -= urb->transfer_buffer_length;
526 __set_bit(0, &port->write_urbs_free);
527 spin_unlock_irqrestore(&port->lock, flags);
528
529 keyspan_pda_write_start(port);
530
531 usb_serial_port_softint(port);
532 }
533
keyspan_pda_write(struct tty_struct * tty,struct usb_serial_port * port,const unsigned char * buf,int count)534 static int keyspan_pda_write(struct tty_struct *tty, struct usb_serial_port *port,
535 const unsigned char *buf, int count)
536 {
537 int rc;
538
539 dev_dbg(&port->dev, "%s - count = %d\n", __func__, count);
540
541 if (!count)
542 return 0;
543
544 count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
545
546 rc = keyspan_pda_write_start(port);
547 if (rc)
548 return rc;
549
550 return count;
551 }
552
keyspan_pda_dtr_rts(struct usb_serial_port * port,int on)553 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
554 {
555 struct usb_serial *serial = port->serial;
556
557 if (on)
558 keyspan_pda_set_modem_info(serial, BIT(7) | BIT(2));
559 else
560 keyspan_pda_set_modem_info(serial, 0);
561 }
562
563
keyspan_pda_open(struct tty_struct * tty,struct usb_serial_port * port)564 static int keyspan_pda_open(struct tty_struct *tty,
565 struct usb_serial_port *port)
566 {
567 struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
568 int rc;
569
570 /* find out how much room is in the Tx ring */
571 rc = keyspan_pda_get_write_room(priv);
572 if (rc < 0)
573 return rc;
574
575 spin_lock_irq(&port->lock);
576 priv->tx_room = rc;
577 spin_unlock_irq(&port->lock);
578
579 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
580 if (rc) {
581 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
582 return rc;
583 }
584
585 return 0;
586 }
587
keyspan_pda_close(struct usb_serial_port * port)588 static void keyspan_pda_close(struct usb_serial_port *port)
589 {
590 struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
591
592 /*
593 * Stop the interrupt URB first as its completion handler may submit
594 * the write URB.
595 */
596 usb_kill_urb(port->interrupt_in_urb);
597 usb_kill_urb(port->write_urb);
598
599 cancel_work_sync(&priv->unthrottle_work);
600
601 spin_lock_irq(&port->lock);
602 kfifo_reset(&port->write_fifo);
603 spin_unlock_irq(&port->lock);
604 }
605
606 /* download the firmware to a "fake" device (pre-renumeration) */
keyspan_pda_fake_startup(struct usb_serial * serial)607 static int keyspan_pda_fake_startup(struct usb_serial *serial)
608 {
609 unsigned int vid = le16_to_cpu(serial->dev->descriptor.idVendor);
610 const char *fw_name;
611
612 /* download the firmware here ... */
613 ezusb_fx1_set_reset(serial->dev, 1);
614
615 switch (vid) {
616 case KEYSPAN_VENDOR_ID:
617 fw_name = "keyspan_pda/keyspan_pda.fw";
618 break;
619 case XIRCOM_VENDOR_ID:
620 case ENTREGA_VENDOR_ID:
621 fw_name = "keyspan_pda/xircom_pgs.fw";
622 break;
623 default:
624 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
625 __func__);
626 return -ENODEV;
627 }
628
629 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
630 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
631 fw_name);
632 return -ENOENT;
633 }
634
635 /*
636 * After downloading firmware renumeration will occur in a moment and
637 * the new device will bind to the real driver.
638 */
639
640 /* We want this device to fail to have a driver assigned to it. */
641 return 1;
642 }
643
644 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
645 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
646
keyspan_pda_port_probe(struct usb_serial_port * port)647 static int keyspan_pda_port_probe(struct usb_serial_port *port)
648 {
649
650 struct keyspan_pda_private *priv;
651
652 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
653 if (!priv)
654 return -ENOMEM;
655
656 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
657 priv->port = port;
658
659 usb_set_serial_port_data(port, priv);
660
661 return 0;
662 }
663
keyspan_pda_port_remove(struct usb_serial_port * port)664 static void keyspan_pda_port_remove(struct usb_serial_port *port)
665 {
666 struct keyspan_pda_private *priv;
667
668 priv = usb_get_serial_port_data(port);
669 kfree(priv);
670 }
671
672 static struct usb_serial_driver keyspan_pda_fake_device = {
673 .driver = {
674 .owner = THIS_MODULE,
675 .name = "keyspan_pda_pre",
676 },
677 .description = "Keyspan PDA - (prerenumeration)",
678 .id_table = id_table_fake,
679 .num_ports = 1,
680 .attach = keyspan_pda_fake_startup,
681 };
682
683 static struct usb_serial_driver keyspan_pda_device = {
684 .driver = {
685 .owner = THIS_MODULE,
686 .name = "keyspan_pda",
687 },
688 .description = "Keyspan PDA",
689 .id_table = id_table_std,
690 .num_ports = 1,
691 .num_bulk_out = 1,
692 .num_interrupt_in = 1,
693 .dtr_rts = keyspan_pda_dtr_rts,
694 .open = keyspan_pda_open,
695 .close = keyspan_pda_close,
696 .write = keyspan_pda_write,
697 .write_bulk_callback = keyspan_pda_write_bulk_callback,
698 .read_int_callback = keyspan_pda_rx_interrupt,
699 .throttle = keyspan_pda_rx_throttle,
700 .unthrottle = keyspan_pda_rx_unthrottle,
701 .set_termios = keyspan_pda_set_termios,
702 .break_ctl = keyspan_pda_break_ctl,
703 .tiocmget = keyspan_pda_tiocmget,
704 .tiocmset = keyspan_pda_tiocmset,
705 .port_probe = keyspan_pda_port_probe,
706 .port_remove = keyspan_pda_port_remove,
707 };
708
709 static struct usb_serial_driver * const serial_drivers[] = {
710 &keyspan_pda_device,
711 &keyspan_pda_fake_device,
712 NULL
713 };
714
715 module_usb_serial_driver(serial_drivers, id_table_combined);
716
717 MODULE_AUTHOR(DRIVER_AUTHOR);
718 MODULE_DESCRIPTION(DRIVER_DESC);
719 MODULE_LICENSE("GPL");
720