2 * USB Keyspan PDA / Xircom / Entregra Converter driver
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>
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.
13 * See Documentation/usb/usb-serial.txt for more information on using this
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/firmware.h>
29 #include <linux/ihex.h>
30 #include <linux/uaccess.h>
31 #include <linux/usb.h>
32 #include <linux/usb/serial.h>
36 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */
37 #if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
42 #if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
51 #define DRIVER_VERSION "v1.1"
52 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
53 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
55 struct keyspan_pda_private {
58 struct work_struct wakeup_work;
59 struct work_struct unthrottle_work;
60 struct usb_serial *serial;
61 struct usb_serial_port *port;
65 #define KEYSPAN_VENDOR_ID 0x06cd
66 #define KEYSPAN_PDA_FAKE_ID 0x0103
67 #define KEYSPAN_PDA_ID 0x0104 /* no clue */
69 /* For Xircom PGSDB9 and older Entregra version of the same device */
70 #define XIRCOM_VENDOR_ID 0x085a
71 #define XIRCOM_FAKE_ID 0x8027
72 #define ENTREGRA_VENDOR_ID 0x1645
73 #define ENTREGRA_FAKE_ID 0x8093
75 static const struct usb_device_id id_table_combined[] = {
77 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
80 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
81 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
83 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
84 { } /* Terminating entry */
87 MODULE_DEVICE_TABLE(usb, id_table_combined);
89 static struct usb_driver keyspan_pda_driver = {
90 .name = "keyspan_pda",
91 .probe = usb_serial_probe,
92 .disconnect = usb_serial_disconnect,
93 .id_table = id_table_combined,
96 static const struct usb_device_id id_table_std[] = {
97 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
98 { } /* Terminating entry */
102 static const struct usb_device_id id_table_fake[] = {
103 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
104 { } /* Terminating entry */
109 static const struct usb_device_id id_table_fake_xircom[] = {
110 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
111 { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
116 static void keyspan_pda_wakeup_write(struct work_struct *work)
118 struct keyspan_pda_private *priv =
119 container_of(work, struct keyspan_pda_private, wakeup_work);
120 struct usb_serial_port *port = priv->port;
121 struct tty_struct *tty = tty_port_tty_get(&port->port);
127 static void keyspan_pda_request_unthrottle(struct work_struct *work)
129 struct keyspan_pda_private *priv =
130 container_of(work, struct keyspan_pda_private, unthrottle_work);
131 struct usb_serial *serial = priv->serial;
134 dbg(" request_unthrottle");
135 /* ask the device to tell us when the tx buffer becomes
136 sufficiently empty */
137 result = usb_control_msg(serial->dev,
138 usb_sndctrlpipe(serial->dev, 0),
139 7, /* request_unthrottle */
140 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
142 16, /* value: threshold */
148 dbg("%s - error %d from usb_control_msg",
153 static void keyspan_pda_rx_interrupt(struct urb *urb)
155 struct usb_serial_port *port = urb->context;
156 struct tty_struct *tty;
157 unsigned char *data = urb->transfer_buffer;
159 int status = urb->status;
160 struct keyspan_pda_private *priv;
161 priv = usb_get_serial_port_data(port);
170 /* this urb is terminated, clean up */
171 dbg("%s - urb shutting down with status: %d",
175 dbg("%s - nonzero urb status received: %d",
180 /* see if the message is data or a status interrupt */
183 tty = tty_port_tty_get(&port->port);
184 /* rest of message is rx data */
185 if (tty && urb->actual_length) {
186 tty_insert_flip_string(tty, data + 1,
187 urb->actual_length - 1);
188 tty_flip_buffer_push(tty);
193 /* status interrupt */
194 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
196 case 1: /* modemline change */
198 case 2: /* tx unthrottle interrupt */
199 priv->tx_throttled = 0;
200 /* queue up a wakeup at scheduler time */
201 schedule_work(&priv->wakeup_work);
212 retval = usb_submit_urb(urb, GFP_ATOMIC);
215 "%s - usb_submit_urb failed with result %d",
220 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
222 /* stop receiving characters. We just turn off the URB request, and
223 let chars pile up in the device. If we're doing hardware
224 flowcontrol, the device will signal the other end when its buffer
225 fills up. If we're doing XON/XOFF, this would be a good time to
226 send an XOFF, although it might make sense to foist that off
227 upon the device too. */
228 struct usb_serial_port *port = tty->driver_data;
229 dbg("keyspan_pda_rx_throttle port %d", port->number);
230 usb_kill_urb(port->interrupt_in_urb);
234 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
236 struct usb_serial_port *port = tty->driver_data;
237 /* just restart the receive interrupt URB */
238 dbg("keyspan_pda_rx_unthrottle port %d", port->number);
239 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
240 dbg(" usb_submit_urb(read urb) failed");
244 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
281 bindex = 5; /* Default to 9600 */
285 /* rather than figure out how to sleep while waiting for this
286 to complete, I just use the "legacy" API. */
287 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
290 | USB_RECIP_INTERFACE
291 | USB_DIR_OUT, /* type */
303 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
305 struct usb_serial_port *port = tty->driver_data;
306 struct usb_serial *serial = port->serial;
310 if (break_state == -1)
311 value = 1; /* start break */
313 value = 0; /* clear break */
314 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
316 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
317 value, 0, NULL, 0, 2000);
319 dbg("%s - error %d from usb_control_msg",
321 /* there is something funky about this.. the TCSBRK that 'cu' performs
322 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
323 seconds apart, but it feels like the break sent isn't as long as it
328 static void keyspan_pda_set_termios(struct tty_struct *tty,
329 struct usb_serial_port *port, struct ktermios *old_termios)
331 struct usb_serial *serial = port->serial;
334 /* cflag specifies lots of stuff: number of stop bits, parity, number
335 of data bits, baud. What can the device actually handle?:
336 CSTOPB (1 stop bit or 2)
339 There is minimal hw support for parity (a PSW bit seems to hold the
340 parity of whatever is in the accumulator). The UART either deals
341 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
342 1 special, stop). So, with firmware changes, we could do:
344 8N2: 11 bit, extra bit always (mark?)
345 8[EOMS]1: 11 bit, extra bit is parity
346 7[EOMS]1: 10 bit, b0/b7 is parity
347 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
349 HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
352 For now, just do baud. */
354 speed = tty_get_baud_rate(tty);
355 speed = keyspan_pda_setbaud(serial, speed);
358 dbg("can't handle requested baud rate");
359 /* It hasn't changed so.. */
360 speed = tty_termios_baud_rate(old_termios);
362 /* Only speed can change so copy the old h/w parameters
363 then encode the new speed */
364 tty_termios_copy_hw(tty->termios, old_termios);
365 tty_encode_baud_rate(tty, speed, speed);
369 /* modem control pins: DTR and RTS are outputs and can be controlled.
370 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
371 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
373 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
374 unsigned char *value)
379 data = kmalloc(1, GFP_KERNEL);
383 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
385 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
386 0, 0, data, 1, 2000);
395 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
399 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
401 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
402 value, 0, NULL, 0, 2000);
406 static int keyspan_pda_tiocmget(struct tty_struct *tty)
408 struct usb_serial_port *port = tty->driver_data;
409 struct usb_serial *serial = port->serial;
411 unsigned char status;
414 rc = keyspan_pda_get_modem_info(serial, &status);
418 ((status & (1<<7)) ? TIOCM_DTR : 0) |
419 ((status & (1<<6)) ? TIOCM_CAR : 0) |
420 ((status & (1<<5)) ? TIOCM_RNG : 0) |
421 ((status & (1<<4)) ? TIOCM_DSR : 0) |
422 ((status & (1<<3)) ? TIOCM_CTS : 0) |
423 ((status & (1<<2)) ? TIOCM_RTS : 0);
427 static int keyspan_pda_tiocmset(struct tty_struct *tty,
428 unsigned int set, unsigned int clear)
430 struct usb_serial_port *port = tty->driver_data;
431 struct usb_serial *serial = port->serial;
433 unsigned char status;
435 rc = keyspan_pda_get_modem_info(serial, &status);
444 if (clear & TIOCM_RTS)
446 if (clear & TIOCM_DTR)
448 rc = keyspan_pda_set_modem_info(serial, status);
452 static int keyspan_pda_write(struct tty_struct *tty,
453 struct usb_serial_port *port, const unsigned char *buf, int count)
455 struct usb_serial *serial = port->serial;
456 int request_unthrottle = 0;
458 struct keyspan_pda_private *priv;
460 priv = usb_get_serial_port_data(port);
461 /* guess how much room is left in the device's ring buffer, and if we
462 want to send more than that, check first, updating our notion of
463 what is left. If our write will result in no room left, ask the
464 device to give us an interrupt when the room available rises above
465 a threshold, and hold off all writers (eventually, those using
466 select() or poll() too) until we receive that unthrottle interrupt.
467 Block if we can't write anything at all, otherwise write as much as
469 dbg("keyspan_pda_write(%d)", count);
471 dbg(" write request of 0 bytes");
475 /* we might block because of:
476 the TX urb is in-flight (wait until it completes)
477 the device is full (wait until it says there is room)
479 spin_lock_bh(&port->lock);
480 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
481 spin_unlock_bh(&port->lock);
484 clear_bit(0, &port->write_urbs_free);
485 spin_unlock_bh(&port->lock);
487 /* At this point the URB is in our control, nobody else can submit it
488 again (the only sudden transition was the one from EINPROGRESS to
489 finished). Also, the tx process is not throttled. So we are
492 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
494 /* Check if we might overrun the Tx buffer. If so, ask the
495 device how much room it really has. This is done only on
496 scheduler time, since usb_control_msg() sleeps. */
497 if (count > priv->tx_room && !in_interrupt()) {
500 room = kmalloc(1, GFP_KERNEL);
506 rc = usb_control_msg(serial->dev,
507 usb_rcvctrlpipe(serial->dev, 0),
509 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
511 0, /* value: 0 means "remaining room" */
517 dbg(" roomquery says %d", *room);
518 priv->tx_room = *room;
522 dbg(" roomquery failed");
526 dbg(" roomquery returned 0 bytes");
527 rc = -EIO; /* device didn't return any data */
531 if (count > priv->tx_room) {
532 /* we're about to completely fill the Tx buffer, so
533 we'll be throttled afterwards. */
534 count = priv->tx_room;
535 request_unthrottle = 1;
539 /* now transfer data */
540 memcpy(port->write_urb->transfer_buffer, buf, count);
541 /* send the data out the bulk port */
542 port->write_urb->transfer_buffer_length = count;
544 priv->tx_room -= count;
546 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
548 dbg(" usb_submit_urb(write bulk) failed");
552 /* There wasn't any room left, so we are throttled until
553 the buffer empties a bit */
554 request_unthrottle = 1;
557 if (request_unthrottle) {
558 priv->tx_throttled = 1; /* block writers */
559 schedule_work(&priv->unthrottle_work);
565 set_bit(0, &port->write_urbs_free);
570 static void keyspan_pda_write_bulk_callback(struct urb *urb)
572 struct usb_serial_port *port = urb->context;
573 struct keyspan_pda_private *priv;
575 set_bit(0, &port->write_urbs_free);
576 priv = usb_get_serial_port_data(port);
578 /* queue up a wakeup at scheduler time */
579 schedule_work(&priv->wakeup_work);
583 static int keyspan_pda_write_room(struct tty_struct *tty)
585 struct usb_serial_port *port = tty->driver_data;
586 struct keyspan_pda_private *priv;
587 priv = usb_get_serial_port_data(port);
588 /* used by n_tty.c for processing of tabs and such. Giving it our
589 conservative guess is probably good enough, but needs testing by
590 running a console through the device. */
591 return priv->tx_room;
595 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
597 struct usb_serial_port *port = tty->driver_data;
598 struct keyspan_pda_private *priv;
602 priv = usb_get_serial_port_data(port);
604 /* when throttled, return at least WAKEUP_CHARS to tell select() (via
605 n_tty.c:normal_poll() ) that we're not writeable. */
607 spin_lock_irqsave(&port->lock, flags);
608 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
610 spin_unlock_irqrestore(&port->lock, flags);
615 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
617 struct usb_serial *serial = port->serial;
621 keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
623 keyspan_pda_set_modem_info(serial, 0);
628 static int keyspan_pda_open(struct tty_struct *tty,
629 struct usb_serial_port *port)
631 struct usb_serial *serial = port->serial;
634 struct keyspan_pda_private *priv;
636 /* find out how much room is in the Tx ring */
637 room = kmalloc(1, GFP_KERNEL);
641 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
643 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
651 dbg("%s - roomquery failed", __func__);
655 dbg("%s - roomquery returned 0 bytes", __func__);
659 priv = usb_get_serial_port_data(port);
660 priv->tx_room = *room;
661 priv->tx_throttled = *room ? 0 : 1;
663 /*Start reading from the device*/
664 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
666 dbg("%s - usb_submit_urb(read int) failed", __func__);
673 static void keyspan_pda_close(struct usb_serial_port *port)
675 struct usb_serial *serial = port->serial;
678 /* shutdown our bulk reads and writes */
679 usb_kill_urb(port->write_urb);
680 usb_kill_urb(port->interrupt_in_urb);
685 /* download the firmware to a "fake" device (pre-renumeration) */
686 static int keyspan_pda_fake_startup(struct usb_serial *serial)
690 const struct ihex_binrec *record;
691 const struct firmware *fw;
693 /* download the firmware here ... */
694 response = ezusb_set_reset(serial, 1);
698 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
699 fw_name = "keyspan_pda/keyspan_pda.fw";
702 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
703 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
704 fw_name = "keyspan_pda/xircom_pgs.fw";
707 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
711 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
712 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
716 record = (const struct ihex_binrec *)fw->data;
719 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
720 (unsigned char *)record->data,
721 be16_to_cpu(record->len), 0xa0);
723 dev_err(&serial->dev->dev, "ezusb_writememory failed "
724 "for Keyspan PDA firmware (%d %04X %p %d)\n",
725 response, be32_to_cpu(record->addr),
726 record->data, be16_to_cpu(record->len));
729 record = ihex_next_binrec(record);
731 release_firmware(fw);
732 /* bring device out of reset. Renumeration will occur in a moment
733 and the new device will bind to the real driver */
734 response = ezusb_set_reset(serial, 0);
736 /* we want this device to fail to have a driver assigned to it. */
741 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
744 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
747 static int keyspan_pda_startup(struct usb_serial *serial)
750 struct keyspan_pda_private *priv;
752 /* allocate the private data structures for all ports. Well, for all
755 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
757 return 1; /* error */
758 usb_set_serial_port_data(serial->port[0], priv);
759 init_waitqueue_head(&serial->port[0]->write_wait);
760 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
761 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
762 priv->serial = serial;
763 priv->port = serial->port[0];
767 static void keyspan_pda_release(struct usb_serial *serial)
771 kfree(usb_get_serial_port_data(serial->port[0]));
775 static struct usb_serial_driver keyspan_pda_fake_device = {
777 .owner = THIS_MODULE,
778 .name = "keyspan_pda_pre",
780 .description = "Keyspan PDA - (prerenumeration)",
781 .id_table = id_table_fake,
783 .attach = keyspan_pda_fake_startup,
788 static struct usb_serial_driver xircom_pgs_fake_device = {
790 .owner = THIS_MODULE,
791 .name = "xircom_no_firm",
793 .description = "Xircom / Entregra PGS - (prerenumeration)",
794 .id_table = id_table_fake_xircom,
796 .attach = keyspan_pda_fake_startup,
800 static struct usb_serial_driver keyspan_pda_device = {
802 .owner = THIS_MODULE,
803 .name = "keyspan_pda",
805 .description = "Keyspan PDA",
806 .id_table = id_table_std,
808 .dtr_rts = keyspan_pda_dtr_rts,
809 .open = keyspan_pda_open,
810 .close = keyspan_pda_close,
811 .write = keyspan_pda_write,
812 .write_room = keyspan_pda_write_room,
813 .write_bulk_callback = keyspan_pda_write_bulk_callback,
814 .read_int_callback = keyspan_pda_rx_interrupt,
815 .chars_in_buffer = keyspan_pda_chars_in_buffer,
816 .throttle = keyspan_pda_rx_throttle,
817 .unthrottle = keyspan_pda_rx_unthrottle,
818 .set_termios = keyspan_pda_set_termios,
819 .break_ctl = keyspan_pda_break_ctl,
820 .tiocmget = keyspan_pda_tiocmget,
821 .tiocmset = keyspan_pda_tiocmset,
822 .attach = keyspan_pda_startup,
823 .release = keyspan_pda_release,
826 static struct usb_serial_driver * const serial_drivers[] = {
829 &keyspan_pda_fake_device,
832 &xircom_pgs_fake_device,
837 module_usb_serial_driver(keyspan_pda_driver, serial_drivers);
839 MODULE_AUTHOR(DRIVER_AUTHOR);
840 MODULE_DESCRIPTION(DRIVER_DESC);
841 MODULE_LICENSE("GPL");
843 module_param(debug, bool, S_IRUGO | S_IWUSR);
844 MODULE_PARM_DESC(debug, "Debug enabled or not");