Version:  2.0.40 2.2.26 2.4.37 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 3.19 4.0

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

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