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#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
45
46
47#define XIRCOM_VENDOR_ID 0x085a
48#define XIRCOM_FAKE_ID 0x8027
49#define XIRCOM_FAKE_ID_2 0x8025
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 { }
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 { }
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 { }
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,
90 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
91 | USB_DIR_IN,
92 0,
93 0,
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
125
126
127 result = usb_control_msg(serial->dev,
128 usb_sndctrlpipe(serial->dev, 0),
129 7,
130 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
131 | USB_DIR_OUT,
132 KEYSPAN_TX_THRESHOLD,
133 0,
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
142
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
169 break;
170 case -ECONNRESET:
171 case -ENOENT:
172 case -ESHUTDOWN:
173
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
187 switch (data[0]) {
188 case 0:
189
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
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:
204 break;
205 case 2:
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
236
237
238
239
240
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
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;
292 baud = 9600;
293 }
294
295 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
296 0,
297 USB_TYPE_VENDOR
298 | USB_RECIP_INTERFACE
299 | USB_DIR_OUT,
300 bindex,
301 0,
302 NULL,
303 0,
304 2000);
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;
320 else
321 value = 0;
322
323 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
324 4,
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
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
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
365 speed = tty_termios_baud_rate(old_termios);
366 }
367
368
369
370
371 tty_termios_copy_hw(&tty->termios, old_termios);
372 tty_encode_baud_rate(tty, speed, speed);
373}
374
375
376
377
378
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,
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,
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
472
473
474
475
476
477
478
479
480
481
482
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
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
605
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
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
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
648
649
650
651
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");
731