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