Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/usb/serial/keyspan.c

  1 /*
  2   Keyspan USB to Serial Converter driver
  3 
  4   (C) Copyright (C) 2000-2001   Hugh Blemings <hugh@blemings.org>
  5   (C) Copyright (C) 2002        Greg Kroah-Hartman <greg@kroah.com>
  6 
  7   This program is free software; you can redistribute it and/or modify
  8   it under the terms of the GNU General Public License as published by
  9   the Free Software Foundation; either version 2 of the License, or
 10   (at your option) any later version.
 11 
 12   See http://blemings.org/hugh/keyspan.html for more information.
 13 
 14   Code in this driver inspired by and in a number of places taken
 15   from Brian Warner's original Keyspan-PDA driver.
 16 
 17   This driver has been put together with the support of Innosys, Inc.
 18   and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
 19   Thanks Guys :)
 20 
 21   Thanks to Paulus for miscellaneous tidy ups, some largish chunks
 22   of much nicer and/or completely new code and (perhaps most uniquely)
 23   having the patience to sit down and explain why and where he'd changed
 24   stuff.
 25 
 26   Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
 27   staff in their work on open source projects.
 28 */
 29 
 30 
 31 #include <linux/kernel.h>
 32 #include <linux/jiffies.h>
 33 #include <linux/errno.h>
 34 #include <linux/slab.h>
 35 #include <linux/tty.h>
 36 #include <linux/tty_driver.h>
 37 #include <linux/tty_flip.h>
 38 #include <linux/module.h>
 39 #include <linux/spinlock.h>
 40 #include <linux/uaccess.h>
 41 #include <linux/usb.h>
 42 #include <linux/usb/serial.h>
 43 #include <linux/usb/ezusb.h>
 44 #include "keyspan.h"
 45 
 46 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
 47 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
 48 
 49 #define INSTAT_BUFLEN   32
 50 #define GLOCONT_BUFLEN  64
 51 #define INDAT49W_BUFLEN 512
 52 #define IN_BUFLEN       64
 53 #define OUT_BUFLEN      64
 54 #define INACK_BUFLEN    1
 55 #define OUTCONT_BUFLEN  64
 56 
 57         /* Per device and per port private data */
 58 struct keyspan_serial_private {
 59         const struct keyspan_device_details     *device_details;
 60 
 61         struct urb      *instat_urb;
 62         char            *instat_buf;
 63 
 64         /* added to support 49wg, where data from all 4 ports comes in
 65            on 1 EP and high-speed supported */
 66         struct urb      *indat_urb;
 67         char            *indat_buf;
 68 
 69         /* XXX this one probably will need a lock */
 70         struct urb      *glocont_urb;
 71         char            *glocont_buf;
 72         char            *ctrl_buf;      /* for EP0 control message */
 73 };
 74 
 75 struct keyspan_port_private {
 76         /* Keep track of which input & output endpoints to use */
 77         int             in_flip;
 78         int             out_flip;
 79 
 80         /* Keep duplicate of device details in each port
 81            structure as well - simplifies some of the
 82            callback functions etc. */
 83         const struct keyspan_device_details     *device_details;
 84 
 85         /* Input endpoints and buffer for this port */
 86         struct urb      *in_urbs[2];
 87         char            *in_buffer[2];
 88         /* Output endpoints and buffer for this port */
 89         struct urb      *out_urbs[2];
 90         char            *out_buffer[2];
 91 
 92         /* Input ack endpoint */
 93         struct urb      *inack_urb;
 94         char            *inack_buffer;
 95 
 96         /* Output control endpoint */
 97         struct urb      *outcont_urb;
 98         char            *outcont_buffer;
 99 
100         /* Settings for the port */
101         int             baud;
102         int             old_baud;
103         unsigned int    cflag;
104         unsigned int    old_cflag;
105         enum            {flow_none, flow_cts, flow_xon} flow_control;
106         int             rts_state;      /* Handshaking pins (outputs) */
107         int             dtr_state;
108         int             cts_state;      /* Handshaking pins (inputs) */
109         int             dsr_state;
110         int             dcd_state;
111         int             ri_state;
112         int             break_on;
113 
114         unsigned long   tx_start_time[2];
115         int             resend_cont;    /* need to resend control packet */
116 };
117 
118 /* Include Keyspan message headers.  All current Keyspan Adapters
119    make use of one of five message formats which are referred
120    to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
121    within this driver. */
122 #include "keyspan_usa26msg.h"
123 #include "keyspan_usa28msg.h"
124 #include "keyspan_usa49msg.h"
125 #include "keyspan_usa90msg.h"
126 #include "keyspan_usa67msg.h"
127 
128 
129 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
130 
131 static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
132 {
133         struct usb_serial_port *port = tty->driver_data;
134         struct keyspan_port_private     *p_priv;
135 
136         p_priv = usb_get_serial_port_data(port);
137 
138         if (break_state == -1)
139                 p_priv->break_on = 1;
140         else
141                 p_priv->break_on = 0;
142 
143         keyspan_send_setup(port, 0);
144 }
145 
146 
147 static void keyspan_set_termios(struct tty_struct *tty,
148                 struct usb_serial_port *port, struct ktermios *old_termios)
149 {
150         int                             baud_rate, device_port;
151         struct keyspan_port_private     *p_priv;
152         const struct keyspan_device_details     *d_details;
153         unsigned int                    cflag;
154 
155         p_priv = usb_get_serial_port_data(port);
156         d_details = p_priv->device_details;
157         cflag = tty->termios.c_cflag;
158         device_port = port->port_number;
159 
160         /* Baud rate calculation takes baud rate as an integer
161            so other rates can be generated if desired. */
162         baud_rate = tty_get_baud_rate(tty);
163         /* If no match or invalid, don't change */
164         if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
165                                 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
166                 /* FIXME - more to do here to ensure rate changes cleanly */
167                 /* FIXME - calculate exact rate from divisor ? */
168                 p_priv->baud = baud_rate;
169         } else
170                 baud_rate = tty_termios_baud_rate(old_termios);
171 
172         tty_encode_baud_rate(tty, baud_rate, baud_rate);
173         /* set CTS/RTS handshake etc. */
174         p_priv->cflag = cflag;
175         p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
176 
177         /* Mark/Space not supported */
178         tty->termios.c_cflag &= ~CMSPAR;
179 
180         keyspan_send_setup(port, 0);
181 }
182 
183 static int keyspan_tiocmget(struct tty_struct *tty)
184 {
185         struct usb_serial_port *port = tty->driver_data;
186         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
187         unsigned int                    value;
188 
189         value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
190                 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
191                 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
192                 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
193                 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
194                 ((p_priv->ri_state) ? TIOCM_RNG : 0);
195 
196         return value;
197 }
198 
199 static int keyspan_tiocmset(struct tty_struct *tty,
200                             unsigned int set, unsigned int clear)
201 {
202         struct usb_serial_port *port = tty->driver_data;
203         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
204 
205         if (set & TIOCM_RTS)
206                 p_priv->rts_state = 1;
207         if (set & TIOCM_DTR)
208                 p_priv->dtr_state = 1;
209         if (clear & TIOCM_RTS)
210                 p_priv->rts_state = 0;
211         if (clear & TIOCM_DTR)
212                 p_priv->dtr_state = 0;
213         keyspan_send_setup(port, 0);
214         return 0;
215 }
216 
217 /* Write function is similar for the four protocols used
218    with only a minor change for usa90 (usa19hs) required */
219 static int keyspan_write(struct tty_struct *tty,
220         struct usb_serial_port *port, const unsigned char *buf, int count)
221 {
222         struct keyspan_port_private     *p_priv;
223         const struct keyspan_device_details     *d_details;
224         int                             flip;
225         int                             left, todo;
226         struct urb                      *this_urb;
227         int                             err, maxDataLen, dataOffset;
228 
229         p_priv = usb_get_serial_port_data(port);
230         d_details = p_priv->device_details;
231 
232         if (d_details->msg_format == msg_usa90) {
233                 maxDataLen = 64;
234                 dataOffset = 0;
235         } else {
236                 maxDataLen = 63;
237                 dataOffset = 1;
238         }
239 
240         dev_dbg(&port->dev, "%s - %d chars, flip=%d\n", __func__, count,
241                 p_priv->out_flip);
242 
243         for (left = count; left > 0; left -= todo) {
244                 todo = left;
245                 if (todo > maxDataLen)
246                         todo = maxDataLen;
247 
248                 flip = p_priv->out_flip;
249 
250                 /* Check we have a valid urb/endpoint before we use it... */
251                 this_urb = p_priv->out_urbs[flip];
252                 if (this_urb == NULL) {
253                         /* no bulk out, so return 0 bytes written */
254                         dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
255                         return count;
256                 }
257 
258                 dev_dbg(&port->dev, "%s - endpoint %d flip %d\n",
259                         __func__, usb_pipeendpoint(this_urb->pipe), flip);
260 
261                 if (this_urb->status == -EINPROGRESS) {
262                         if (time_before(jiffies,
263                                         p_priv->tx_start_time[flip] + 10 * HZ))
264                                 break;
265                         usb_unlink_urb(this_urb);
266                         break;
267                 }
268 
269                 /* First byte in buffer is "last flag" (except for usa19hx)
270                    - unused so for now so set to zero */
271                 ((char *)this_urb->transfer_buffer)[0] = 0;
272 
273                 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
274                 buf += todo;
275 
276                 /* send the data out the bulk port */
277                 this_urb->transfer_buffer_length = todo + dataOffset;
278 
279                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
280                 if (err != 0)
281                         dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
282                 p_priv->tx_start_time[flip] = jiffies;
283 
284                 /* Flip for next time if usa26 or usa28 interface
285                    (not used on usa49) */
286                 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
287         }
288 
289         return count - left;
290 }
291 
292 static void     usa26_indat_callback(struct urb *urb)
293 {
294         int                     i, err;
295         int                     endpoint;
296         struct usb_serial_port  *port;
297         unsigned char           *data = urb->transfer_buffer;
298         int status = urb->status;
299 
300         endpoint = usb_pipeendpoint(urb->pipe);
301 
302         if (status) {
303                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
304                         __func__, status, endpoint);
305                 return;
306         }
307 
308         port =  urb->context;
309         if (urb->actual_length) {
310                 /* 0x80 bit is error flag */
311                 if ((data[0] & 0x80) == 0) {
312                         /* no errors on individual bytes, only
313                            possible overrun err */
314                         if (data[0] & RXERROR_OVERRUN)
315                                 err = TTY_OVERRUN;
316                         else
317                                 err = 0;
318                         for (i = 1; i < urb->actual_length ; ++i)
319                                 tty_insert_flip_char(&port->port, data[i], err);
320                 } else {
321                         /* some bytes had errors, every byte has status */
322                         dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
323                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
324                                 int stat = data[i], flag = 0;
325                                 if (stat & RXERROR_OVERRUN)
326                                         flag |= TTY_OVERRUN;
327                                 if (stat & RXERROR_FRAMING)
328                                         flag |= TTY_FRAME;
329                                 if (stat & RXERROR_PARITY)
330                                         flag |= TTY_PARITY;
331                                 /* XXX should handle break (0x10) */
332                                 tty_insert_flip_char(&port->port, data[i+1],
333                                                 flag);
334                         }
335                 }
336                 tty_flip_buffer_push(&port->port);
337         }
338 
339         /* Resubmit urb so we continue receiving */
340         err = usb_submit_urb(urb, GFP_ATOMIC);
341         if (err != 0)
342                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
343 }
344 
345 /* Outdat handling is common for all devices */
346 static void     usa2x_outdat_callback(struct urb *urb)
347 {
348         struct usb_serial_port *port;
349         struct keyspan_port_private *p_priv;
350 
351         port =  urb->context;
352         p_priv = usb_get_serial_port_data(port);
353         dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
354 
355         usb_serial_port_softint(port);
356 }
357 
358 static void     usa26_inack_callback(struct urb *urb)
359 {
360 }
361 
362 static void     usa26_outcont_callback(struct urb *urb)
363 {
364         struct usb_serial_port *port;
365         struct keyspan_port_private *p_priv;
366 
367         port =  urb->context;
368         p_priv = usb_get_serial_port_data(port);
369 
370         if (p_priv->resend_cont) {
371                 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
372                 keyspan_usa26_send_setup(port->serial, port,
373                                                 p_priv->resend_cont - 1);
374         }
375 }
376 
377 static void     usa26_instat_callback(struct urb *urb)
378 {
379         unsigned char                           *data = urb->transfer_buffer;
380         struct keyspan_usa26_portStatusMessage  *msg;
381         struct usb_serial                       *serial;
382         struct usb_serial_port                  *port;
383         struct keyspan_port_private             *p_priv;
384         int old_dcd_state, err;
385         int status = urb->status;
386 
387         serial =  urb->context;
388 
389         if (status) {
390                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
391                 return;
392         }
393         if (urb->actual_length != 9) {
394                 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
395                 goto exit;
396         }
397 
398         msg = (struct keyspan_usa26_portStatusMessage *)data;
399 
400         /* Check port number from message and retrieve private data */
401         if (msg->port >= serial->num_ports) {
402                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
403                 goto exit;
404         }
405         port = serial->port[msg->port];
406         p_priv = usb_get_serial_port_data(port);
407 
408         /* Update handshaking pin state information */
409         old_dcd_state = p_priv->dcd_state;
410         p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
411         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
412         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
413         p_priv->ri_state = ((msg->ri) ? 1 : 0);
414 
415         if (old_dcd_state != p_priv->dcd_state)
416                 tty_port_tty_hangup(&port->port, true);
417 
418         /* Resubmit urb so we continue receiving */
419         err = usb_submit_urb(urb, GFP_ATOMIC);
420         if (err != 0)
421                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
422 exit: ;
423 }
424 
425 static void     usa26_glocont_callback(struct urb *urb)
426 {
427 }
428 
429 
430 static void usa28_indat_callback(struct urb *urb)
431 {
432         int                     err;
433         struct usb_serial_port  *port;
434         unsigned char           *data;
435         struct keyspan_port_private             *p_priv;
436         int status = urb->status;
437 
438         port =  urb->context;
439         p_priv = usb_get_serial_port_data(port);
440         data = urb->transfer_buffer;
441 
442         if (urb != p_priv->in_urbs[p_priv->in_flip])
443                 return;
444 
445         do {
446                 if (status) {
447                         dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
448                                 __func__, status, usb_pipeendpoint(urb->pipe));
449                         return;
450                 }
451 
452                 port =  urb->context;
453                 p_priv = usb_get_serial_port_data(port);
454                 data = urb->transfer_buffer;
455 
456                 if (urb->actual_length) {
457                         tty_insert_flip_string(&port->port, data,
458                                         urb->actual_length);
459                         tty_flip_buffer_push(&port->port);
460                 }
461 
462                 /* Resubmit urb so we continue receiving */
463                 err = usb_submit_urb(urb, GFP_ATOMIC);
464                 if (err != 0)
465                         dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
466                                                         __func__, err);
467                 p_priv->in_flip ^= 1;
468 
469                 urb = p_priv->in_urbs[p_priv->in_flip];
470         } while (urb->status != -EINPROGRESS);
471 }
472 
473 static void     usa28_inack_callback(struct urb *urb)
474 {
475 }
476 
477 static void     usa28_outcont_callback(struct urb *urb)
478 {
479         struct usb_serial_port *port;
480         struct keyspan_port_private *p_priv;
481 
482         port =  urb->context;
483         p_priv = usb_get_serial_port_data(port);
484 
485         if (p_priv->resend_cont) {
486                 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
487                 keyspan_usa28_send_setup(port->serial, port,
488                                                 p_priv->resend_cont - 1);
489         }
490 }
491 
492 static void     usa28_instat_callback(struct urb *urb)
493 {
494         int                                     err;
495         unsigned char                           *data = urb->transfer_buffer;
496         struct keyspan_usa28_portStatusMessage  *msg;
497         struct usb_serial                       *serial;
498         struct usb_serial_port                  *port;
499         struct keyspan_port_private             *p_priv;
500         int old_dcd_state;
501         int status = urb->status;
502 
503         serial =  urb->context;
504 
505         if (status) {
506                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
507                 return;
508         }
509 
510         if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
511                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
512                 goto exit;
513         }
514 
515         msg = (struct keyspan_usa28_portStatusMessage *)data;
516 
517         /* Check port number from message and retrieve private data */
518         if (msg->port >= serial->num_ports) {
519                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
520                 goto exit;
521         }
522         port = serial->port[msg->port];
523         p_priv = usb_get_serial_port_data(port);
524 
525         /* Update handshaking pin state information */
526         old_dcd_state = p_priv->dcd_state;
527         p_priv->cts_state = ((msg->cts) ? 1 : 0);
528         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
529         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
530         p_priv->ri_state = ((msg->ri) ? 1 : 0);
531 
532         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
533                 tty_port_tty_hangup(&port->port, true);
534 
535                 /* Resubmit urb so we continue receiving */
536         err = usb_submit_urb(urb, GFP_ATOMIC);
537         if (err != 0)
538                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
539 exit: ;
540 }
541 
542 static void     usa28_glocont_callback(struct urb *urb)
543 {
544 }
545 
546 
547 static void     usa49_glocont_callback(struct urb *urb)
548 {
549         struct usb_serial *serial;
550         struct usb_serial_port *port;
551         struct keyspan_port_private *p_priv;
552         int i;
553 
554         serial =  urb->context;
555         for (i = 0; i < serial->num_ports; ++i) {
556                 port = serial->port[i];
557                 p_priv = usb_get_serial_port_data(port);
558 
559                 if (p_priv->resend_cont) {
560                         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
561                         keyspan_usa49_send_setup(serial, port,
562                                                 p_priv->resend_cont - 1);
563                         break;
564                 }
565         }
566 }
567 
568         /* This is actually called glostat in the Keyspan
569            doco */
570 static void     usa49_instat_callback(struct urb *urb)
571 {
572         int                                     err;
573         unsigned char                           *data = urb->transfer_buffer;
574         struct keyspan_usa49_portStatusMessage  *msg;
575         struct usb_serial                       *serial;
576         struct usb_serial_port                  *port;
577         struct keyspan_port_private             *p_priv;
578         int old_dcd_state;
579         int status = urb->status;
580 
581         serial =  urb->context;
582 
583         if (status) {
584                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
585                 return;
586         }
587 
588         if (urb->actual_length !=
589                         sizeof(struct keyspan_usa49_portStatusMessage)) {
590                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
591                 goto exit;
592         }
593 
594         msg = (struct keyspan_usa49_portStatusMessage *)data;
595 
596         /* Check port number from message and retrieve private data */
597         if (msg->portNumber >= serial->num_ports) {
598                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
599                         __func__, msg->portNumber);
600                 goto exit;
601         }
602         port = serial->port[msg->portNumber];
603         p_priv = usb_get_serial_port_data(port);
604 
605         /* Update handshaking pin state information */
606         old_dcd_state = p_priv->dcd_state;
607         p_priv->cts_state = ((msg->cts) ? 1 : 0);
608         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
609         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
610         p_priv->ri_state = ((msg->ri) ? 1 : 0);
611 
612         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
613                 tty_port_tty_hangup(&port->port, true);
614 
615         /* Resubmit urb so we continue receiving */
616         err = usb_submit_urb(urb, GFP_ATOMIC);
617         if (err != 0)
618                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
619 exit:   ;
620 }
621 
622 static void     usa49_inack_callback(struct urb *urb)
623 {
624 }
625 
626 static void     usa49_indat_callback(struct urb *urb)
627 {
628         int                     i, err;
629         int                     endpoint;
630         struct usb_serial_port  *port;
631         unsigned char           *data = urb->transfer_buffer;
632         int status = urb->status;
633 
634         endpoint = usb_pipeendpoint(urb->pipe);
635 
636         if (status) {
637                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
638                         __func__, status, endpoint);
639                 return;
640         }
641 
642         port =  urb->context;
643         if (urb->actual_length) {
644                 /* 0x80 bit is error flag */
645                 if ((data[0] & 0x80) == 0) {
646                         /* no error on any byte */
647                         tty_insert_flip_string(&port->port, data + 1,
648                                                 urb->actual_length - 1);
649                 } else {
650                         /* some bytes had errors, every byte has status */
651                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
652                                 int stat = data[i], flag = 0;
653                                 if (stat & RXERROR_OVERRUN)
654                                         flag |= TTY_OVERRUN;
655                                 if (stat & RXERROR_FRAMING)
656                                         flag |= TTY_FRAME;
657                                 if (stat & RXERROR_PARITY)
658                                         flag |= TTY_PARITY;
659                                 /* XXX should handle break (0x10) */
660                                 tty_insert_flip_char(&port->port, data[i+1],
661                                                 flag);
662                         }
663                 }
664                 tty_flip_buffer_push(&port->port);
665         }
666 
667         /* Resubmit urb so we continue receiving */
668         err = usb_submit_urb(urb, GFP_ATOMIC);
669         if (err != 0)
670                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
671 }
672 
673 static void usa49wg_indat_callback(struct urb *urb)
674 {
675         int                     i, len, x, err;
676         struct usb_serial       *serial;
677         struct usb_serial_port  *port;
678         unsigned char           *data = urb->transfer_buffer;
679         int status = urb->status;
680 
681         serial = urb->context;
682 
683         if (status) {
684                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
685                 return;
686         }
687 
688         /* inbound data is in the form P#, len, status, data */
689         i = 0;
690         len = 0;
691 
692         while (i < urb->actual_length) {
693 
694                 /* Check port number from message */
695                 if (data[i] >= serial->num_ports) {
696                         dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
697                                 __func__, data[i]);
698                         return;
699                 }
700                 port = serial->port[data[i++]];
701                 len = data[i++];
702 
703                 /* 0x80 bit is error flag */
704                 if ((data[i] & 0x80) == 0) {
705                         /* no error on any byte */
706                         i++;
707                         for (x = 1; x < len && i < urb->actual_length; ++x)
708                                 tty_insert_flip_char(&port->port,
709                                                 data[i++], 0);
710                 } else {
711                         /*
712                          * some bytes had errors, every byte has status
713                          */
714                         for (x = 0; x + 1 < len &&
715                                     i + 1 < urb->actual_length; x += 2) {
716                                 int stat = data[i], flag = 0;
717 
718                                 if (stat & RXERROR_OVERRUN)
719                                         flag |= TTY_OVERRUN;
720                                 if (stat & RXERROR_FRAMING)
721                                         flag |= TTY_FRAME;
722                                 if (stat & RXERROR_PARITY)
723                                         flag |= TTY_PARITY;
724                                 /* XXX should handle break (0x10) */
725                                 tty_insert_flip_char(&port->port, data[i+1],
726                                                      flag);
727                                 i += 2;
728                         }
729                 }
730                 tty_flip_buffer_push(&port->port);
731         }
732 
733         /* Resubmit urb so we continue receiving */
734         err = usb_submit_urb(urb, GFP_ATOMIC);
735         if (err != 0)
736                 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
737 }
738 
739 /* not used, usa-49 doesn't have per-port control endpoints */
740 static void usa49_outcont_callback(struct urb *urb)
741 {
742 }
743 
744 static void usa90_indat_callback(struct urb *urb)
745 {
746         int                     i, err;
747         int                     endpoint;
748         struct usb_serial_port  *port;
749         struct keyspan_port_private             *p_priv;
750         unsigned char           *data = urb->transfer_buffer;
751         int status = urb->status;
752 
753         endpoint = usb_pipeendpoint(urb->pipe);
754 
755         if (status) {
756                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
757                     __func__, status, endpoint);
758                 return;
759         }
760 
761         port =  urb->context;
762         p_priv = usb_get_serial_port_data(port);
763 
764         if (urb->actual_length) {
765                 /* if current mode is DMA, looks like usa28 format
766                    otherwise looks like usa26 data format */
767 
768                 if (p_priv->baud > 57600)
769                         tty_insert_flip_string(&port->port, data,
770                                         urb->actual_length);
771                 else {
772                         /* 0x80 bit is error flag */
773                         if ((data[0] & 0x80) == 0) {
774                                 /* no errors on individual bytes, only
775                                    possible overrun err*/
776                                 if (data[0] & RXERROR_OVERRUN)
777                                         err = TTY_OVERRUN;
778                                 else
779                                         err = 0;
780                                 for (i = 1; i < urb->actual_length ; ++i)
781                                         tty_insert_flip_char(&port->port,
782                                                         data[i], err);
783                         }  else {
784                         /* some bytes had errors, every byte has status */
785                                 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
786                                 for (i = 0; i + 1 < urb->actual_length; i += 2) {
787                                         int stat = data[i], flag = 0;
788                                         if (stat & RXERROR_OVERRUN)
789                                                 flag |= TTY_OVERRUN;
790                                         if (stat & RXERROR_FRAMING)
791                                                 flag |= TTY_FRAME;
792                                         if (stat & RXERROR_PARITY)
793                                                 flag |= TTY_PARITY;
794                                         /* XXX should handle break (0x10) */
795                                         tty_insert_flip_char(&port->port,
796                                                         data[i+1], flag);
797                                 }
798                         }
799                 }
800                 tty_flip_buffer_push(&port->port);
801         }
802 
803         /* Resubmit urb so we continue receiving */
804         err = usb_submit_urb(urb, GFP_ATOMIC);
805         if (err != 0)
806                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
807 }
808 
809 
810 static void     usa90_instat_callback(struct urb *urb)
811 {
812         unsigned char                           *data = urb->transfer_buffer;
813         struct keyspan_usa90_portStatusMessage  *msg;
814         struct usb_serial                       *serial;
815         struct usb_serial_port                  *port;
816         struct keyspan_port_private             *p_priv;
817         int old_dcd_state, err;
818         int status = urb->status;
819 
820         serial =  urb->context;
821 
822         if (status) {
823                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
824                 return;
825         }
826         if (urb->actual_length < 14) {
827                 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
828                 goto exit;
829         }
830 
831         msg = (struct keyspan_usa90_portStatusMessage *)data;
832 
833         /* Now do something useful with the data */
834 
835         port = serial->port[0];
836         p_priv = usb_get_serial_port_data(port);
837 
838         /* Update handshaking pin state information */
839         old_dcd_state = p_priv->dcd_state;
840         p_priv->cts_state = ((msg->cts) ? 1 : 0);
841         p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
842         p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
843         p_priv->ri_state = ((msg->ri) ? 1 : 0);
844 
845         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
846                 tty_port_tty_hangup(&port->port, true);
847 
848         /* Resubmit urb so we continue receiving */
849         err = usb_submit_urb(urb, GFP_ATOMIC);
850         if (err != 0)
851                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
852 exit:
853         ;
854 }
855 
856 static void     usa90_outcont_callback(struct urb *urb)
857 {
858         struct usb_serial_port *port;
859         struct keyspan_port_private *p_priv;
860 
861         port =  urb->context;
862         p_priv = usb_get_serial_port_data(port);
863 
864         if (p_priv->resend_cont) {
865                 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
866                 keyspan_usa90_send_setup(port->serial, port,
867                                                 p_priv->resend_cont - 1);
868         }
869 }
870 
871 /* Status messages from the 28xg */
872 static void     usa67_instat_callback(struct urb *urb)
873 {
874         int                                     err;
875         unsigned char                           *data = urb->transfer_buffer;
876         struct keyspan_usa67_portStatusMessage  *msg;
877         struct usb_serial                       *serial;
878         struct usb_serial_port                  *port;
879         struct keyspan_port_private             *p_priv;
880         int old_dcd_state;
881         int status = urb->status;
882 
883         serial = urb->context;
884 
885         if (status) {
886                 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
887                 return;
888         }
889 
890         if (urb->actual_length !=
891                         sizeof(struct keyspan_usa67_portStatusMessage)) {
892                 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
893                 return;
894         }
895 
896 
897         /* Now do something useful with the data */
898         msg = (struct keyspan_usa67_portStatusMessage *)data;
899 
900         /* Check port number from message and retrieve private data */
901         if (msg->port >= serial->num_ports) {
902                 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
903                 return;
904         }
905 
906         port = serial->port[msg->port];
907         p_priv = usb_get_serial_port_data(port);
908 
909         /* Update handshaking pin state information */
910         old_dcd_state = p_priv->dcd_state;
911         p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
912         p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
913 
914         if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
915                 tty_port_tty_hangup(&port->port, true);
916 
917         /* Resubmit urb so we continue receiving */
918         err = usb_submit_urb(urb, GFP_ATOMIC);
919         if (err != 0)
920                 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
921 }
922 
923 static void usa67_glocont_callback(struct urb *urb)
924 {
925         struct usb_serial *serial;
926         struct usb_serial_port *port;
927         struct keyspan_port_private *p_priv;
928         int i;
929 
930         serial = urb->context;
931         for (i = 0; i < serial->num_ports; ++i) {
932                 port = serial->port[i];
933                 p_priv = usb_get_serial_port_data(port);
934 
935                 if (p_priv->resend_cont) {
936                         dev_dbg(&port->dev, "%s - sending setup\n", __func__);
937                         keyspan_usa67_send_setup(serial, port,
938                                                 p_priv->resend_cont - 1);
939                         break;
940                 }
941         }
942 }
943 
944 static int keyspan_write_room(struct tty_struct *tty)
945 {
946         struct usb_serial_port *port = tty->driver_data;
947         struct keyspan_port_private     *p_priv;
948         const struct keyspan_device_details     *d_details;
949         int                             flip;
950         int                             data_len;
951         struct urb                      *this_urb;
952 
953         p_priv = usb_get_serial_port_data(port);
954         d_details = p_priv->device_details;
955 
956         /* FIXME: locking */
957         if (d_details->msg_format == msg_usa90)
958                 data_len = 64;
959         else
960                 data_len = 63;
961 
962         flip = p_priv->out_flip;
963 
964         /* Check both endpoints to see if any are available. */
965         this_urb = p_priv->out_urbs[flip];
966         if (this_urb != NULL) {
967                 if (this_urb->status != -EINPROGRESS)
968                         return data_len;
969                 flip = (flip + 1) & d_details->outdat_endp_flip;
970                 this_urb = p_priv->out_urbs[flip];
971                 if (this_urb != NULL) {
972                         if (this_urb->status != -EINPROGRESS)
973                                 return data_len;
974                 }
975         }
976         return 0;
977 }
978 
979 
980 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
981 {
982         struct keyspan_port_private     *p_priv;
983         const struct keyspan_device_details     *d_details;
984         int                             i, err;
985         int                             baud_rate, device_port;
986         struct urb                      *urb;
987         unsigned int                    cflag = 0;
988 
989         p_priv = usb_get_serial_port_data(port);
990         d_details = p_priv->device_details;
991 
992         /* Set some sane defaults */
993         p_priv->rts_state = 1;
994         p_priv->dtr_state = 1;
995         p_priv->baud = 9600;
996 
997         /* force baud and lcr to be set on open */
998         p_priv->old_baud = 0;
999         p_priv->old_cflag = 0;
1000 
1001         p_priv->out_flip = 0;
1002         p_priv->in_flip = 0;
1003 
1004         /* Reset low level data toggle and start reading from endpoints */
1005         for (i = 0; i < 2; i++) {
1006                 urb = p_priv->in_urbs[i];
1007                 if (urb == NULL)
1008                         continue;
1009 
1010                 /* make sure endpoint data toggle is synchronized
1011                    with the device */
1012                 usb_clear_halt(urb->dev, urb->pipe);
1013                 err = usb_submit_urb(urb, GFP_KERNEL);
1014                 if (err != 0)
1015                         dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1016         }
1017 
1018         /* Reset low level data toggle on out endpoints */
1019         for (i = 0; i < 2; i++) {
1020                 urb = p_priv->out_urbs[i];
1021                 if (urb == NULL)
1022                         continue;
1023                 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1024                                                 usb_pipeout(urb->pipe), 0); */
1025         }
1026 
1027         /* get the terminal config for the setup message now so we don't
1028          * need to send 2 of them */
1029 
1030         device_port = port->port_number;
1031         if (tty) {
1032                 cflag = tty->termios.c_cflag;
1033                 /* Baud rate calculation takes baud rate as an integer
1034                    so other rates can be generated if desired. */
1035                 baud_rate = tty_get_baud_rate(tty);
1036                 /* If no match or invalid, leave as default */
1037                 if (baud_rate >= 0
1038                     && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1039                                         NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1040                         p_priv->baud = baud_rate;
1041                 }
1042         }
1043         /* set CTS/RTS handshake etc. */
1044         p_priv->cflag = cflag;
1045         p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1046 
1047         keyspan_send_setup(port, 1);
1048         /* mdelay(100); */
1049         /* keyspan_set_termios(port, NULL); */
1050 
1051         return 0;
1052 }
1053 
1054 static inline void stop_urb(struct urb *urb)
1055 {
1056         if (urb && urb->status == -EINPROGRESS)
1057                 usb_kill_urb(urb);
1058 }
1059 
1060 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1061 {
1062         struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1063 
1064         p_priv->rts_state = on;
1065         p_priv->dtr_state = on;
1066         keyspan_send_setup(port, 0);
1067 }
1068 
1069 static void keyspan_close(struct usb_serial_port *port)
1070 {
1071         int                     i;
1072         struct keyspan_port_private     *p_priv;
1073 
1074         p_priv = usb_get_serial_port_data(port);
1075 
1076         p_priv->rts_state = 0;
1077         p_priv->dtr_state = 0;
1078 
1079         keyspan_send_setup(port, 2);
1080         /* pilot-xfer seems to work best with this delay */
1081         mdelay(100);
1082 
1083         p_priv->out_flip = 0;
1084         p_priv->in_flip = 0;
1085 
1086         stop_urb(p_priv->inack_urb);
1087         for (i = 0; i < 2; i++) {
1088                 stop_urb(p_priv->in_urbs[i]);
1089                 stop_urb(p_priv->out_urbs[i]);
1090         }
1091 }
1092 
1093 /* download the firmware to a pre-renumeration device */
1094 static int keyspan_fake_startup(struct usb_serial *serial)
1095 {
1096         char    *fw_name;
1097 
1098         dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1099                 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1100                 le16_to_cpu(serial->dev->descriptor.idProduct));
1101 
1102         if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1103                                                                 != 0x8000) {
1104                 dev_dbg(&serial->dev->dev, "Firmware already loaded.  Quitting.\n");
1105                 return 1;
1106         }
1107 
1108                 /* Select firmware image on the basis of idProduct */
1109         switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1110         case keyspan_usa28_pre_product_id:
1111                 fw_name = "keyspan/usa28.fw";
1112                 break;
1113 
1114         case keyspan_usa28x_pre_product_id:
1115                 fw_name = "keyspan/usa28x.fw";
1116                 break;
1117 
1118         case keyspan_usa28xa_pre_product_id:
1119                 fw_name = "keyspan/usa28xa.fw";
1120                 break;
1121 
1122         case keyspan_usa28xb_pre_product_id:
1123                 fw_name = "keyspan/usa28xb.fw";
1124                 break;
1125 
1126         case keyspan_usa19_pre_product_id:
1127                 fw_name = "keyspan/usa19.fw";
1128                 break;
1129 
1130         case keyspan_usa19qi_pre_product_id:
1131                 fw_name = "keyspan/usa19qi.fw";
1132                 break;
1133 
1134         case keyspan_mpr_pre_product_id:
1135                 fw_name = "keyspan/mpr.fw";
1136                 break;
1137 
1138         case keyspan_usa19qw_pre_product_id:
1139                 fw_name = "keyspan/usa19qw.fw";
1140                 break;
1141 
1142         case keyspan_usa18x_pre_product_id:
1143                 fw_name = "keyspan/usa18x.fw";
1144                 break;
1145 
1146         case keyspan_usa19w_pre_product_id:
1147                 fw_name = "keyspan/usa19w.fw";
1148                 break;
1149 
1150         case keyspan_usa49w_pre_product_id:
1151                 fw_name = "keyspan/usa49w.fw";
1152                 break;
1153 
1154         case keyspan_usa49wlc_pre_product_id:
1155                 fw_name = "keyspan/usa49wlc.fw";
1156                 break;
1157 
1158         default:
1159                 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1160                         le16_to_cpu(serial->dev->descriptor.idProduct));
1161                 return 1;
1162         }
1163 
1164         dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1165 
1166         if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1167                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1168                         fw_name);
1169                 return -ENOENT;
1170         }
1171 
1172         /* after downloading firmware Renumeration will occur in a
1173           moment and the new device will bind to the real driver */
1174 
1175         /* we don't want this device to have a driver assigned to it. */
1176         return 1;
1177 }
1178 
1179 /* Helper functions used by keyspan_setup_urbs */
1180 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1181                                                      int endpoint)
1182 {
1183         struct usb_host_interface *iface_desc;
1184         struct usb_endpoint_descriptor *ep;
1185         int i;
1186 
1187         iface_desc = serial->interface->cur_altsetting;
1188         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1189                 ep = &iface_desc->endpoint[i].desc;
1190                 if (ep->bEndpointAddress == endpoint)
1191                         return ep;
1192         }
1193         dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1194                  "endpoint %x\n", endpoint);
1195         return NULL;
1196 }
1197 
1198 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1199                                       int dir, void *ctx, char *buf, int len,
1200                                       void (*callback)(struct urb *))
1201 {
1202         struct urb *urb;
1203         struct usb_endpoint_descriptor const *ep_desc;
1204         char const *ep_type_name;
1205 
1206         if (endpoint == -1)
1207                 return NULL;            /* endpoint not needed */
1208 
1209         dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
1210         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
1211         if (!urb)
1212                 return NULL;
1213 
1214         if (endpoint == 0) {
1215                 /* control EP filled in when used */
1216                 return urb;
1217         }
1218 
1219         ep_desc = find_ep(serial, endpoint);
1220         if (!ep_desc) {
1221                 /* leak the urb, something's wrong and the callers don't care */
1222                 return urb;
1223         }
1224         if (usb_endpoint_xfer_int(ep_desc)) {
1225                 ep_type_name = "INT";
1226                 usb_fill_int_urb(urb, serial->dev,
1227                                  usb_sndintpipe(serial->dev, endpoint) | dir,
1228                                  buf, len, callback, ctx,
1229                                  ep_desc->bInterval);
1230         } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1231                 ep_type_name = "BULK";
1232                 usb_fill_bulk_urb(urb, serial->dev,
1233                                   usb_sndbulkpipe(serial->dev, endpoint) | dir,
1234                                   buf, len, callback, ctx);
1235         } else {
1236                 dev_warn(&serial->interface->dev,
1237                          "unsupported endpoint type %x\n",
1238                          usb_endpoint_type(ep_desc));
1239                 usb_free_urb(urb);
1240                 return NULL;
1241         }
1242 
1243         dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1244             __func__, urb, ep_type_name, endpoint);
1245         return urb;
1246 }
1247 
1248 static struct callbacks {
1249         void    (*instat_callback)(struct urb *);
1250         void    (*glocont_callback)(struct urb *);
1251         void    (*indat_callback)(struct urb *);
1252         void    (*outdat_callback)(struct urb *);
1253         void    (*inack_callback)(struct urb *);
1254         void    (*outcont_callback)(struct urb *);
1255 } keyspan_callbacks[] = {
1256         {
1257                 /* msg_usa26 callbacks */
1258                 .instat_callback =      usa26_instat_callback,
1259                 .glocont_callback =     usa26_glocont_callback,
1260                 .indat_callback =       usa26_indat_callback,
1261                 .outdat_callback =      usa2x_outdat_callback,
1262                 .inack_callback =       usa26_inack_callback,
1263                 .outcont_callback =     usa26_outcont_callback,
1264         }, {
1265                 /* msg_usa28 callbacks */
1266                 .instat_callback =      usa28_instat_callback,
1267                 .glocont_callback =     usa28_glocont_callback,
1268                 .indat_callback =       usa28_indat_callback,
1269                 .outdat_callback =      usa2x_outdat_callback,
1270                 .inack_callback =       usa28_inack_callback,
1271                 .outcont_callback =     usa28_outcont_callback,
1272         }, {
1273                 /* msg_usa49 callbacks */
1274                 .instat_callback =      usa49_instat_callback,
1275                 .glocont_callback =     usa49_glocont_callback,
1276                 .indat_callback =       usa49_indat_callback,
1277                 .outdat_callback =      usa2x_outdat_callback,
1278                 .inack_callback =       usa49_inack_callback,
1279                 .outcont_callback =     usa49_outcont_callback,
1280         }, {
1281                 /* msg_usa90 callbacks */
1282                 .instat_callback =      usa90_instat_callback,
1283                 .glocont_callback =     usa28_glocont_callback,
1284                 .indat_callback =       usa90_indat_callback,
1285                 .outdat_callback =      usa2x_outdat_callback,
1286                 .inack_callback =       usa28_inack_callback,
1287                 .outcont_callback =     usa90_outcont_callback,
1288         }, {
1289                 /* msg_usa67 callbacks */
1290                 .instat_callback =      usa67_instat_callback,
1291                 .glocont_callback =     usa67_glocont_callback,
1292                 .indat_callback =       usa26_indat_callback,
1293                 .outdat_callback =      usa2x_outdat_callback,
1294                 .inack_callback =       usa26_inack_callback,
1295                 .outcont_callback =     usa26_outcont_callback,
1296         }
1297 };
1298 
1299         /* Generic setup urbs function that uses
1300            data in device_details */
1301 static void keyspan_setup_urbs(struct usb_serial *serial)
1302 {
1303         struct keyspan_serial_private   *s_priv;
1304         const struct keyspan_device_details     *d_details;
1305         struct callbacks                *cback;
1306 
1307         s_priv = usb_get_serial_data(serial);
1308         d_details = s_priv->device_details;
1309 
1310         /* Setup values for the various callback routines */
1311         cback = &keyspan_callbacks[d_details->msg_format];
1312 
1313         /* Allocate and set up urbs for each one that is in use,
1314            starting with instat endpoints */
1315         s_priv->instat_urb = keyspan_setup_urb
1316                 (serial, d_details->instat_endpoint, USB_DIR_IN,
1317                  serial, s_priv->instat_buf, INSTAT_BUFLEN,
1318                  cback->instat_callback);
1319 
1320         s_priv->indat_urb = keyspan_setup_urb
1321                 (serial, d_details->indat_endpoint, USB_DIR_IN,
1322                  serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1323                  usa49wg_indat_callback);
1324 
1325         s_priv->glocont_urb = keyspan_setup_urb
1326                 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1327                  serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1328                  cback->glocont_callback);
1329 }
1330 
1331 /* usa19 function doesn't require prescaler */
1332 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1333                                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
1334                                    u8 *rate_low, u8 *prescaler, int portnum)
1335 {
1336         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1337                 div,    /* divisor */
1338                 cnt;    /* inverse of divisor (programmed into 8051) */
1339 
1340         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1341 
1342         /* prevent divide by zero...  */
1343         b16 = baud_rate * 16L;
1344         if (b16 == 0)
1345                 return KEYSPAN_INVALID_BAUD_RATE;
1346         /* Any "standard" rate over 57k6 is marginal on the USA-19
1347            as we run out of divisor resolution. */
1348         if (baud_rate > 57600)
1349                 return KEYSPAN_INVALID_BAUD_RATE;
1350 
1351         /* calculate the divisor and the counter (its inverse) */
1352         div = baudclk / b16;
1353         if (div == 0)
1354                 return KEYSPAN_INVALID_BAUD_RATE;
1355         else
1356                 cnt = 0 - div;
1357 
1358         if (div > 0xffff)
1359                 return KEYSPAN_INVALID_BAUD_RATE;
1360 
1361         /* return the counter values if non-null */
1362         if (rate_low)
1363                 *rate_low = (u8) (cnt & 0xff);
1364         if (rate_hi)
1365                 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1366         if (rate_low && rate_hi)
1367                 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1368                                 __func__, baud_rate, *rate_hi, *rate_low);
1369         return KEYSPAN_BAUD_RATE_OK;
1370 }
1371 
1372 /* usa19hs function doesn't require prescaler */
1373 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1374                                      u32 baud_rate, u32 baudclk, u8 *rate_hi,
1375                                      u8 *rate_low, u8 *prescaler, int portnum)
1376 {
1377         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1378                         div;    /* divisor */
1379 
1380         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1381 
1382         /* prevent divide by zero...  */
1383         b16 = baud_rate * 16L;
1384         if (b16 == 0)
1385                 return KEYSPAN_INVALID_BAUD_RATE;
1386 
1387         /* calculate the divisor */
1388         div = baudclk / b16;
1389         if (div == 0)
1390                 return KEYSPAN_INVALID_BAUD_RATE;
1391 
1392         if (div > 0xffff)
1393                 return KEYSPAN_INVALID_BAUD_RATE;
1394 
1395         /* return the counter values if non-null */
1396         if (rate_low)
1397                 *rate_low = (u8) (div & 0xff);
1398 
1399         if (rate_hi)
1400                 *rate_hi = (u8) ((div >> 8) & 0xff);
1401 
1402         if (rate_low && rate_hi)
1403                 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1404                         __func__, baud_rate, *rate_hi, *rate_low);
1405 
1406         return KEYSPAN_BAUD_RATE_OK;
1407 }
1408 
1409 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1410                                     u32 baud_rate, u32 baudclk, u8 *rate_hi,
1411                                     u8 *rate_low, u8 *prescaler, int portnum)
1412 {
1413         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1414                 clk,    /* clock with 13/8 prescaler */
1415                 div,    /* divisor using 13/8 prescaler */
1416                 res,    /* resulting baud rate using 13/8 prescaler */
1417                 diff,   /* error using 13/8 prescaler */
1418                 smallest_diff;
1419         u8      best_prescaler;
1420         int     i;
1421 
1422         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1423 
1424         /* prevent divide by zero */
1425         b16 = baud_rate * 16L;
1426         if (b16 == 0)
1427                 return KEYSPAN_INVALID_BAUD_RATE;
1428 
1429         /* Calculate prescaler by trying them all and looking
1430            for best fit */
1431 
1432         /* start with largest possible difference */
1433         smallest_diff = 0xffffffff;
1434 
1435                 /* 0 is an invalid prescaler, used as a flag */
1436         best_prescaler = 0;
1437 
1438         for (i = 8; i <= 0xff; ++i) {
1439                 clk = (baudclk * 8) / (u32) i;
1440 
1441                 div = clk / b16;
1442                 if (div == 0)
1443                         continue;
1444 
1445                 res = clk / div;
1446                 diff = (res > b16) ? (res-b16) : (b16-res);
1447 
1448                 if (diff < smallest_diff) {
1449                         best_prescaler = i;
1450                         smallest_diff = diff;
1451                 }
1452         }
1453 
1454         if (best_prescaler == 0)
1455                 return KEYSPAN_INVALID_BAUD_RATE;
1456 
1457         clk = (baudclk * 8) / (u32) best_prescaler;
1458         div = clk / b16;
1459 
1460         /* return the divisor and prescaler if non-null */
1461         if (rate_low)
1462                 *rate_low = (u8) (div & 0xff);
1463         if (rate_hi)
1464                 *rate_hi = (u8) ((div >> 8) & 0xff);
1465         if (prescaler) {
1466                 *prescaler = best_prescaler;
1467                 /*  dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1468         }
1469         return KEYSPAN_BAUD_RATE_OK;
1470 }
1471 
1472         /* USA-28 supports different maximum baud rates on each port */
1473 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1474                                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
1475                                    u8 *rate_low, u8 *prescaler, int portnum)
1476 {
1477         u32     b16,    /* baud rate times 16 (actual rate used internally) */
1478                 div,    /* divisor */
1479                 cnt;    /* inverse of divisor (programmed into 8051) */
1480 
1481         dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1482 
1483                 /* prevent divide by zero */
1484         b16 = baud_rate * 16L;
1485         if (b16 == 0)
1486                 return KEYSPAN_INVALID_BAUD_RATE;
1487 
1488         /* calculate the divisor and the counter (its inverse) */
1489         div = KEYSPAN_USA28_BAUDCLK / b16;
1490         if (div == 0)
1491                 return KEYSPAN_INVALID_BAUD_RATE;
1492         else
1493                 cnt = 0 - div;
1494 
1495         /* check for out of range, based on portnum,
1496            and return result */
1497         if (portnum == 0) {
1498                 if (div > 0xffff)
1499                         return KEYSPAN_INVALID_BAUD_RATE;
1500         } else {
1501                 if (portnum == 1) {
1502                         if (div > 0xff)
1503                                 return KEYSPAN_INVALID_BAUD_RATE;
1504                 } else
1505                         return KEYSPAN_INVALID_BAUD_RATE;
1506         }
1507 
1508                 /* return the counter values if not NULL
1509                    (port 1 will ignore retHi) */
1510         if (rate_low)
1511                 *rate_low = (u8) (cnt & 0xff);
1512         if (rate_hi)
1513                 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1514         dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
1515         return KEYSPAN_BAUD_RATE_OK;
1516 }
1517 
1518 static int keyspan_usa26_send_setup(struct usb_serial *serial,
1519                                     struct usb_serial_port *port,
1520                                     int reset_port)
1521 {
1522         struct keyspan_usa26_portControlMessage msg;
1523         struct keyspan_serial_private           *s_priv;
1524         struct keyspan_port_private             *p_priv;
1525         const struct keyspan_device_details     *d_details;
1526         struct urb                              *this_urb;
1527         int                                     device_port, err;
1528 
1529         dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
1530 
1531         s_priv = usb_get_serial_data(serial);
1532         p_priv = usb_get_serial_port_data(port);
1533         d_details = s_priv->device_details;
1534         device_port = port->port_number;
1535 
1536         this_urb = p_priv->outcont_urb;
1537 
1538                 /* Make sure we have an urb then send the message */
1539         if (this_urb == NULL) {
1540                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1541                 return -1;
1542         }
1543 
1544         dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
1545 
1546         /* Save reset port val for resend.
1547            Don't overwrite resend for open/close condition. */
1548         if ((reset_port + 1) > p_priv->resend_cont)
1549                 p_priv->resend_cont = reset_port + 1;
1550         if (this_urb->status == -EINPROGRESS) {
1551                 /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1552                 mdelay(5);
1553                 return -1;
1554         }
1555 
1556         memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
1557 
1558         /* Only set baud rate if it's changed */
1559         if (p_priv->old_baud != p_priv->baud) {
1560                 p_priv->old_baud = p_priv->baud;
1561                 msg.setClocking = 0xff;
1562                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1563                                                    &msg.baudHi, &msg.baudLo, &msg.prescaler,
1564                                                    device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1565                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1566                                 __func__, p_priv->baud);
1567                         msg.baudLo = 0;
1568                         msg.baudHi = 125;       /* Values for 9600 baud */
1569                         msg.prescaler = 10;
1570                 }
1571                 msg.setPrescaler = 0xff;
1572         }
1573 
1574         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1575         switch (p_priv->cflag & CSIZE) {
1576         case CS5:
1577                 msg.lcr |= USA_DATABITS_5;
1578                 break;
1579         case CS6:
1580                 msg.lcr |= USA_DATABITS_6;
1581                 break;
1582         case CS7:
1583                 msg.lcr |= USA_DATABITS_7;
1584                 break;
1585         case CS8:
1586                 msg.lcr |= USA_DATABITS_8;
1587                 break;
1588         }
1589         if (p_priv->cflag & PARENB) {
1590                 /* note USA_PARITY_NONE == 0 */
1591                 msg.lcr |= (p_priv->cflag & PARODD) ?
1592                         USA_PARITY_ODD : USA_PARITY_EVEN;
1593         }
1594         msg.setLcr = 0xff;
1595 
1596         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1597         msg.xonFlowControl = 0;
1598         msg.setFlowControl = 0xff;
1599         msg.forwardingLength = 16;
1600         msg.xonChar = 17;
1601         msg.xoffChar = 19;
1602 
1603         /* Opening port */
1604         if (reset_port == 1) {
1605                 msg._txOn = 1;
1606                 msg._txOff = 0;
1607                 msg.txFlush = 0;
1608                 msg.txBreak = 0;
1609                 msg.rxOn = 1;
1610                 msg.rxOff = 0;
1611                 msg.rxFlush = 1;
1612                 msg.rxForward = 0;
1613                 msg.returnStatus = 0;
1614                 msg.resetDataToggle = 0xff;
1615         }
1616 
1617         /* Closing port */
1618         else if (reset_port == 2) {
1619                 msg._txOn = 0;
1620                 msg._txOff = 1;
1621                 msg.txFlush = 0;
1622                 msg.txBreak = 0;
1623                 msg.rxOn = 0;
1624                 msg.rxOff = 1;
1625                 msg.rxFlush = 1;
1626                 msg.rxForward = 0;
1627                 msg.returnStatus = 0;
1628                 msg.resetDataToggle = 0;
1629         }
1630 
1631         /* Sending intermediate configs */
1632         else {
1633                 msg._txOn = (!p_priv->break_on);
1634                 msg._txOff = 0;
1635                 msg.txFlush = 0;
1636                 msg.txBreak = (p_priv->break_on);
1637                 msg.rxOn = 0;
1638                 msg.rxOff = 0;
1639                 msg.rxFlush = 0;
1640                 msg.rxForward = 0;
1641                 msg.returnStatus = 0;
1642                 msg.resetDataToggle = 0x0;
1643         }
1644 
1645         /* Do handshaking outputs */
1646         msg.setTxTriState_setRts = 0xff;
1647         msg.txTriState_rts = p_priv->rts_state;
1648 
1649         msg.setHskoa_setDtr = 0xff;
1650         msg.hskoa_dtr = p_priv->dtr_state;
1651 
1652         p_priv->resend_cont = 0;
1653         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1654 
1655         /* send the data out the device on control endpoint */
1656         this_urb->transfer_buffer_length = sizeof(msg);
1657 
1658         err = usb_submit_urb(this_urb, GFP_ATOMIC);
1659         if (err != 0)
1660                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1661         return 0;
1662 }
1663 
1664 static int keyspan_usa28_send_setup(struct usb_serial *serial,
1665                                     struct usb_serial_port *port,
1666                                     int reset_port)
1667 {
1668         struct keyspan_usa28_portControlMessage msg;
1669         struct keyspan_serial_private           *s_priv;
1670         struct keyspan_port_private             *p_priv;
1671         const struct keyspan_device_details     *d_details;
1672         struct urb                              *this_urb;
1673         int                                     device_port, err;
1674 
1675         s_priv = usb_get_serial_data(serial);
1676         p_priv = usb_get_serial_port_data(port);
1677         d_details = s_priv->device_details;
1678         device_port = port->port_number;
1679 
1680         /* only do something if we have a bulk out endpoint */
1681         this_urb = p_priv->outcont_urb;
1682         if (this_urb == NULL) {
1683                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1684                 return -1;
1685         }
1686 
1687         /* Save reset port val for resend.
1688            Don't overwrite resend for open/close condition. */
1689         if ((reset_port + 1) > p_priv->resend_cont)
1690                 p_priv->resend_cont = reset_port + 1;
1691         if (this_urb->status == -EINPROGRESS) {
1692                 dev_dbg(&port->dev, "%s already writing\n", __func__);
1693                 mdelay(5);
1694                 return -1;
1695         }
1696 
1697         memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
1698 
1699         msg.setBaudRate = 1;
1700         if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1701                                            &msg.baudHi, &msg.baudLo, NULL,
1702                                            device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1703                 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
1704                                                 __func__, p_priv->baud);
1705                 msg.baudLo = 0xff;
1706                 msg.baudHi = 0xb2;      /* Values for 9600 baud */
1707         }
1708 
1709         /* If parity is enabled, we must calculate it ourselves. */
1710         msg.parity = 0;         /* XXX for now */
1711 
1712         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1713         msg.xonFlowControl = 0;
1714 
1715         /* Do handshaking outputs, DTR is inverted relative to RTS */
1716         msg.rts = p_priv->rts_state;
1717         msg.dtr = p_priv->dtr_state;
1718 
1719         msg.forwardingLength = 16;
1720         msg.forwardMs = 10;
1721         msg.breakThreshold = 45;
1722         msg.xonChar = 17;
1723         msg.xoffChar = 19;
1724 
1725         /*msg.returnStatus = 1;
1726         msg.resetDataToggle = 0xff;*/
1727         /* Opening port */
1728         if (reset_port == 1) {
1729                 msg._txOn = 1;
1730                 msg._txOff = 0;
1731                 msg.txFlush = 0;
1732                 msg.txForceXoff = 0;
1733                 msg.txBreak = 0;
1734                 msg.rxOn = 1;
1735                 msg.rxOff = 0;
1736                 msg.rxFlush = 1;
1737                 msg.rxForward = 0;
1738                 msg.returnStatus = 0;
1739                 msg.resetDataToggle = 0xff;
1740         }
1741         /* Closing port */
1742         else if (reset_port == 2) {
1743                 msg._txOn = 0;
1744                 msg._txOff = 1;
1745                 msg.txFlush = 0;
1746                 msg.txForceXoff = 0;
1747                 msg.txBreak = 0;
1748                 msg.rxOn = 0;
1749                 msg.rxOff = 1;
1750                 msg.rxFlush = 1;
1751                 msg.rxForward = 0;
1752                 msg.returnStatus = 0;
1753                 msg.resetDataToggle = 0;
1754         }
1755         /* Sending intermediate configs */
1756         else {
1757                 msg._txOn = (!p_priv->break_on);
1758                 msg._txOff = 0;
1759                 msg.txFlush = 0;
1760                 msg.txForceXoff = 0;
1761                 msg.txBreak = (p_priv->break_on);
1762                 msg.rxOn = 0;
1763                 msg.rxOff = 0;
1764                 msg.rxFlush = 0;
1765                 msg.rxForward = 0;
1766                 msg.returnStatus = 0;
1767                 msg.resetDataToggle = 0x0;
1768         }
1769 
1770         p_priv->resend_cont = 0;
1771         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1772 
1773         /* send the data out the device on control endpoint */
1774         this_urb->transfer_buffer_length = sizeof(msg);
1775 
1776         err = usb_submit_urb(this_urb, GFP_ATOMIC);
1777         if (err != 0)
1778                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
1779 
1780         return 0;
1781 }
1782 
1783 static int keyspan_usa49_send_setup(struct usb_serial *serial,
1784                                     struct usb_serial_port *port,
1785                                     int reset_port)
1786 {
1787         struct keyspan_usa49_portControlMessage msg;
1788         struct usb_ctrlrequest                  *dr = NULL;
1789         struct keyspan_serial_private           *s_priv;
1790         struct keyspan_port_private             *p_priv;
1791         const struct keyspan_device_details     *d_details;
1792         struct urb                              *this_urb;
1793         int                                     err, device_port;
1794 
1795         s_priv = usb_get_serial_data(serial);
1796         p_priv = usb_get_serial_port_data(port);
1797         d_details = s_priv->device_details;
1798 
1799         this_urb = s_priv->glocont_urb;
1800 
1801         /* Work out which port within the device is being setup */
1802         device_port = port->port_number;
1803 
1804         /* Make sure we have an urb then send the message */
1805         if (this_urb == NULL) {
1806                 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
1807                 return -1;
1808         }
1809 
1810         dev_dbg(&port->dev, "%s - endpoint %d (%d)\n",
1811                 __func__, usb_pipeendpoint(this_urb->pipe), device_port);
1812 
1813         /* Save reset port val for resend.
1814            Don't overwrite resend for open/close condition. */
1815         if ((reset_port + 1) > p_priv->resend_cont)
1816                 p_priv->resend_cont = reset_port + 1;
1817 
1818         if (this_urb->status == -EINPROGRESS) {
1819                 /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1820                 mdelay(5);
1821                 return -1;
1822         }
1823 
1824         memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
1825 
1826         msg.portNumber = device_port;
1827 
1828         /* Only set baud rate if it's changed */
1829         if (p_priv->old_baud != p_priv->baud) {
1830                 p_priv->old_baud = p_priv->baud;
1831                 msg.setClocking = 0xff;
1832                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1833                                                    &msg.baudHi, &msg.baudLo, &msg.prescaler,
1834                                                    device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1835                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1836                                 __func__, p_priv->baud);
1837                         msg.baudLo = 0;
1838                         msg.baudHi = 125;       /* Values for 9600 baud */
1839                         msg.prescaler = 10;
1840                 }
1841                 /* msg.setPrescaler = 0xff; */
1842         }
1843 
1844         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1845         switch (p_priv->cflag & CSIZE) {
1846         case CS5:
1847                 msg.lcr |= USA_DATABITS_5;
1848                 break;
1849         case CS6:
1850                 msg.lcr |= USA_DATABITS_6;
1851                 break;
1852         case CS7:
1853                 msg.lcr |= USA_DATABITS_7;
1854                 break;
1855         case CS8:
1856                 msg.lcr |= USA_DATABITS_8;
1857                 break;
1858         }
1859         if (p_priv->cflag & PARENB) {
1860                 /* note USA_PARITY_NONE == 0 */
1861                 msg.lcr |= (p_priv->cflag & PARODD) ?
1862                         USA_PARITY_ODD : USA_PARITY_EVEN;
1863         }
1864         msg.setLcr = 0xff;
1865 
1866         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1867         msg.xonFlowControl = 0;
1868         msg.setFlowControl = 0xff;
1869 
1870         msg.forwardingLength = 16;
1871         msg.xonChar = 17;
1872         msg.xoffChar = 19;
1873 
1874         /* Opening port */
1875         if (reset_port == 1) {
1876                 msg._txOn = 1;
1877                 msg._txOff = 0;
1878                 msg.txFlush = 0;
1879                 msg.txBreak = 0;
1880                 msg.rxOn = 1;
1881                 msg.rxOff = 0;
1882                 msg.rxFlush = 1;
1883                 msg.rxForward = 0;
1884                 msg.returnStatus = 0;
1885                 msg.resetDataToggle = 0xff;
1886                 msg.enablePort = 1;
1887                 msg.disablePort = 0;
1888         }
1889         /* Closing port */
1890         else if (reset_port == 2) {
1891                 msg._txOn = 0;
1892                 msg._txOff = 1;
1893                 msg.txFlush = 0;
1894                 msg.txBreak = 0;
1895                 msg.rxOn = 0;
1896                 msg.rxOff = 1;
1897                 msg.rxFlush = 1;
1898                 msg.rxForward = 0;
1899                 msg.returnStatus = 0;
1900                 msg.resetDataToggle = 0;
1901                 msg.enablePort = 0;
1902                 msg.disablePort = 1;
1903         }
1904         /* Sending intermediate configs */
1905         else {
1906                 msg._txOn = (!p_priv->break_on);
1907                 msg._txOff = 0;
1908                 msg.txFlush = 0;
1909                 msg.txBreak = (p_priv->break_on);
1910                 msg.rxOn = 0;
1911                 msg.rxOff = 0;
1912                 msg.rxFlush = 0;
1913                 msg.rxForward = 0;
1914                 msg.returnStatus = 0;
1915                 msg.resetDataToggle = 0x0;
1916                 msg.enablePort = 0;
1917                 msg.disablePort = 0;
1918         }
1919 
1920         /* Do handshaking outputs */
1921         msg.setRts = 0xff;
1922         msg.rts = p_priv->rts_state;
1923 
1924         msg.setDtr = 0xff;
1925         msg.dtr = p_priv->dtr_state;
1926 
1927         p_priv->resend_cont = 0;
1928 
1929         /* if the device is a 49wg, we send control message on usb
1930            control EP 0 */
1931 
1932         if (d_details->product_id == keyspan_usa49wg_product_id) {
1933                 dr = (void *)(s_priv->ctrl_buf);
1934                 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
1935                 dr->bRequest = 0xB0;    /* 49wg control message */;
1936                 dr->wValue = 0;
1937                 dr->wIndex = 0;
1938                 dr->wLength = cpu_to_le16(sizeof(msg));
1939 
1940                 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
1941 
1942                 usb_fill_control_urb(this_urb, serial->dev,
1943                                 usb_sndctrlpipe(serial->dev, 0),
1944                                 (unsigned char *)dr, s_priv->glocont_buf,
1945                                 sizeof(msg), usa49_glocont_callback, serial);
1946 
1947         } else {
1948                 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1949 
1950                 /* send the data out the device on control endpoint */
1951                 this_urb->transfer_buffer_length = sizeof(msg);
1952         }
1953         err = usb_submit_urb(this_urb, GFP_ATOMIC);
1954         if (err != 0)
1955                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1956 
1957         return 0;
1958 }
1959 
1960 static int keyspan_usa90_send_setup(struct usb_serial *serial,
1961                                     struct usb_serial_port *port,
1962                                     int reset_port)
1963 {
1964         struct keyspan_usa90_portControlMessage msg;
1965         struct keyspan_serial_private           *s_priv;
1966         struct keyspan_port_private             *p_priv;
1967         const struct keyspan_device_details     *d_details;
1968         struct urb                              *this_urb;
1969         int                                     err;
1970         u8                                              prescaler;
1971 
1972         s_priv = usb_get_serial_data(serial);
1973         p_priv = usb_get_serial_port_data(port);
1974         d_details = s_priv->device_details;
1975 
1976         /* only do something if we have a bulk out endpoint */
1977         this_urb = p_priv->outcont_urb;
1978         if (this_urb == NULL) {
1979                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1980                 return -1;
1981         }
1982 
1983         /* Save reset port val for resend.
1984            Don't overwrite resend for open/close condition. */
1985         if ((reset_port + 1) > p_priv->resend_cont)
1986                 p_priv->resend_cont = reset_port + 1;
1987         if (this_urb->status == -EINPROGRESS) {
1988                 dev_dbg(&port->dev, "%s already writing\n", __func__);
1989                 mdelay(5);
1990                 return -1;
1991         }
1992 
1993         memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
1994 
1995         /* Only set baud rate if it's changed */
1996         if (p_priv->old_baud != p_priv->baud) {
1997                 p_priv->old_baud = p_priv->baud;
1998                 msg.setClocking = 0x01;
1999                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2000                                                    &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2001                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2002                                 __func__, p_priv->baud);
2003                         p_priv->baud = 9600;
2004                         d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2005                                 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2006                 }
2007                 msg.setRxMode = 1;
2008                 msg.setTxMode = 1;
2009         }
2010 
2011         /* modes must always be correctly specified */
2012         if (p_priv->baud > 57600) {
2013                 msg.rxMode = RXMODE_DMA;
2014                 msg.txMode = TXMODE_DMA;
2015         } else {
2016                 msg.rxMode = RXMODE_BYHAND;
2017                 msg.txMode = TXMODE_BYHAND;
2018         }
2019 
2020         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2021         switch (p_priv->cflag & CSIZE) {
2022         case CS5:
2023                 msg.lcr |= USA_DATABITS_5;
2024                 break;
2025         case CS6:
2026                 msg.lcr |= USA_DATABITS_6;
2027                 break;
2028         case CS7:
2029                 msg.lcr |= USA_DATABITS_7;
2030                 break;
2031         case CS8:
2032                 msg.lcr |= USA_DATABITS_8;
2033                 break;
2034         }
2035         if (p_priv->cflag & PARENB) {
2036                 /* note USA_PARITY_NONE == 0 */
2037                 msg.lcr |= (p_priv->cflag & PARODD) ?
2038                         USA_PARITY_ODD : USA_PARITY_EVEN;
2039         }
2040         if (p_priv->old_cflag != p_priv->cflag) {
2041                 p_priv->old_cflag = p_priv->cflag;
2042                 msg.setLcr = 0x01;
2043         }
2044 
2045         if (p_priv->flow_control == flow_cts)
2046                 msg.txFlowControl = TXFLOW_CTS;
2047         msg.setTxFlowControl = 0x01;
2048         msg.setRxFlowControl = 0x01;
2049 
2050         msg.rxForwardingLength = 16;
2051         msg.rxForwardingTimeout = 16;
2052         msg.txAckSetting = 0;
2053         msg.xonChar = 17;
2054         msg.xoffChar = 19;
2055 
2056         /* Opening port */
2057         if (reset_port == 1) {
2058                 msg.portEnabled = 1;
2059                 msg.rxFlush = 1;
2060                 msg.txBreak = (p_priv->break_on);
2061         }
2062         /* Closing port */
2063         else if (reset_port == 2)
2064                 msg.portEnabled = 0;
2065         /* Sending intermediate configs */
2066         else {
2067                 msg.portEnabled = 1;
2068                 msg.txBreak = (p_priv->break_on);
2069         }
2070 
2071         /* Do handshaking outputs */
2072         msg.setRts = 0x01;
2073         msg.rts = p_priv->rts_state;
2074 
2075         msg.setDtr = 0x01;
2076         msg.dtr = p_priv->dtr_state;
2077 
2078         p_priv->resend_cont = 0;
2079         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2080 
2081         /* send the data out the device on control endpoint */
2082         this_urb->transfer_buffer_length = sizeof(msg);
2083 
2084         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2085         if (err != 0)
2086                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2087         return 0;
2088 }
2089 
2090 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2091                                     struct usb_serial_port *port,
2092                                     int reset_port)
2093 {
2094         struct keyspan_usa67_portControlMessage msg;
2095         struct keyspan_serial_private           *s_priv;
2096         struct keyspan_port_private             *p_priv;
2097         const struct keyspan_device_details     *d_details;
2098         struct urb                              *this_urb;
2099         int                                     err, device_port;
2100 
2101         s_priv = usb_get_serial_data(serial);
2102         p_priv = usb_get_serial_port_data(port);
2103         d_details = s_priv->device_details;
2104 
2105         this_urb = s_priv->glocont_urb;
2106 
2107         /* Work out which port within the device is being setup */
2108         device_port = port->port_number;
2109 
2110         /* Make sure we have an urb then send the message */
2111         if (this_urb == NULL) {
2112                 dev_dbg(&port->dev, "%s - oops no urb for port.\n", __func__);
2113                 return -1;
2114         }
2115 
2116         /* Save reset port val for resend.
2117            Don't overwrite resend for open/close condition. */
2118         if ((reset_port + 1) > p_priv->resend_cont)
2119                 p_priv->resend_cont = reset_port + 1;
2120         if (this_urb->status == -EINPROGRESS) {
2121                 /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2122                 mdelay(5);
2123                 return -1;
2124         }
2125 
2126         memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2127 
2128         msg.port = device_port;
2129 
2130         /* Only set baud rate if it's changed */
2131         if (p_priv->old_baud != p_priv->baud) {
2132                 p_priv->old_baud = p_priv->baud;
2133                 msg.setClocking = 0xff;
2134                 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2135                                                    &msg.baudHi, &msg.baudLo, &msg.prescaler,
2136                                                    device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2137                         dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2138                                 __func__, p_priv->baud);
2139                         msg.baudLo = 0;
2140                         msg.baudHi = 125;       /* Values for 9600 baud */
2141                         msg.prescaler = 10;
2142                 }
2143                 msg.setPrescaler = 0xff;
2144         }
2145 
2146         msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2147         switch (p_priv->cflag & CSIZE) {
2148         case CS5:
2149                 msg.lcr |= USA_DATABITS_5;
2150                 break;
2151         case CS6:
2152                 msg.lcr |= USA_DATABITS_6;
2153                 break;
2154         case CS7:
2155                 msg.lcr |= USA_DATABITS_7;
2156                 break;
2157         case CS8:
2158                 msg.lcr |= USA_DATABITS_8;
2159                 break;
2160         }
2161         if (p_priv->cflag & PARENB) {
2162                 /* note USA_PARITY_NONE == 0 */
2163                 msg.lcr |= (p_priv->cflag & PARODD) ?
2164                                         USA_PARITY_ODD : USA_PARITY_EVEN;
2165         }
2166         msg.setLcr = 0xff;
2167 
2168         msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2169         msg.xonFlowControl = 0;
2170         msg.setFlowControl = 0xff;
2171         msg.forwardingLength = 16;
2172         msg.xonChar = 17;
2173         msg.xoffChar = 19;
2174 
2175         if (reset_port == 1) {
2176                 /* Opening port */
2177                 msg._txOn = 1;
2178                 msg._txOff = 0;
2179                 msg.txFlush = 0;
2180                 msg.txBreak = 0;
2181                 msg.rxOn = 1;
2182                 msg.rxOff = 0;
2183                 msg.rxFlush = 1;
2184                 msg.rxForward = 0;
2185                 msg.returnStatus = 0;
2186                 msg.resetDataToggle = 0xff;
2187         } else if (reset_port == 2) {
2188                 /* Closing port */
2189                 msg._txOn = 0;
2190                 msg._txOff = 1;
2191                 msg.txFlush = 0;
2192                 msg.txBreak = 0;
2193                 msg.rxOn = 0;
2194                 msg.rxOff = 1;
2195                 msg.rxFlush = 1;
2196                 msg.rxForward = 0;
2197                 msg.returnStatus = 0;
2198                 msg.resetDataToggle = 0;
2199         } else {
2200                 /* Sending intermediate configs */
2201                 msg._txOn = (!p_priv->break_on);
2202                 msg._txOff = 0;
2203                 msg.txFlush = 0;
2204                 msg.txBreak = (p_priv->break_on);
2205                 msg.rxOn = 0;
2206                 msg.rxOff = 0;
2207                 msg.rxFlush = 0;
2208                 msg.rxForward = 0;
2209                 msg.returnStatus = 0;
2210                 msg.resetDataToggle = 0x0;
2211         }
2212 
2213         /* Do handshaking outputs */
2214         msg.setTxTriState_setRts = 0xff;
2215         msg.txTriState_rts = p_priv->rts_state;
2216 
2217         msg.setHskoa_setDtr = 0xff;
2218         msg.hskoa_dtr = p_priv->dtr_state;
2219 
2220         p_priv->resend_cont = 0;
2221 
2222         memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2223 
2224         /* send the data out the device on control endpoint */
2225         this_urb->transfer_buffer_length = sizeof(msg);
2226 
2227         err = usb_submit_urb(this_urb, GFP_ATOMIC);
2228         if (err != 0)
2229                 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2230         return 0;
2231 }
2232 
2233 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2234 {
2235         struct usb_serial *serial = port->serial;
2236         struct keyspan_serial_private *s_priv;
2237         const struct keyspan_device_details *d_details;
2238 
2239         s_priv = usb_get_serial_data(serial);
2240         d_details = s_priv->device_details;
2241 
2242         switch (d_details->msg_format) {
2243         case msg_usa26:
2244                 keyspan_usa26_send_setup(serial, port, reset_port);
2245                 break;
2246         case msg_usa28:
2247                 keyspan_usa28_send_setup(serial, port, reset_port);
2248                 break;
2249         case msg_usa49:
2250                 keyspan_usa49_send_setup(serial, port, reset_port);
2251                 break;
2252         case msg_usa90:
2253                 keyspan_usa90_send_setup(serial, port, reset_port);
2254                 break;
2255         case msg_usa67:
2256                 keyspan_usa67_send_setup(serial, port, reset_port);
2257                 break;
2258         }
2259 }
2260 
2261 
2262 /* Gets called by the "real" driver (ie once firmware is loaded
2263    and renumeration has taken place. */
2264 static int keyspan_startup(struct usb_serial *serial)
2265 {
2266         int                             i, err;
2267         struct keyspan_serial_private   *s_priv;
2268         const struct keyspan_device_details     *d_details;
2269 
2270         for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2271                 if (d_details->product_id ==
2272                                 le16_to_cpu(serial->dev->descriptor.idProduct))
2273                         break;
2274         if (d_details == NULL) {
2275                 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2276                     __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2277                 return -ENODEV;
2278         }
2279 
2280         /* Setup private data for serial driver */
2281         s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2282         if (!s_priv)
2283                 return -ENOMEM;
2284 
2285         s_priv->instat_buf = kzalloc(INSTAT_BUFLEN, GFP_KERNEL);
2286         if (!s_priv->instat_buf)
2287                 goto err_instat_buf;
2288 
2289         s_priv->indat_buf = kzalloc(INDAT49W_BUFLEN, GFP_KERNEL);
2290         if (!s_priv->indat_buf)
2291                 goto err_indat_buf;
2292 
2293         s_priv->glocont_buf = kzalloc(GLOCONT_BUFLEN, GFP_KERNEL);
2294         if (!s_priv->glocont_buf)
2295                 goto err_glocont_buf;
2296 
2297         s_priv->ctrl_buf = kzalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
2298         if (!s_priv->ctrl_buf)
2299                 goto err_ctrl_buf;
2300 
2301         s_priv->device_details = d_details;
2302         usb_set_serial_data(serial, s_priv);
2303 
2304         keyspan_setup_urbs(serial);
2305 
2306         if (s_priv->instat_urb != NULL) {
2307                 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2308                 if (err != 0)
2309                         dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2310         }
2311         if (s_priv->indat_urb != NULL) {
2312                 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2313                 if (err != 0)
2314                         dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2315         }
2316 
2317         return 0;
2318 
2319 err_ctrl_buf:
2320         kfree(s_priv->glocont_buf);
2321 err_glocont_buf:
2322         kfree(s_priv->indat_buf);
2323 err_indat_buf:
2324         kfree(s_priv->instat_buf);
2325 err_instat_buf:
2326         kfree(s_priv);
2327 
2328         return -ENOMEM;
2329 }
2330 
2331 static void keyspan_disconnect(struct usb_serial *serial)
2332 {
2333         struct keyspan_serial_private *s_priv;
2334 
2335         s_priv = usb_get_serial_data(serial);
2336 
2337         stop_urb(s_priv->instat_urb);
2338         stop_urb(s_priv->glocont_urb);
2339         stop_urb(s_priv->indat_urb);
2340 }
2341 
2342 static void keyspan_release(struct usb_serial *serial)
2343 {
2344         struct keyspan_serial_private *s_priv;
2345 
2346         s_priv = usb_get_serial_data(serial);
2347 
2348         usb_free_urb(s_priv->instat_urb);
2349         usb_free_urb(s_priv->indat_urb);
2350         usb_free_urb(s_priv->glocont_urb);
2351 
2352         kfree(s_priv->ctrl_buf);
2353         kfree(s_priv->glocont_buf);
2354         kfree(s_priv->indat_buf);
2355         kfree(s_priv->instat_buf);
2356 
2357         kfree(s_priv);
2358 }
2359 
2360 static int keyspan_port_probe(struct usb_serial_port *port)
2361 {
2362         struct usb_serial *serial = port->serial;
2363         struct keyspan_serial_private *s_priv;
2364         struct keyspan_port_private *p_priv;
2365         const struct keyspan_device_details *d_details;
2366         struct callbacks *cback;
2367         int endp;
2368         int port_num;
2369         int i;
2370 
2371         s_priv = usb_get_serial_data(serial);
2372         d_details = s_priv->device_details;
2373 
2374         p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2375         if (!p_priv)
2376                 return -ENOMEM;
2377 
2378         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) {
2379                 p_priv->in_buffer[i] = kzalloc(IN_BUFLEN, GFP_KERNEL);
2380                 if (!p_priv->in_buffer[i])
2381                         goto err_in_buffer;
2382         }
2383 
2384         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) {
2385                 p_priv->out_buffer[i] = kzalloc(OUT_BUFLEN, GFP_KERNEL);
2386                 if (!p_priv->out_buffer[i])
2387                         goto err_out_buffer;
2388         }
2389 
2390         p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL);
2391         if (!p_priv->inack_buffer)
2392                 goto err_inack_buffer;
2393 
2394         p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL);
2395         if (!p_priv->outcont_buffer)
2396                 goto err_outcont_buffer;
2397 
2398         p_priv->device_details = d_details;
2399 
2400         /* Setup values for the various callback routines */
2401         cback = &keyspan_callbacks[d_details->msg_format];
2402 
2403         port_num = port->port_number;
2404 
2405         /* Do indat endpoints first, once for each flip */
2406         endp = d_details->indat_endpoints[port_num];
2407         for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2408                 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2409                                                 USB_DIR_IN, port,
2410                                                 p_priv->in_buffer[i],
2411                                                 IN_BUFLEN,
2412                                                 cback->indat_callback);
2413         }
2414         /* outdat endpoints also have flip */
2415         endp = d_details->outdat_endpoints[port_num];
2416         for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2417                 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2418                                                 USB_DIR_OUT, port,
2419                                                 p_priv->out_buffer[i],
2420                                                 OUT_BUFLEN,
2421                                                 cback->outdat_callback);
2422         }
2423         /* inack endpoint */
2424         p_priv->inack_urb = keyspan_setup_urb(serial,
2425                                         d_details->inack_endpoints[port_num],
2426                                         USB_DIR_IN, port,
2427                                         p_priv->inack_buffer,
2428                                         INACK_BUFLEN,
2429                                         cback->inack_callback);
2430         /* outcont endpoint */
2431         p_priv->outcont_urb = keyspan_setup_urb(serial,
2432                                         d_details->outcont_endpoints[port_num],
2433                                         USB_DIR_OUT, port,
2434                                         p_priv->outcont_buffer,
2435                                         OUTCONT_BUFLEN,
2436                                          cback->outcont_callback);
2437 
2438         usb_set_serial_port_data(port, p_priv);
2439 
2440         return 0;
2441 
2442 err_outcont_buffer:
2443         kfree(p_priv->inack_buffer);
2444 err_inack_buffer:
2445         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2446                 kfree(p_priv->out_buffer[i]);
2447 err_out_buffer:
2448         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2449                 kfree(p_priv->in_buffer[i]);
2450 err_in_buffer:
2451         kfree(p_priv);
2452 
2453         return -ENOMEM;
2454 }
2455 
2456 static int keyspan_port_remove(struct usb_serial_port *port)
2457 {
2458         struct keyspan_port_private *p_priv;
2459         int i;
2460 
2461         p_priv = usb_get_serial_port_data(port);
2462 
2463         stop_urb(p_priv->inack_urb);
2464         stop_urb(p_priv->outcont_urb);
2465         for (i = 0; i < 2; i++) {
2466                 stop_urb(p_priv->in_urbs[i]);
2467                 stop_urb(p_priv->out_urbs[i]);
2468         }
2469 
2470         usb_free_urb(p_priv->inack_urb);
2471         usb_free_urb(p_priv->outcont_urb);
2472         for (i = 0; i < 2; i++) {
2473                 usb_free_urb(p_priv->in_urbs[i]);
2474                 usb_free_urb(p_priv->out_urbs[i]);
2475         }
2476 
2477         kfree(p_priv->outcont_buffer);
2478         kfree(p_priv->inack_buffer);
2479         for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
2480                 kfree(p_priv->out_buffer[i]);
2481         for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
2482                 kfree(p_priv->in_buffer[i]);
2483 
2484         kfree(p_priv);
2485 
2486         return 0;
2487 }
2488 
2489 MODULE_AUTHOR(DRIVER_AUTHOR);
2490 MODULE_DESCRIPTION(DRIVER_DESC);
2491 MODULE_LICENSE("GPL");
2492 
2493 MODULE_FIRMWARE("keyspan/usa28.fw");
2494 MODULE_FIRMWARE("keyspan/usa28x.fw");
2495 MODULE_FIRMWARE("keyspan/usa28xa.fw");
2496 MODULE_FIRMWARE("keyspan/usa28xb.fw");
2497 MODULE_FIRMWARE("keyspan/usa19.fw");
2498 MODULE_FIRMWARE("keyspan/usa19qi.fw");
2499 MODULE_FIRMWARE("keyspan/mpr.fw");
2500 MODULE_FIRMWARE("keyspan/usa19qw.fw");
2501 MODULE_FIRMWARE("keyspan/usa18x.fw");
2502 MODULE_FIRMWARE("keyspan/usa19w.fw");
2503 MODULE_FIRMWARE("keyspan/usa49w.fw");
2504 MODULE_FIRMWARE("keyspan/usa49wlc.fw");
2505 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us