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