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