1
2
3
4
5
6
7
8
9
10
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
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
56
57
58#define XIRCOM_VENDOR_ID 0x085a
59#define XIRCOM_FAKE_ID 0x8027
60#define XIRCOM_FAKE_ID_2 0x8025
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 { }
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 { }
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 { }
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
117
118 result = usb_control_msg(serial->dev,
119 usb_sndctrlpipe(serial->dev, 0),
120 7,
121 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
122 | USB_DIR_OUT,
123 16,
124 0,
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
147 break;
148 case -ECONNRESET:
149 case -ENOENT:
150 case -ESHUTDOWN:
151
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
165 switch (data[0]) {
166 case 0:
167
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
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:
182 break;
183 case 2:
184 priv->tx_throttled = 0;
185
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
208
209
210
211
212
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
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;
267 baud = 9600;
268 }
269
270
271
272 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
273 0,
274 USB_TYPE_VENDOR
275 | USB_RECIP_INTERFACE
276 | USB_DIR_OUT,
277 bindex,
278 0,
279 NULL,
280 0,
281 2000);
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;
297 else
298 value = 0;
299 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
300 4,
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
307
308
309
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
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
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
345 speed = tty_termios_baud_rate(old_termios);
346 }
347
348
349 tty_termios_copy_hw(&tty->termios, old_termios);
350 tty_encode_baud_rate(tty, speed, speed);
351}
352
353
354
355
356
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,
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,
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
447
448
449
450
451
452
453
454 if (count == 0) {
455 dev_dbg(&port->dev, "write request of 0 bytes\n");
456 return 0;
457 }
458
459
460
461
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
472
473
474
475
476 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
477
478
479
480
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,
493 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
494 | USB_DIR_IN,
495 0,
496 0,
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;
512 goto exit;
513 }
514 }
515 if (count > priv->tx_room) {
516
517
518 count = priv->tx_room;
519 request_unthrottle = 1;
520 }
521
522 if (count) {
523
524 memcpy(port->write_urb->transfer_buffer, buf, count);
525
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
537
538 request_unthrottle = 1;
539 }
540
541 if (request_unthrottle) {
542 priv->tx_throttled = 1;
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
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
573
574
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
589
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
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,
625 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
626 | USB_DIR_IN,
627 0,
628 0,
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
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
663static int keyspan_pda_fake_startup(struct usb_serial *serial)
664{
665 int response;
666 const char *fw_name;
667
668
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
694
695
696
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");
806