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