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 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
keyspan_pda_request_unthrottle(struct work_struct * work)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
keyspan_pda_rx_interrupt(struct urb * urb)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
keyspan_pda_rx_throttle(struct tty_struct * tty)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
keyspan_pda_rx_unthrottle(struct tty_struct * tty)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
keyspan_pda_setbaud(struct usb_serial * serial,speed_t baud)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
keyspan_pda_break_ctl(struct tty_struct * tty,int break_state)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
keyspan_pda_set_termios(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)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 */
keyspan_pda_get_modem_info(struct usb_serial * serial,unsigned char * value)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
keyspan_pda_set_modem_info(struct usb_serial * serial,unsigned char value)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
keyspan_pda_tiocmget(struct tty_struct * tty)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
keyspan_pda_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)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
keyspan_pda_write_start(struct usb_serial_port * port)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
keyspan_pda_write_bulk_callback(struct urb * urb)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
keyspan_pda_write(struct tty_struct * tty,struct usb_serial_port * port,const unsigned char * buf,int count)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
keyspan_pda_dtr_rts(struct usb_serial_port * port,int on)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
keyspan_pda_open(struct tty_struct * tty,struct usb_serial_port * port)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
keyspan_pda_close(struct usb_serial_port * port)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) */
keyspan_pda_fake_startup(struct usb_serial * serial)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
keyspan_pda_port_probe(struct usb_serial_port * port)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
keyspan_pda_port_remove(struct usb_serial_port * port)675 static void 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
683 static struct usb_serial_driver keyspan_pda_fake_device = {
684 .driver = {
685 .owner = THIS_MODULE,
686 .name = "keyspan_pda_pre",
687 },
688 .description = "Keyspan PDA - (prerenumeration)",
689 .id_table = id_table_fake,
690 .num_ports = 1,
691 .attach = keyspan_pda_fake_startup,
692 };
693
694 static struct usb_serial_driver keyspan_pda_device = {
695 .driver = {
696 .owner = THIS_MODULE,
697 .name = "keyspan_pda",
698 },
699 .description = "Keyspan PDA",
700 .id_table = id_table_std,
701 .num_ports = 1,
702 .num_bulk_out = 1,
703 .num_interrupt_in = 1,
704 .dtr_rts = keyspan_pda_dtr_rts,
705 .open = keyspan_pda_open,
706 .close = keyspan_pda_close,
707 .write = keyspan_pda_write,
708 .write_bulk_callback = keyspan_pda_write_bulk_callback,
709 .read_int_callback = keyspan_pda_rx_interrupt,
710 .throttle = keyspan_pda_rx_throttle,
711 .unthrottle = keyspan_pda_rx_unthrottle,
712 .set_termios = keyspan_pda_set_termios,
713 .break_ctl = keyspan_pda_break_ctl,
714 .tiocmget = keyspan_pda_tiocmget,
715 .tiocmset = keyspan_pda_tiocmset,
716 .port_probe = keyspan_pda_port_probe,
717 .port_remove = keyspan_pda_port_remove,
718 };
719
720 static struct usb_serial_driver * const serial_drivers[] = {
721 &keyspan_pda_device,
722 &keyspan_pda_fake_device,
723 NULL
724 };
725
726 module_usb_serial_driver(serial_drivers, id_table_combined);
727
728 MODULE_AUTHOR(DRIVER_AUTHOR);
729 MODULE_DESCRIPTION(DRIVER_DESC);
730 MODULE_LICENSE("GPL");
731