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