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