Loading...
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 *
9 * See Documentation/usb/usb-serial.txt for more information on using this
10 * driver
11 */
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/* make a simple define to handle if we are compiling keyspan_pda or xircom support */
29#if IS_ENABLED(CONFIG_USB_SERIAL_KEYSPAN_PDA)
30 #define KEYSPAN
31#else
32 #undef KEYSPAN
33#endif
34#if IS_ENABLED(CONFIG_USB_SERIAL_XIRCOM)
35 #define XIRCOM
36#else
37 #undef XIRCOM
38#endif
39
40#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
41#define DRIVER_DESC "USB Keyspan PDA Converter driver"
42
43struct keyspan_pda_private {
44 int tx_room;
45 int tx_throttled;
46 struct work_struct wakeup_work;
47 struct work_struct unthrottle_work;
48 struct usb_serial *serial;
49 struct usb_serial_port *port;
50};
51
52
53#define KEYSPAN_VENDOR_ID 0x06cd
54#define KEYSPAN_PDA_FAKE_ID 0x0103
55#define KEYSPAN_PDA_ID 0x0104 /* no clue */
56
57/* For Xircom PGSDB9 and older Entrega version of the same device */
58#define XIRCOM_VENDOR_ID 0x085a
59#define XIRCOM_FAKE_ID 0x8027
60#define XIRCOM_FAKE_ID_2 0x8025 /* "PGMFHUB" serial */
61#define ENTREGA_VENDOR_ID 0x1645
62#define ENTREGA_FAKE_ID 0x8093
63
64static const struct usb_device_id id_table_combined[] = {
65#ifdef KEYSPAN
66 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
67#endif
68#ifdef XIRCOM
69 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
70 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
71 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
72#endif
73 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
74 { } /* Terminating entry */
75};
76
77MODULE_DEVICE_TABLE(usb, id_table_combined);
78
79static const struct usb_device_id id_table_std[] = {
80 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
81 { } /* Terminating entry */
82};
83
84#ifdef KEYSPAN
85static const struct usb_device_id id_table_fake[] = {
86 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
87 { } /* Terminating entry */
88};
89#endif
90
91#ifdef XIRCOM
92static const struct usb_device_id id_table_fake_xircom[] = {
93 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
94 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
95 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
96 { }
97};
98#endif
99
100static void keyspan_pda_wakeup_write(struct work_struct *work)
101{
102 struct keyspan_pda_private *priv =
103 container_of(work, struct keyspan_pda_private, wakeup_work);
104 struct usb_serial_port *port = priv->port;
105
106 tty_port_tty_wakeup(&port->port);
107}
108
109static void keyspan_pda_request_unthrottle(struct work_struct *work)
110{
111 struct keyspan_pda_private *priv =
112 container_of(work, struct keyspan_pda_private, unthrottle_work);
113 struct usb_serial *serial = priv->serial;
114 int result;
115
116 /* ask the device to tell us when the tx buffer becomes
117 sufficiently empty */
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 16, /* value: 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
133
134static void keyspan_pda_rx_interrupt(struct urb *urb)
135{
136 struct usb_serial_port *port = urb->context;
137 unsigned char *data = urb->transfer_buffer;
138 unsigned int len = urb->actual_length;
139 int retval;
140 int status = urb->status;
141 struct keyspan_pda_private *priv;
142 priv = usb_get_serial_port_data(port);
143
144 switch (status) {
145 case 0:
146 /* success */
147 break;
148 case -ECONNRESET:
149 case -ENOENT:
150 case -ESHUTDOWN:
151 /* this urb is terminated, clean up */
152 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
153 return;
154 default:
155 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
156 goto exit;
157 }
158
159 if (len < 1) {
160 dev_warn(&port->dev, "short message received\n");
161 goto exit;
162 }
163
164 /* see if the message is data or a status interrupt */
165 switch (data[0]) {
166 case 0:
167 /* rest of message is rx data */
168 if (len < 2)
169 break;
170 tty_insert_flip_string(&port->port, data + 1, len - 1);
171 tty_flip_buffer_push(&port->port);
172 break;
173 case 1:
174 /* status interrupt */
175 if (len < 3) {
176 dev_warn(&port->dev, "short interrupt message received\n");
177 break;
178 }
179 dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
180 switch (data[1]) {
181 case 1: /* modemline change */
182 break;
183 case 2: /* tx unthrottle interrupt */
184 priv->tx_throttled = 0;
185 /* queue up a wakeup at scheduler time */
186 schedule_work(&priv->wakeup_work);
187 break;
188 default:
189 break;
190 }
191 break;
192 default:
193 break;
194 }
195
196exit:
197 retval = usb_submit_urb(urb, GFP_ATOMIC);
198 if (retval)
199 dev_err(&port->dev,
200 "%s - usb_submit_urb failed with result %d\n",
201 __func__, retval);
202}
203
204
205static void keyspan_pda_rx_throttle(struct tty_struct *tty)
206{
207 /* stop receiving characters. We just turn off the URB request, and
208 let chars pile up in the device. If we're doing hardware
209 flowcontrol, the device will signal the other end when its buffer
210 fills up. If we're doing XON/XOFF, this would be a good time to
211 send an XOFF, although it might make sense to foist that off
212 upon the device too. */
213 struct usb_serial_port *port = tty->driver_data;
214
215 usb_kill_urb(port->interrupt_in_urb);
216}
217
218
219static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
220{
221 struct usb_serial_port *port = tty->driver_data;
222 /* just restart the receive interrupt URB */
223
224 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
225 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
226}
227
228
229static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
230{
231 int rc;
232 int bindex;
233
234 switch (baud) {
235 case 110:
236 bindex = 0;
237 break;
238 case 300:
239 bindex = 1;
240 break;
241 case 1200:
242 bindex = 2;
243 break;
244 case 2400:
245 bindex = 3;
246 break;
247 case 4800:
248 bindex = 4;
249 break;
250 case 9600:
251 bindex = 5;
252 break;
253 case 19200:
254 bindex = 6;
255 break;
256 case 38400:
257 bindex = 7;
258 break;
259 case 57600:
260 bindex = 8;
261 break;
262 case 115200:
263 bindex = 9;
264 break;
265 default:
266 bindex = 5; /* Default to 9600 */
267 baud = 9600;
268 }
269
270 /* rather than figure out how to sleep while waiting for this
271 to complete, I just use the "legacy" API. */
272 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
273 0, /* set baud */
274 USB_TYPE_VENDOR
275 | USB_RECIP_INTERFACE
276 | USB_DIR_OUT, /* type */
277 bindex, /* value */
278 0, /* index */
279 NULL, /* &data */
280 0, /* size */
281 2000); /* timeout */
282 if (rc < 0)
283 return 0;
284 return baud;
285}
286
287
288static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
289{
290 struct usb_serial_port *port = tty->driver_data;
291 struct usb_serial *serial = port->serial;
292 int value;
293 int result;
294
295 if (break_state == -1)
296 value = 1; /* start break */
297 else
298 value = 0; /* clear break */
299 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
300 4, /* set break */
301 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
302 value, 0, NULL, 0, 2000);
303 if (result < 0)
304 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
305 __func__, result);
306 /* there is something funky about this.. the TCSBRK that 'cu' performs
307 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
308 seconds apart, but it feels like the break sent isn't as long as it
309 is on /dev/ttyS0 */
310}
311
312
313static void keyspan_pda_set_termios(struct tty_struct *tty,
314 struct usb_serial_port *port, struct ktermios *old_termios)
315{
316 struct usb_serial *serial = port->serial;
317 speed_t speed;
318
319 /* cflag specifies lots of stuff: number of stop bits, parity, number
320 of data bits, baud. What can the device actually handle?:
321 CSTOPB (1 stop bit or 2)
322 PARENB (parity)
323 CSIZE (5bit .. 8bit)
324 There is minimal hw support for parity (a PSW bit seems to hold the
325 parity of whatever is in the accumulator). The UART either deals
326 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
327 1 special, stop). So, with firmware changes, we could do:
328 8N1: 10 bit
329 8N2: 11 bit, extra bit always (mark?)
330 8[EOMS]1: 11 bit, extra bit is parity
331 7[EOMS]1: 10 bit, b0/b7 is parity
332 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
333
334 HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
335 bit.
336
337 For now, just do baud. */
338
339 speed = tty_get_baud_rate(tty);
340 speed = keyspan_pda_setbaud(serial, speed);
341
342 if (speed == 0) {
343 dev_dbg(&port->dev, "can't handle requested baud rate\n");
344 /* It hasn't changed so.. */
345 speed = tty_termios_baud_rate(old_termios);
346 }
347 /* Only speed can change so copy the old h/w parameters
348 then encode the new speed */
349 tty_termios_copy_hw(&tty->termios, old_termios);
350 tty_encode_baud_rate(tty, speed, speed);
351}
352
353
354/* modem control pins: DTR and RTS are outputs and can be controlled.
355 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
356 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
357
358static int keyspan_pda_get_modem_info(struct usb_serial *serial,
359 unsigned char *value)
360{
361 int rc;
362 u8 *data;
363
364 data = kmalloc(1, GFP_KERNEL);
365 if (!data)
366 return -ENOMEM;
367
368 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
369 3, /* get pins */
370 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
371 0, 0, data, 1, 2000);
372 if (rc >= 0)
373 *value = *data;
374
375 kfree(data);
376 return rc;
377}
378
379
380static int keyspan_pda_set_modem_info(struct usb_serial *serial,
381 unsigned char value)
382{
383 int rc;
384 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
385 3, /* set pins */
386 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
387 value, 0, NULL, 0, 2000);
388 return rc;
389}
390
391static int keyspan_pda_tiocmget(struct tty_struct *tty)
392{
393 struct usb_serial_port *port = tty->driver_data;
394 struct usb_serial *serial = port->serial;
395 int rc;
396 unsigned char status;
397 int value;
398
399 rc = keyspan_pda_get_modem_info(serial, &status);
400 if (rc < 0)
401 return rc;
402 value =
403 ((status & (1<<7)) ? TIOCM_DTR : 0) |
404 ((status & (1<<6)) ? TIOCM_CAR : 0) |
405 ((status & (1<<5)) ? TIOCM_RNG : 0) |
406 ((status & (1<<4)) ? TIOCM_DSR : 0) |
407 ((status & (1<<3)) ? TIOCM_CTS : 0) |
408 ((status & (1<<2)) ? TIOCM_RTS : 0);
409 return value;
410}
411
412static int keyspan_pda_tiocmset(struct tty_struct *tty,
413 unsigned int set, unsigned int clear)
414{
415 struct usb_serial_port *port = tty->driver_data;
416 struct usb_serial *serial = port->serial;
417 int rc;
418 unsigned char status;
419
420 rc = keyspan_pda_get_modem_info(serial, &status);
421 if (rc < 0)
422 return rc;
423
424 if (set & TIOCM_RTS)
425 status |= (1<<2);
426 if (set & TIOCM_DTR)
427 status |= (1<<7);
428
429 if (clear & TIOCM_RTS)
430 status &= ~(1<<2);
431 if (clear & TIOCM_DTR)
432 status &= ~(1<<7);
433 rc = keyspan_pda_set_modem_info(serial, status);
434 return rc;
435}
436
437static int keyspan_pda_write(struct tty_struct *tty,
438 struct usb_serial_port *port, const unsigned char *buf, int count)
439{
440 struct usb_serial *serial = port->serial;
441 int request_unthrottle = 0;
442 int rc = 0;
443 struct keyspan_pda_private *priv;
444
445 priv = usb_get_serial_port_data(port);
446 /* guess how much room is left in the device's ring buffer, and if we
447 want to send more than that, check first, updating our notion of
448 what is left. If our write will result in no room left, ask the
449 device to give us an interrupt when the room available rises above
450 a threshold, and hold off all writers (eventually, those using
451 select() or poll() too) until we receive that unthrottle interrupt.
452 Block if we can't write anything at all, otherwise write as much as
453 we can. */
454 if (count == 0) {
455 dev_dbg(&port->dev, "write request of 0 bytes\n");
456 return 0;
457 }
458
459 /* we might block because of:
460 the TX urb is in-flight (wait until it completes)
461 the device is full (wait until it says there is room)
462 */
463 spin_lock_bh(&port->lock);
464 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
465 spin_unlock_bh(&port->lock);
466 return 0;
467 }
468 clear_bit(0, &port->write_urbs_free);
469 spin_unlock_bh(&port->lock);
470
471 /* At this point the URB is in our control, nobody else can submit it
472 again (the only sudden transition was the one from EINPROGRESS to
473 finished). Also, the tx process is not throttled. So we are
474 ready to write. */
475
476 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
477
478 /* Check if we might overrun the Tx buffer. If so, ask the
479 device how much room it really has. This is done only on
480 scheduler time, since usb_control_msg() sleeps. */
481 if (count > priv->tx_room && !in_interrupt()) {
482 u8 *room;
483
484 room = kmalloc(1, GFP_KERNEL);
485 if (!room) {
486 rc = -ENOMEM;
487 goto exit;
488 }
489
490 rc = usb_control_msg(serial->dev,
491 usb_rcvctrlpipe(serial->dev, 0),
492 6, /* write_room */
493 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
494 | USB_DIR_IN,
495 0, /* value: 0 means "remaining room" */
496 0, /* index */
497 room,
498 1,
499 2000);
500 if (rc > 0) {
501 dev_dbg(&port->dev, "roomquery says %d\n", *room);
502 priv->tx_room = *room;
503 }
504 kfree(room);
505 if (rc < 0) {
506 dev_dbg(&port->dev, "roomquery failed\n");
507 goto exit;
508 }
509 if (rc == 0) {
510 dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
511 rc = -EIO; /* device didn't return any data */
512 goto exit;
513 }
514 }
515 if (count > priv->tx_room) {
516 /* we're about to completely fill the Tx buffer, so
517 we'll be throttled afterwards. */
518 count = priv->tx_room;
519 request_unthrottle = 1;
520 }
521
522 if (count) {
523 /* now transfer data */
524 memcpy(port->write_urb->transfer_buffer, buf, count);
525 /* send the data out the bulk port */
526 port->write_urb->transfer_buffer_length = count;
527
528 priv->tx_room -= count;
529
530 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
531 if (rc) {
532 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
533 goto exit;
534 }
535 } else {
536 /* There wasn't any room left, so we are throttled until
537 the buffer empties a bit */
538 request_unthrottle = 1;
539 }
540
541 if (request_unthrottle) {
542 priv->tx_throttled = 1; /* block writers */
543 schedule_work(&priv->unthrottle_work);
544 }
545
546 rc = count;
547exit:
548 if (rc < 0)
549 set_bit(0, &port->write_urbs_free);
550 return rc;
551}
552
553
554static void keyspan_pda_write_bulk_callback(struct urb *urb)
555{
556 struct usb_serial_port *port = urb->context;
557 struct keyspan_pda_private *priv;
558
559 set_bit(0, &port->write_urbs_free);
560 priv = usb_get_serial_port_data(port);
561
562 /* queue up a wakeup at scheduler time */
563 schedule_work(&priv->wakeup_work);
564}
565
566
567static int keyspan_pda_write_room(struct tty_struct *tty)
568{
569 struct usb_serial_port *port = tty->driver_data;
570 struct keyspan_pda_private *priv;
571 priv = usb_get_serial_port_data(port);
572 /* used by n_tty.c for processing of tabs and such. Giving it our
573 conservative guess is probably good enough, but needs testing by
574 running a console through the device. */
575 return priv->tx_room;
576}
577
578
579static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
580{
581 struct usb_serial_port *port = tty->driver_data;
582 struct keyspan_pda_private *priv;
583 unsigned long flags;
584 int ret = 0;
585
586 priv = usb_get_serial_port_data(port);
587
588 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
589 n_tty.c:normal_poll() ) that we're not writeable. */
590
591 spin_lock_irqsave(&port->lock, flags);
592 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
593 ret = 256;
594 spin_unlock_irqrestore(&port->lock, flags);
595 return ret;
596}
597
598
599static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
600{
601 struct usb_serial *serial = port->serial;
602
603 if (on)
604 keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
605 else
606 keyspan_pda_set_modem_info(serial, 0);
607}
608
609
610static int keyspan_pda_open(struct tty_struct *tty,
611 struct usb_serial_port *port)
612{
613 struct usb_serial *serial = port->serial;
614 u8 *room;
615 int rc = 0;
616 struct keyspan_pda_private *priv;
617
618 /* find out how much room is in the Tx ring */
619 room = kmalloc(1, GFP_KERNEL);
620 if (!room)
621 return -ENOMEM;
622
623 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
624 6, /* write_room */
625 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
626 | USB_DIR_IN,
627 0, /* value */
628 0, /* index */
629 room,
630 1,
631 2000);
632 if (rc < 0) {
633 dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
634 goto error;
635 }
636 if (rc == 0) {
637 dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
638 rc = -EIO;
639 goto error;
640 }
641 priv = usb_get_serial_port_data(port);
642 priv->tx_room = *room;
643 priv->tx_throttled = *room ? 0 : 1;
644
645 /*Start reading from the device*/
646 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
647 if (rc) {
648 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
649 goto error;
650 }
651error:
652 kfree(room);
653 return rc;
654}
655static void keyspan_pda_close(struct usb_serial_port *port)
656{
657 usb_kill_urb(port->write_urb);
658 usb_kill_urb(port->interrupt_in_urb);
659}
660
661
662/* download the firmware to a "fake" device (pre-renumeration) */
663static int keyspan_pda_fake_startup(struct usb_serial *serial)
664{
665 int response;
666 const char *fw_name;
667
668 /* download the firmware here ... */
669 response = ezusb_fx1_set_reset(serial->dev, 1);
670
671 if (0) { ; }
672#ifdef KEYSPAN
673 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
674 fw_name = "keyspan_pda/keyspan_pda.fw";
675#endif
676#ifdef XIRCOM
677 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
678 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
679 fw_name = "keyspan_pda/xircom_pgs.fw";
680#endif
681 else {
682 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
683 __func__);
684 return -ENODEV;
685 }
686
687 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
688 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
689 fw_name);
690 return -ENOENT;
691 }
692
693 /* after downloading firmware Renumeration will occur in a
694 moment and the new device will bind to the real driver */
695
696 /* we want this device to fail to have a driver assigned to it. */
697 return 1;
698}
699
700#ifdef KEYSPAN
701MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
702#endif
703#ifdef XIRCOM
704MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
705#endif
706
707static int keyspan_pda_port_probe(struct usb_serial_port *port)
708{
709
710 struct keyspan_pda_private *priv;
711
712 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
713 if (!priv)
714 return -ENOMEM;
715
716 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
717 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
718 priv->serial = port->serial;
719 priv->port = port;
720
721 usb_set_serial_port_data(port, priv);
722
723 return 0;
724}
725
726static int keyspan_pda_port_remove(struct usb_serial_port *port)
727{
728 struct keyspan_pda_private *priv;
729
730 priv = usb_get_serial_port_data(port);
731 kfree(priv);
732
733 return 0;
734}
735
736#ifdef KEYSPAN
737static struct usb_serial_driver keyspan_pda_fake_device = {
738 .driver = {
739 .owner = THIS_MODULE,
740 .name = "keyspan_pda_pre",
741 },
742 .description = "Keyspan PDA - (prerenumeration)",
743 .id_table = id_table_fake,
744 .num_ports = 1,
745 .attach = keyspan_pda_fake_startup,
746};
747#endif
748
749#ifdef XIRCOM
750static struct usb_serial_driver xircom_pgs_fake_device = {
751 .driver = {
752 .owner = THIS_MODULE,
753 .name = "xircom_no_firm",
754 },
755 .description = "Xircom / Entrega PGS - (prerenumeration)",
756 .id_table = id_table_fake_xircom,
757 .num_ports = 1,
758 .attach = keyspan_pda_fake_startup,
759};
760#endif
761
762static struct usb_serial_driver keyspan_pda_device = {
763 .driver = {
764 .owner = THIS_MODULE,
765 .name = "keyspan_pda",
766 },
767 .description = "Keyspan PDA",
768 .id_table = id_table_std,
769 .num_ports = 1,
770 .num_bulk_out = 1,
771 .num_interrupt_in = 1,
772 .dtr_rts = keyspan_pda_dtr_rts,
773 .open = keyspan_pda_open,
774 .close = keyspan_pda_close,
775 .write = keyspan_pda_write,
776 .write_room = keyspan_pda_write_room,
777 .write_bulk_callback = keyspan_pda_write_bulk_callback,
778 .read_int_callback = keyspan_pda_rx_interrupt,
779 .chars_in_buffer = keyspan_pda_chars_in_buffer,
780 .throttle = keyspan_pda_rx_throttle,
781 .unthrottle = keyspan_pda_rx_unthrottle,
782 .set_termios = keyspan_pda_set_termios,
783 .break_ctl = keyspan_pda_break_ctl,
784 .tiocmget = keyspan_pda_tiocmget,
785 .tiocmset = keyspan_pda_tiocmset,
786 .port_probe = keyspan_pda_port_probe,
787 .port_remove = keyspan_pda_port_remove,
788};
789
790static struct usb_serial_driver * const serial_drivers[] = {
791 &keyspan_pda_device,
792#ifdef KEYSPAN
793 &keyspan_pda_fake_device,
794#endif
795#ifdef XIRCOM
796 &xircom_pgs_fake_device,
797#endif
798 NULL
799};
800
801module_usb_serial_driver(serial_drivers, id_table_combined);
802
803MODULE_AUTHOR(DRIVER_AUTHOR);
804MODULE_DESCRIPTION(DRIVER_DESC);
805MODULE_LICENSE("GPL");
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
33struct 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
40static 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
53static 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};
61MODULE_DEVICE_TABLE(usb, id_table_combined);
62
63static const struct usb_device_id id_table_std[] = {
64 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
65 { } /* Terminating entry */
66};
67
68static 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
76static 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
103static 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
145static 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
213exit:
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
221static 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
236static 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
245static 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
302static 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
323static 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 */
372static 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
393static 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
404static 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
426static 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
451static 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
520static 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
535static 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
554static 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
565static 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
589static 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) */
608static 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
645MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
646MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
647
648static 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
665static 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
673static 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
684static 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
710static struct usb_serial_driver * const serial_drivers[] = {
711 &keyspan_pda_device,
712 &keyspan_pda_fake_device,
713 NULL
714};
715
716module_usb_serial_driver(serial_drivers, id_table_combined);
717
718MODULE_AUTHOR(DRIVER_AUTHOR);
719MODULE_DESCRIPTION(DRIVER_DESC);
720MODULE_LICENSE("GPL");