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