Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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

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