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