Version:  2.0.40 2.2.26 2.4.37 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 3.17 3.18

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

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