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