1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/kernel.h>
19#include <linux/errno.h>
20#include <linux/init.h>
21#include <linux/slab.h>
22#include <linux/tty.h>
23#include <linux/tty_driver.h>
24#include <linux/tty_flip.h>
25#include <linux/module.h>
26#include <linux/spinlock.h>
27#include <linux/workqueue.h>
28#include <linux/uaccess.h>
29#include <linux/usb.h>
30#include <linux/usb/serial.h>
31#include <linux/usb/ezusb.h>
32
33
34#if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
35 #define KEYSPAN
36#else
37 #undef KEYSPAN
38#endif
39#if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
40 #define XIRCOM
41#else
42 #undef XIRCOM
43#endif
44
45#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
46#define DRIVER_DESC "USB Keyspan PDA Converter driver"
47
48struct keyspan_pda_private {
49 int tx_room;
50 int tx_throttled;
51 struct work_struct wakeup_work;
52 struct work_struct unthrottle_work;
53 struct usb_serial *serial;
54 struct usb_serial_port *port;
55};
56
57
58#define KEYSPAN_VENDOR_ID 0x06cd
59#define KEYSPAN_PDA_FAKE_ID 0x0103
60#define KEYSPAN_PDA_ID 0x0104
61
62
63#define XIRCOM_VENDOR_ID 0x085a
64#define XIRCOM_FAKE_ID 0x8027
65#define ENTREGRA_VENDOR_ID 0x1645
66#define ENTREGRA_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(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
75#endif
76 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
77 { }
78};
79
80MODULE_DEVICE_TABLE(usb, id_table_combined);
81
82static const struct usb_device_id id_table_std[] = {
83 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
84 { }
85};
86
87#ifdef KEYSPAN
88static const struct usb_device_id id_table_fake[] = {
89 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
90 { }
91};
92#endif
93
94#ifdef XIRCOM
95static const struct usb_device_id id_table_fake_xircom[] = {
96 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
97 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
98 { }
99};
100#endif
101
102static void keyspan_pda_wakeup_write(struct work_struct *work)
103{
104 struct keyspan_pda_private *priv =
105 container_of(work, struct keyspan_pda_private, wakeup_work);
106 struct usb_serial_port *port = priv->port;
107
108 tty_port_tty_wakeup(&port->port);
109}
110
111static void keyspan_pda_request_unthrottle(struct work_struct *work)
112{
113 struct keyspan_pda_private *priv =
114 container_of(work, struct keyspan_pda_private, unthrottle_work);
115 struct usb_serial *serial = priv->serial;
116 int result;
117
118
119
120 result = usb_control_msg(serial->dev,
121 usb_sndctrlpipe(serial->dev, 0),
122 7,
123 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
124 | USB_DIR_OUT,
125 16,
126 0,
127 NULL,
128 0,
129 2000);
130 if (result < 0)
131 dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
132 __func__, result);
133}
134
135
136static void keyspan_pda_rx_interrupt(struct urb *urb)
137{
138 struct usb_serial_port *port = urb->context;
139 unsigned char *data = urb->transfer_buffer;
140 int retval;
141 int status = urb->status;
142 struct keyspan_pda_private *priv;
143 priv = usb_get_serial_port_data(port);
144
145 switch (status) {
146 case 0:
147
148 break;
149 case -ECONNRESET:
150 case -ENOENT:
151 case -ESHUTDOWN:
152
153 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
154 return;
155 default:
156 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
157 goto exit;
158 }
159
160
161 switch (data[0]) {
162 case 0:
163
164 if (urb->actual_length) {
165 tty_insert_flip_string(&port->port, data + 1,
166 urb->actual_length - 1);
167 tty_flip_buffer_push(&port->port);
168 }
169 break;
170 case 1:
171
172 dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
173 switch (data[1]) {
174 case 1:
175 break;
176 case 2:
177 priv->tx_throttled = 0;
178
179 schedule_work(&priv->wakeup_work);
180 break;
181 default:
182 break;
183 }
184 break;
185 default:
186 break;
187 }
188
189exit:
190 retval = usb_submit_urb(urb, GFP_ATOMIC);
191 if (retval)
192 dev_err(&port->dev,
193 "%s - usb_submit_urb failed with result %d",
194 __func__, retval);
195}
196
197
198static void keyspan_pda_rx_throttle(struct tty_struct *tty)
199{
200
201
202
203
204
205
206 struct usb_serial_port *port = tty->driver_data;
207
208 usb_kill_urb(port->interrupt_in_urb);
209}
210
211
212static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
213{
214 struct usb_serial_port *port = tty->driver_data;
215
216
217 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
218 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
219}
220
221
222static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
223{
224 int rc;
225 int bindex;
226
227 switch (baud) {
228 case 110:
229 bindex = 0;
230 break;
231 case 300:
232 bindex = 1;
233 break;
234 case 1200:
235 bindex = 2;
236 break;
237 case 2400:
238 bindex = 3;
239 break;
240 case 4800:
241 bindex = 4;
242 break;
243 case 9600:
244 bindex = 5;
245 break;
246 case 19200:
247 bindex = 6;
248 break;
249 case 38400:
250 bindex = 7;
251 break;
252 case 57600:
253 bindex = 8;
254 break;
255 case 115200:
256 bindex = 9;
257 break;
258 default:
259 bindex = 5;
260 baud = 9600;
261 }
262
263
264
265 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
266 0,
267 USB_TYPE_VENDOR
268 | USB_RECIP_INTERFACE
269 | USB_DIR_OUT,
270 bindex,
271 0,
272 NULL,
273 0,
274 2000);
275 if (rc < 0)
276 return 0;
277 return baud;
278}
279
280
281static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
282{
283 struct usb_serial_port *port = tty->driver_data;
284 struct usb_serial *serial = port->serial;
285 int value;
286 int result;
287
288 if (break_state == -1)
289 value = 1;
290 else
291 value = 0;
292 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
293 4,
294 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
295 value, 0, NULL, 0, 2000);
296 if (result < 0)
297 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
298 __func__, result);
299
300
301
302
303}
304
305
306static void keyspan_pda_set_termios(struct tty_struct *tty,
307 struct usb_serial_port *port, struct ktermios *old_termios)
308{
309 struct usb_serial *serial = port->serial;
310 speed_t speed;
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332 speed = tty_get_baud_rate(tty);
333 speed = keyspan_pda_setbaud(serial, speed);
334
335 if (speed == 0) {
336 dev_dbg(&port->dev, "can't handle requested baud rate\n");
337
338 speed = tty_termios_baud_rate(old_termios);
339 }
340
341
342 tty_termios_copy_hw(&tty->termios, old_termios);
343 tty_encode_baud_rate(tty, speed, speed);
344}
345
346
347
348
349
350
351static int keyspan_pda_get_modem_info(struct usb_serial *serial,
352 unsigned char *value)
353{
354 int rc;
355 u8 *data;
356
357 data = kmalloc(1, GFP_KERNEL);
358 if (!data)
359 return -ENOMEM;
360
361 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
362 3,
363 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
364 0, 0, data, 1, 2000);
365 if (rc >= 0)
366 *value = *data;
367
368 kfree(data);
369 return rc;
370}
371
372
373static int keyspan_pda_set_modem_info(struct usb_serial *serial,
374 unsigned char value)
375{
376 int rc;
377 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
378 3,
379 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
380 value, 0, NULL, 0, 2000);
381 return rc;
382}
383
384static int keyspan_pda_tiocmget(struct tty_struct *tty)
385{
386 struct usb_serial_port *port = tty->driver_data;
387 struct usb_serial *serial = port->serial;
388 int rc;
389 unsigned char status;
390 int value;
391
392 rc = keyspan_pda_get_modem_info(serial, &status);
393 if (rc < 0)
394 return rc;
395 value =
396 ((status & (1<<7)) ? TIOCM_DTR : 0) |
397 ((status & (1<<6)) ? TIOCM_CAR : 0) |
398 ((status & (1<<5)) ? TIOCM_RNG : 0) |
399 ((status & (1<<4)) ? TIOCM_DSR : 0) |
400 ((status & (1<<3)) ? TIOCM_CTS : 0) |
401 ((status & (1<<2)) ? TIOCM_RTS : 0);
402 return value;
403}
404
405static int keyspan_pda_tiocmset(struct tty_struct *tty,
406 unsigned int set, unsigned int clear)
407{
408 struct usb_serial_port *port = tty->driver_data;
409 struct usb_serial *serial = port->serial;
410 int rc;
411 unsigned char status;
412
413 rc = keyspan_pda_get_modem_info(serial, &status);
414 if (rc < 0)
415 return rc;
416
417 if (set & TIOCM_RTS)
418 status |= (1<<2);
419 if (set & TIOCM_DTR)
420 status |= (1<<7);
421
422 if (clear & TIOCM_RTS)
423 status &= ~(1<<2);
424 if (clear & TIOCM_DTR)
425 status &= ~(1<<7);
426 rc = keyspan_pda_set_modem_info(serial, status);
427 return rc;
428}
429
430static int keyspan_pda_write(struct tty_struct *tty,
431 struct usb_serial_port *port, const unsigned char *buf, int count)
432{
433 struct usb_serial *serial = port->serial;
434 int request_unthrottle = 0;
435 int rc = 0;
436 struct keyspan_pda_private *priv;
437
438 priv = usb_get_serial_port_data(port);
439
440
441
442
443
444
445
446
447 if (count == 0) {
448 dev_dbg(&port->dev, "write request of 0 bytes\n");
449 return 0;
450 }
451
452
453
454
455
456 spin_lock_bh(&port->lock);
457 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
458 spin_unlock_bh(&port->lock);
459 return 0;
460 }
461 clear_bit(0, &port->write_urbs_free);
462 spin_unlock_bh(&port->lock);
463
464
465
466
467
468
469 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
470
471
472
473
474 if (count > priv->tx_room && !in_interrupt()) {
475 u8 *room;
476
477 room = kmalloc(1, GFP_KERNEL);
478 if (!room) {
479 rc = -ENOMEM;
480 goto exit;
481 }
482
483 rc = usb_control_msg(serial->dev,
484 usb_rcvctrlpipe(serial->dev, 0),
485 6,
486 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
487 | USB_DIR_IN,
488 0,
489 0,
490 room,
491 1,
492 2000);
493 if (rc > 0) {
494 dev_dbg(&port->dev, "roomquery says %d\n", *room);
495 priv->tx_room = *room;
496 }
497 kfree(room);
498 if (rc < 0) {
499 dev_dbg(&port->dev, "roomquery failed\n");
500 goto exit;
501 }
502 if (rc == 0) {
503 dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
504 rc = -EIO;
505 goto exit;
506 }
507 }
508 if (count > priv->tx_room) {
509
510
511 count = priv->tx_room;
512 request_unthrottle = 1;
513 }
514
515 if (count) {
516
517 memcpy(port->write_urb->transfer_buffer, buf, count);
518
519 port->write_urb->transfer_buffer_length = count;
520
521 priv->tx_room -= count;
522
523 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
524 if (rc) {
525 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
526 goto exit;
527 }
528 } else {
529
530
531 request_unthrottle = 1;
532 }
533
534 if (request_unthrottle) {
535 priv->tx_throttled = 1;
536 schedule_work(&priv->unthrottle_work);
537 }
538
539 rc = count;
540exit:
541 if (rc < 0)
542 set_bit(0, &port->write_urbs_free);
543 return rc;
544}
545
546
547static void keyspan_pda_write_bulk_callback(struct urb *urb)
548{
549 struct usb_serial_port *port = urb->context;
550 struct keyspan_pda_private *priv;
551
552 set_bit(0, &port->write_urbs_free);
553 priv = usb_get_serial_port_data(port);
554
555
556 schedule_work(&priv->wakeup_work);
557}
558
559
560static int keyspan_pda_write_room(struct tty_struct *tty)
561{
562 struct usb_serial_port *port = tty->driver_data;
563 struct keyspan_pda_private *priv;
564 priv = usb_get_serial_port_data(port);
565
566
567
568 return priv->tx_room;
569}
570
571
572static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
573{
574 struct usb_serial_port *port = tty->driver_data;
575 struct keyspan_pda_private *priv;
576 unsigned long flags;
577 int ret = 0;
578
579 priv = usb_get_serial_port_data(port);
580
581
582
583
584 spin_lock_irqsave(&port->lock, flags);
585 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
586 ret = 256;
587 spin_unlock_irqrestore(&port->lock, flags);
588 return ret;
589}
590
591
592static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
593{
594 struct usb_serial *serial = port->serial;
595
596 if (on)
597 keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
598 else
599 keyspan_pda_set_modem_info(serial, 0);
600}
601
602
603static int keyspan_pda_open(struct tty_struct *tty,
604 struct usb_serial_port *port)
605{
606 struct usb_serial *serial = port->serial;
607 u8 *room;
608 int rc = 0;
609 struct keyspan_pda_private *priv;
610
611
612 room = kmalloc(1, GFP_KERNEL);
613 if (!room)
614 return -ENOMEM;
615
616 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
617 6,
618 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
619 | USB_DIR_IN,
620 0,
621 0,
622 room,
623 1,
624 2000);
625 if (rc < 0) {
626 dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
627 goto error;
628 }
629 if (rc == 0) {
630 dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
631 rc = -EIO;
632 goto error;
633 }
634 priv = usb_get_serial_port_data(port);
635 priv->tx_room = *room;
636 priv->tx_throttled = *room ? 0 : 1;
637
638
639 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
640 if (rc) {
641 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
642 goto error;
643 }
644error:
645 kfree(room);
646 return rc;
647}
648static void keyspan_pda_close(struct usb_serial_port *port)
649{
650 usb_kill_urb(port->write_urb);
651 usb_kill_urb(port->interrupt_in_urb);
652}
653
654
655
656static int keyspan_pda_fake_startup(struct usb_serial *serial)
657{
658 int response;
659 const char *fw_name;
660
661
662 response = ezusb_fx1_set_reset(serial->dev, 1);
663
664 if (0) { ; }
665#ifdef KEYSPAN
666 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
667 fw_name = "keyspan_pda/keyspan_pda.fw";
668#endif
669#ifdef XIRCOM
670 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
671 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
672 fw_name = "keyspan_pda/xircom_pgs.fw";
673#endif
674 else {
675 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
676 __func__);
677 return -ENODEV;
678 }
679
680 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
681 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
682 fw_name);
683 return -ENOENT;
684 }
685
686
687
688
689
690 return 1;
691}
692
693#ifdef KEYSPAN
694MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
695#endif
696#ifdef XIRCOM
697MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
698#endif
699
700static int keyspan_pda_port_probe(struct usb_serial_port *port)
701{
702
703 struct keyspan_pda_private *priv;
704
705 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
706 if (!priv)
707 return -ENOMEM;
708
709 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
710 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
711 priv->serial = port->serial;
712 priv->port = port;
713
714 usb_set_serial_port_data(port, priv);
715
716 return 0;
717}
718
719static int keyspan_pda_port_remove(struct usb_serial_port *port)
720{
721 struct keyspan_pda_private *priv;
722
723 priv = usb_get_serial_port_data(port);
724 kfree(priv);
725
726 return 0;
727}
728
729#ifdef KEYSPAN
730static struct usb_serial_driver keyspan_pda_fake_device = {
731 .driver = {
732 .owner = THIS_MODULE,
733 .name = "keyspan_pda_pre",
734 },
735 .description = "Keyspan PDA - (prerenumeration)",
736 .id_table = id_table_fake,
737 .num_ports = 1,
738 .attach = keyspan_pda_fake_startup,
739};
740#endif
741
742#ifdef XIRCOM
743static struct usb_serial_driver xircom_pgs_fake_device = {
744 .driver = {
745 .owner = THIS_MODULE,
746 .name = "xircom_no_firm",
747 },
748 .description = "Xircom / Entregra PGS - (prerenumeration)",
749 .id_table = id_table_fake_xircom,
750 .num_ports = 1,
751 .attach = keyspan_pda_fake_startup,
752};
753#endif
754
755static struct usb_serial_driver keyspan_pda_device = {
756 .driver = {
757 .owner = THIS_MODULE,
758 .name = "keyspan_pda",
759 },
760 .description = "Keyspan PDA",
761 .id_table = id_table_std,
762 .num_ports = 1,
763 .dtr_rts = keyspan_pda_dtr_rts,
764 .open = keyspan_pda_open,
765 .close = keyspan_pda_close,
766 .write = keyspan_pda_write,
767 .write_room = keyspan_pda_write_room,
768 .write_bulk_callback = keyspan_pda_write_bulk_callback,
769 .read_int_callback = keyspan_pda_rx_interrupt,
770 .chars_in_buffer = keyspan_pda_chars_in_buffer,
771 .throttle = keyspan_pda_rx_throttle,
772 .unthrottle = keyspan_pda_rx_unthrottle,
773 .set_termios = keyspan_pda_set_termios,
774 .break_ctl = keyspan_pda_break_ctl,
775 .tiocmget = keyspan_pda_tiocmget,
776 .tiocmset = keyspan_pda_tiocmset,
777 .port_probe = keyspan_pda_port_probe,
778 .port_remove = keyspan_pda_port_remove,
779};
780
781static struct usb_serial_driver * const serial_drivers[] = {
782 &keyspan_pda_device,
783#ifdef KEYSPAN
784 &keyspan_pda_fake_device,
785#endif
786#ifdef XIRCOM
787 &xircom_pgs_fake_device,
788#endif
789 NULL
790};
791
792module_usb_serial_driver(serial_drivers, id_table_combined);
793
794MODULE_AUTHOR(DRIVER_AUTHOR);
795MODULE_DESCRIPTION(DRIVER_DESC);
796MODULE_LICENSE("GPL");
797