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