Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/usb/serial/keyspan.c

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

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