2 Keyspan USB to Serial Converter driver
4 (C) Copyright (C) 2000-2001 Hugh Blemings <hugh@blemings.org>
5 (C) Copyright (C) 2002 Greg Kroah-Hartman <greg@kroah.com>
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.
12 See http://blemings.org/hugh/keyspan.html for more information.
14 Code in this driver inspired by and in a number of places taken
15 from Brian Warner's original Keyspan-PDA driver.
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.
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
26 Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
27 staff in their work on open source projects.
31 #include <linux/kernel.h>
32 #include <linux/jiffies.h>
33 #include <linux/errno.h>
34 #include <linux/init.h>
35 #include <linux/slab.h>
36 #include <linux/tty.h>
37 #include <linux/tty_driver.h>
38 #include <linux/tty_flip.h>
39 #include <linux/module.h>
40 #include <linux/spinlock.h>
41 #include <linux/uaccess.h>
42 #include <linux/usb.h>
43 #include <linux/usb/serial.h>
44 #include <linux/usb/ezusb.h>
47 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
48 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
50 #define INSTAT_BUFLEN 32
51 #define GLOCONT_BUFLEN 64
52 #define INDAT49W_BUFLEN 512
54 /* Per device and per port private data */
55 struct keyspan_serial_private {
56 const struct keyspan_device_details *device_details;
58 struct urb *instat_urb;
59 char instat_buf[INSTAT_BUFLEN];
61 /* added to support 49wg, where data from all 4 ports comes in
62 on 1 EP and high-speed supported */
63 struct urb *indat_urb;
64 char indat_buf[INDAT49W_BUFLEN];
66 /* XXX this one probably will need a lock */
67 struct urb *glocont_urb;
68 char glocont_buf[GLOCONT_BUFLEN];
69 char ctrl_buf[8]; /* for EP0 control message */
72 struct keyspan_port_private {
73 /* Keep track of which input & output endpoints to use */
77 /* Keep duplicate of device details in each port
78 structure as well - simplifies some of the
79 callback functions etc. */
80 const struct keyspan_device_details *device_details;
82 /* Input endpoints and buffer for this port */
83 struct urb *in_urbs[2];
84 char in_buffer[2][64];
85 /* Output endpoints and buffer for this port */
86 struct urb *out_urbs[2];
87 char out_buffer[2][64];
89 /* Input ack endpoint */
90 struct urb *inack_urb;
93 /* Output control endpoint */
94 struct urb *outcont_urb;
95 char outcont_buffer[64];
97 /* Settings for the port */
101 unsigned int old_cflag;
102 enum {flow_none, flow_cts, flow_xon} flow_control;
103 int rts_state; /* Handshaking pins (outputs) */
105 int cts_state; /* Handshaking pins (inputs) */
111 unsigned long tx_start_time[2];
112 int resend_cont; /* need to resend control packet */
115 /* Include Keyspan message headers. All current Keyspan Adapters
116 make use of one of five message formats which are referred
117 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
118 within this driver. */
119 #include "keyspan_usa26msg.h"
120 #include "keyspan_usa28msg.h"
121 #include "keyspan_usa49msg.h"
122 #include "keyspan_usa90msg.h"
123 #include "keyspan_usa67msg.h"
126 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
128 static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
130 struct usb_serial_port *port = tty->driver_data;
131 struct keyspan_port_private *p_priv;
133 p_priv = usb_get_serial_port_data(port);
135 if (break_state == -1)
136 p_priv->break_on = 1;
138 p_priv->break_on = 0;
140 keyspan_send_setup(port, 0);
144 static void keyspan_set_termios(struct tty_struct *tty,
145 struct usb_serial_port *port, struct ktermios *old_termios)
147 int baud_rate, device_port;
148 struct keyspan_port_private *p_priv;
149 const struct keyspan_device_details *d_details;
152 p_priv = usb_get_serial_port_data(port);
153 d_details = p_priv->device_details;
154 cflag = tty->termios.c_cflag;
155 device_port = port->number - port->serial->minor;
157 /* Baud rate calculation takes baud rate as an integer
158 so other rates can be generated if desired. */
159 baud_rate = tty_get_baud_rate(tty);
160 /* If no match or invalid, don't change */
161 if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
162 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
163 /* FIXME - more to do here to ensure rate changes cleanly */
164 /* FIXME - calcuate exact rate from divisor ? */
165 p_priv->baud = baud_rate;
167 baud_rate = tty_termios_baud_rate(old_termios);
169 tty_encode_baud_rate(tty, baud_rate, baud_rate);
170 /* set CTS/RTS handshake etc. */
171 p_priv->cflag = cflag;
172 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
174 /* Mark/Space not supported */
175 tty->termios.c_cflag &= ~CMSPAR;
177 keyspan_send_setup(port, 0);
180 static int keyspan_tiocmget(struct tty_struct *tty)
182 struct usb_serial_port *port = tty->driver_data;
183 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
186 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
187 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
188 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
189 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
190 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
191 ((p_priv->ri_state) ? TIOCM_RNG : 0);
196 static int keyspan_tiocmset(struct tty_struct *tty,
197 unsigned int set, unsigned int clear)
199 struct usb_serial_port *port = tty->driver_data;
200 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
203 p_priv->rts_state = 1;
205 p_priv->dtr_state = 1;
206 if (clear & TIOCM_RTS)
207 p_priv->rts_state = 0;
208 if (clear & TIOCM_DTR)
209 p_priv->dtr_state = 0;
210 keyspan_send_setup(port, 0);
214 /* Write function is similar for the four protocols used
215 with only a minor change for usa90 (usa19hs) required */
216 static int keyspan_write(struct tty_struct *tty,
217 struct usb_serial_port *port, const unsigned char *buf, int count)
219 struct keyspan_port_private *p_priv;
220 const struct keyspan_device_details *d_details;
223 struct urb *this_urb;
224 int err, maxDataLen, dataOffset;
226 p_priv = usb_get_serial_port_data(port);
227 d_details = p_priv->device_details;
229 if (d_details->msg_format == msg_usa90) {
237 dev_dbg(&port->dev, "%s - for port %d (%d chars), flip=%d\n",
238 __func__, port->number, count, p_priv->out_flip);
240 for (left = count; left > 0; left -= todo) {
242 if (todo > maxDataLen)
245 flip = p_priv->out_flip;
247 /* Check we have a valid urb/endpoint before we use it... */
248 this_urb = p_priv->out_urbs[flip];
249 if (this_urb == NULL) {
250 /* no bulk out, so return 0 bytes written */
251 dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
255 dev_dbg(&port->dev, "%s - endpoint %d flip %d\n",
256 __func__, usb_pipeendpoint(this_urb->pipe), flip);
258 if (this_urb->status == -EINPROGRESS) {
259 if (time_before(jiffies,
260 p_priv->tx_start_time[flip] + 10 * HZ))
262 usb_unlink_urb(this_urb);
266 /* First byte in buffer is "last flag" (except for usa19hx)
267 - unused so for now so set to zero */
268 ((char *)this_urb->transfer_buffer)[0] = 0;
270 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
273 /* send the data out the bulk port */
274 this_urb->transfer_buffer_length = todo + dataOffset;
276 err = usb_submit_urb(this_urb, GFP_ATOMIC);
278 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
279 p_priv->tx_start_time[flip] = jiffies;
281 /* Flip for next time if usa26 or usa28 interface
282 (not used on usa49) */
283 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
289 static void usa26_indat_callback(struct urb *urb)
293 struct usb_serial_port *port;
294 unsigned char *data = urb->transfer_buffer;
295 int status = urb->status;
297 endpoint = usb_pipeendpoint(urb->pipe);
300 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
301 __func__, status, endpoint);
306 if (urb->actual_length) {
307 /* 0x80 bit is error flag */
308 if ((data[0] & 0x80) == 0) {
309 /* no errors on individual bytes, only
310 possible overrun err */
311 if (data[0] & RXERROR_OVERRUN)
315 for (i = 1; i < urb->actual_length ; ++i)
316 tty_insert_flip_char(&port->port, data[i], err);
318 /* some bytes had errors, every byte has status */
319 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
320 for (i = 0; i + 1 < urb->actual_length; i += 2) {
321 int stat = data[i], flag = 0;
322 if (stat & RXERROR_OVERRUN)
324 if (stat & RXERROR_FRAMING)
326 if (stat & RXERROR_PARITY)
328 /* XXX should handle break (0x10) */
329 tty_insert_flip_char(&port->port, data[i+1],
333 tty_flip_buffer_push(&port->port);
336 /* Resubmit urb so we continue receiving */
337 err = usb_submit_urb(urb, GFP_ATOMIC);
339 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
342 /* Outdat handling is common for all devices */
343 static void usa2x_outdat_callback(struct urb *urb)
345 struct usb_serial_port *port;
346 struct keyspan_port_private *p_priv;
349 p_priv = usb_get_serial_port_data(port);
350 dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
352 usb_serial_port_softint(port);
355 static void usa26_inack_callback(struct urb *urb)
359 static void usa26_outcont_callback(struct urb *urb)
361 struct usb_serial_port *port;
362 struct keyspan_port_private *p_priv;
365 p_priv = usb_get_serial_port_data(port);
367 if (p_priv->resend_cont) {
368 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
369 keyspan_usa26_send_setup(port->serial, port,
370 p_priv->resend_cont - 1);
374 static void usa26_instat_callback(struct urb *urb)
376 unsigned char *data = urb->transfer_buffer;
377 struct keyspan_usa26_portStatusMessage *msg;
378 struct usb_serial *serial;
379 struct usb_serial_port *port;
380 struct keyspan_port_private *p_priv;
381 int old_dcd_state, err;
382 int status = urb->status;
384 serial = urb->context;
387 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
390 if (urb->actual_length != 9) {
391 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
395 msg = (struct keyspan_usa26_portStatusMessage *)data;
398 dev_dbg(&urb->dev->dev,
399 "%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
400 __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr,
401 msg->ri, msg->_txOff, msg->_txXoff, msg->rxEnabled,
402 msg->controlResponse);
405 /* Now do something useful with the data */
408 /* Check port number from message and retrieve private data */
409 if (msg->port >= serial->num_ports) {
410 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
413 port = serial->port[msg->port];
414 p_priv = usb_get_serial_port_data(port);
416 /* Update handshaking pin state information */
417 old_dcd_state = p_priv->dcd_state;
418 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
419 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
420 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
421 p_priv->ri_state = ((msg->ri) ? 1 : 0);
423 if (old_dcd_state != p_priv->dcd_state)
424 tty_port_tty_hangup(&port->port, true);
426 /* Resubmit urb so we continue receiving */
427 err = usb_submit_urb(urb, GFP_ATOMIC);
429 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
433 static void usa26_glocont_callback(struct urb *urb)
438 static void usa28_indat_callback(struct urb *urb)
441 struct usb_serial_port *port;
443 struct keyspan_port_private *p_priv;
444 int status = urb->status;
447 p_priv = usb_get_serial_port_data(port);
448 data = urb->transfer_buffer;
450 if (urb != p_priv->in_urbs[p_priv->in_flip])
455 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
456 __func__, status, usb_pipeendpoint(urb->pipe));
461 p_priv = usb_get_serial_port_data(port);
462 data = urb->transfer_buffer;
464 if (urb->actual_length) {
465 tty_insert_flip_string(&port->port, data,
467 tty_flip_buffer_push(&port->port);
470 /* Resubmit urb so we continue receiving */
471 err = usb_submit_urb(urb, GFP_ATOMIC);
473 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
475 p_priv->in_flip ^= 1;
477 urb = p_priv->in_urbs[p_priv->in_flip];
478 } while (urb->status != -EINPROGRESS);
481 static void usa28_inack_callback(struct urb *urb)
485 static void usa28_outcont_callback(struct urb *urb)
487 struct usb_serial_port *port;
488 struct keyspan_port_private *p_priv;
491 p_priv = usb_get_serial_port_data(port);
493 if (p_priv->resend_cont) {
494 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
495 keyspan_usa28_send_setup(port->serial, port,
496 p_priv->resend_cont - 1);
500 static void usa28_instat_callback(struct urb *urb)
503 unsigned char *data = urb->transfer_buffer;
504 struct keyspan_usa28_portStatusMessage *msg;
505 struct usb_serial *serial;
506 struct usb_serial_port *port;
507 struct keyspan_port_private *p_priv;
509 int status = urb->status;
511 serial = urb->context;
514 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
518 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
519 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
524 dev_dbg(&urb->dev->dev,
525 "%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__,
526 data[0], data[1], data[2], data[3], data[4], data[5],
527 data[6], data[7], data[8], data[9], data[10], data[11]);
530 /* Now do something useful with the data */
531 msg = (struct keyspan_usa28_portStatusMessage *)data;
533 /* Check port number from message and retrieve private data */
534 if (msg->port >= serial->num_ports) {
535 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
538 port = serial->port[msg->port];
539 p_priv = usb_get_serial_port_data(port);
541 /* Update handshaking pin state information */
542 old_dcd_state = p_priv->dcd_state;
543 p_priv->cts_state = ((msg->cts) ? 1 : 0);
544 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
545 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
546 p_priv->ri_state = ((msg->ri) ? 1 : 0);
548 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
549 tty_port_tty_hangup(&port->port, true);
551 /* Resubmit urb so we continue receiving */
552 err = usb_submit_urb(urb, GFP_ATOMIC);
554 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
558 static void usa28_glocont_callback(struct urb *urb)
563 static void usa49_glocont_callback(struct urb *urb)
565 struct usb_serial *serial;
566 struct usb_serial_port *port;
567 struct keyspan_port_private *p_priv;
570 serial = urb->context;
571 for (i = 0; i < serial->num_ports; ++i) {
572 port = serial->port[i];
573 p_priv = usb_get_serial_port_data(port);
575 if (p_priv->resend_cont) {
576 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
577 keyspan_usa49_send_setup(serial, port,
578 p_priv->resend_cont - 1);
584 /* This is actually called glostat in the Keyspan
586 static void usa49_instat_callback(struct urb *urb)
589 unsigned char *data = urb->transfer_buffer;
590 struct keyspan_usa49_portStatusMessage *msg;
591 struct usb_serial *serial;
592 struct usb_serial_port *port;
593 struct keyspan_port_private *p_priv;
595 int status = urb->status;
597 serial = urb->context;
600 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
604 if (urb->actual_length !=
605 sizeof(struct keyspan_usa49_portStatusMessage)) {
606 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
611 dev_dbg(&urb->dev->dev, "%s: %x %x %x %x %x %x %x %x %x %x %x",
612 __func__, data[0], data[1], data[2], data[3], data[4],
613 data[5], data[6], data[7], data[8], data[9], data[10]);
616 /* Now do something useful with the data */
617 msg = (struct keyspan_usa49_portStatusMessage *)data;
619 /* Check port number from message and retrieve private data */
620 if (msg->portNumber >= serial->num_ports) {
621 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
622 __func__, msg->portNumber);
625 port = serial->port[msg->portNumber];
626 p_priv = usb_get_serial_port_data(port);
628 /* Update handshaking pin state information */
629 old_dcd_state = p_priv->dcd_state;
630 p_priv->cts_state = ((msg->cts) ? 1 : 0);
631 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
632 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
633 p_priv->ri_state = ((msg->ri) ? 1 : 0);
635 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
636 tty_port_tty_hangup(&port->port, true);
638 /* Resubmit urb so we continue receiving */
639 err = usb_submit_urb(urb, GFP_ATOMIC);
641 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
645 static void usa49_inack_callback(struct urb *urb)
649 static void usa49_indat_callback(struct urb *urb)
653 struct usb_serial_port *port;
654 unsigned char *data = urb->transfer_buffer;
655 int status = urb->status;
657 endpoint = usb_pipeendpoint(urb->pipe);
660 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
661 __func__, status, endpoint);
666 if (urb->actual_length) {
667 /* 0x80 bit is error flag */
668 if ((data[0] & 0x80) == 0) {
669 /* no error on any byte */
670 tty_insert_flip_string(&port->port, data + 1,
671 urb->actual_length - 1);
673 /* some bytes had errors, every byte has status */
674 for (i = 0; i + 1 < urb->actual_length; i += 2) {
675 int stat = data[i], flag = 0;
676 if (stat & RXERROR_OVERRUN)
678 if (stat & RXERROR_FRAMING)
680 if (stat & RXERROR_PARITY)
682 /* XXX should handle break (0x10) */
683 tty_insert_flip_char(&port->port, data[i+1],
687 tty_flip_buffer_push(&port->port);
690 /* Resubmit urb so we continue receiving */
691 err = usb_submit_urb(urb, GFP_ATOMIC);
693 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
696 static void usa49wg_indat_callback(struct urb *urb)
699 struct usb_serial *serial;
700 struct usb_serial_port *port;
701 unsigned char *data = urb->transfer_buffer;
702 int status = urb->status;
704 serial = urb->context;
707 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
711 /* inbound data is in the form P#, len, status, data */
715 while (i < urb->actual_length) {
717 /* Check port number from message */
718 if (data[i] >= serial->num_ports) {
719 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
723 port = serial->port[data[i++]];
726 /* 0x80 bit is error flag */
727 if ((data[i] & 0x80) == 0) {
728 /* no error on any byte */
730 for (x = 1; x < len && i < urb->actual_length; ++x)
731 tty_insert_flip_char(&port->port,
735 * some bytes had errors, every byte has status
737 for (x = 0; x + 1 < len &&
738 i + 1 < urb->actual_length; x += 2) {
739 int stat = data[i], flag = 0;
741 if (stat & RXERROR_OVERRUN)
743 if (stat & RXERROR_FRAMING)
745 if (stat & RXERROR_PARITY)
747 /* XXX should handle break (0x10) */
748 tty_insert_flip_char(&port->port, data[i+1],
753 tty_flip_buffer_push(&port->port);
756 /* Resubmit urb so we continue receiving */
757 err = usb_submit_urb(urb, GFP_ATOMIC);
759 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
762 /* not used, usa-49 doesn't have per-port control endpoints */
763 static void usa49_outcont_callback(struct urb *urb)
767 static void usa90_indat_callback(struct urb *urb)
771 struct usb_serial_port *port;
772 struct keyspan_port_private *p_priv;
773 unsigned char *data = urb->transfer_buffer;
774 int status = urb->status;
776 endpoint = usb_pipeendpoint(urb->pipe);
779 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
780 __func__, status, endpoint);
785 p_priv = usb_get_serial_port_data(port);
787 if (urb->actual_length) {
788 /* if current mode is DMA, looks like usa28 format
789 otherwise looks like usa26 data format */
791 if (p_priv->baud > 57600)
792 tty_insert_flip_string(&port->port, data,
795 /* 0x80 bit is error flag */
796 if ((data[0] & 0x80) == 0) {
797 /* no errors on individual bytes, only
798 possible overrun err*/
799 if (data[0] & RXERROR_OVERRUN)
803 for (i = 1; i < urb->actual_length ; ++i)
804 tty_insert_flip_char(&port->port,
807 /* some bytes had errors, every byte has status */
808 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
809 for (i = 0; i + 1 < urb->actual_length; i += 2) {
810 int stat = data[i], flag = 0;
811 if (stat & RXERROR_OVERRUN)
813 if (stat & RXERROR_FRAMING)
815 if (stat & RXERROR_PARITY)
817 /* XXX should handle break (0x10) */
818 tty_insert_flip_char(&port->port,
823 tty_flip_buffer_push(&port->port);
826 /* Resubmit urb so we continue receiving */
827 err = usb_submit_urb(urb, GFP_ATOMIC);
829 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
833 static void usa90_instat_callback(struct urb *urb)
835 unsigned char *data = urb->transfer_buffer;
836 struct keyspan_usa90_portStatusMessage *msg;
837 struct usb_serial *serial;
838 struct usb_serial_port *port;
839 struct keyspan_port_private *p_priv;
840 int old_dcd_state, err;
841 int status = urb->status;
843 serial = urb->context;
846 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
849 if (urb->actual_length < 14) {
850 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
854 msg = (struct keyspan_usa90_portStatusMessage *)data;
856 /* Now do something useful with the data */
858 port = serial->port[0];
859 p_priv = usb_get_serial_port_data(port);
861 /* Update handshaking pin state information */
862 old_dcd_state = p_priv->dcd_state;
863 p_priv->cts_state = ((msg->cts) ? 1 : 0);
864 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
865 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
866 p_priv->ri_state = ((msg->ri) ? 1 : 0);
868 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
869 tty_port_tty_hangup(&port->port, true);
871 /* Resubmit urb so we continue receiving */
872 err = usb_submit_urb(urb, GFP_ATOMIC);
874 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
879 static void usa90_outcont_callback(struct urb *urb)
881 struct usb_serial_port *port;
882 struct keyspan_port_private *p_priv;
885 p_priv = usb_get_serial_port_data(port);
887 if (p_priv->resend_cont) {
888 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
889 keyspan_usa90_send_setup(port->serial, port,
890 p_priv->resend_cont - 1);
894 /* Status messages from the 28xg */
895 static void usa67_instat_callback(struct urb *urb)
898 unsigned char *data = urb->transfer_buffer;
899 struct keyspan_usa67_portStatusMessage *msg;
900 struct usb_serial *serial;
901 struct usb_serial_port *port;
902 struct keyspan_port_private *p_priv;
904 int status = urb->status;
906 serial = urb->context;
909 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
913 if (urb->actual_length !=
914 sizeof(struct keyspan_usa67_portStatusMessage)) {
915 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
920 /* Now do something useful with the data */
921 msg = (struct keyspan_usa67_portStatusMessage *)data;
923 /* Check port number from message and retrieve private data */
924 if (msg->port >= serial->num_ports) {
925 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
929 port = serial->port[msg->port];
930 p_priv = usb_get_serial_port_data(port);
932 /* Update handshaking pin state information */
933 old_dcd_state = p_priv->dcd_state;
934 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
935 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
937 if (old_dcd_state != p_priv->dcd_state && old_dcd_state)
938 tty_port_tty_hangup(&port->port, true);
940 /* Resubmit urb so we continue receiving */
941 err = usb_submit_urb(urb, GFP_ATOMIC);
943 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
946 static void usa67_glocont_callback(struct urb *urb)
948 struct usb_serial *serial;
949 struct usb_serial_port *port;
950 struct keyspan_port_private *p_priv;
953 serial = urb->context;
954 for (i = 0; i < serial->num_ports; ++i) {
955 port = serial->port[i];
956 p_priv = usb_get_serial_port_data(port);
958 if (p_priv->resend_cont) {
959 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
960 keyspan_usa67_send_setup(serial, port,
961 p_priv->resend_cont - 1);
967 static int keyspan_write_room(struct tty_struct *tty)
969 struct usb_serial_port *port = tty->driver_data;
970 struct keyspan_port_private *p_priv;
971 const struct keyspan_device_details *d_details;
974 struct urb *this_urb;
976 p_priv = usb_get_serial_port_data(port);
977 d_details = p_priv->device_details;
980 if (d_details->msg_format == msg_usa90)
985 flip = p_priv->out_flip;
987 /* Check both endpoints to see if any are available. */
988 this_urb = p_priv->out_urbs[flip];
989 if (this_urb != NULL) {
990 if (this_urb->status != -EINPROGRESS)
992 flip = (flip + 1) & d_details->outdat_endp_flip;
993 this_urb = p_priv->out_urbs[flip];
994 if (this_urb != NULL) {
995 if (this_urb->status != -EINPROGRESS)
1003 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1005 struct keyspan_port_private *p_priv;
1006 const struct keyspan_device_details *d_details;
1008 int baud_rate, device_port;
1010 unsigned int cflag = 0;
1012 p_priv = usb_get_serial_port_data(port);
1013 d_details = p_priv->device_details;
1015 /* Set some sane defaults */
1016 p_priv->rts_state = 1;
1017 p_priv->dtr_state = 1;
1018 p_priv->baud = 9600;
1020 /* force baud and lcr to be set on open */
1021 p_priv->old_baud = 0;
1022 p_priv->old_cflag = 0;
1024 p_priv->out_flip = 0;
1025 p_priv->in_flip = 0;
1027 /* Reset low level data toggle and start reading from endpoints */
1028 for (i = 0; i < 2; i++) {
1029 urb = p_priv->in_urbs[i];
1033 /* make sure endpoint data toggle is synchronized
1035 usb_clear_halt(urb->dev, urb->pipe);
1036 err = usb_submit_urb(urb, GFP_KERNEL);
1038 dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1041 /* Reset low level data toggle on out endpoints */
1042 for (i = 0; i < 2; i++) {
1043 urb = p_priv->out_urbs[i];
1046 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1047 usb_pipeout(urb->pipe), 0); */
1050 /* get the terminal config for the setup message now so we don't
1051 * need to send 2 of them */
1053 device_port = port->number - port->serial->minor;
1055 cflag = tty->termios.c_cflag;
1056 /* Baud rate calculation takes baud rate as an integer
1057 so other rates can be generated if desired. */
1058 baud_rate = tty_get_baud_rate(tty);
1059 /* If no match or invalid, leave as default */
1061 && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1062 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1063 p_priv->baud = baud_rate;
1066 /* set CTS/RTS handshake etc. */
1067 p_priv->cflag = cflag;
1068 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1070 keyspan_send_setup(port, 1);
1072 /* keyspan_set_termios(port, NULL); */
1077 static inline void stop_urb(struct urb *urb)
1079 if (urb && urb->status == -EINPROGRESS)
1083 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1085 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1087 p_priv->rts_state = on;
1088 p_priv->dtr_state = on;
1089 keyspan_send_setup(port, 0);
1092 static void keyspan_close(struct usb_serial_port *port)
1095 struct keyspan_port_private *p_priv;
1097 p_priv = usb_get_serial_port_data(port);
1099 p_priv->rts_state = 0;
1100 p_priv->dtr_state = 0;
1102 keyspan_send_setup(port, 2);
1103 /* pilot-xfer seems to work best with this delay */
1106 p_priv->out_flip = 0;
1107 p_priv->in_flip = 0;
1109 stop_urb(p_priv->inack_urb);
1110 for (i = 0; i < 2; i++) {
1111 stop_urb(p_priv->in_urbs[i]);
1112 stop_urb(p_priv->out_urbs[i]);
1116 /* download the firmware to a pre-renumeration device */
1117 static int keyspan_fake_startup(struct usb_serial *serial)
1121 dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1122 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1123 le16_to_cpu(serial->dev->descriptor.idProduct));
1125 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1127 dev_dbg(&serial->dev->dev, "Firmware already loaded. Quitting.\n");
1131 /* Select firmware image on the basis of idProduct */
1132 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1133 case keyspan_usa28_pre_product_id:
1134 fw_name = "keyspan/usa28.fw";
1137 case keyspan_usa28x_pre_product_id:
1138 fw_name = "keyspan/usa28x.fw";
1141 case keyspan_usa28xa_pre_product_id:
1142 fw_name = "keyspan/usa28xa.fw";
1145 case keyspan_usa28xb_pre_product_id:
1146 fw_name = "keyspan/usa28xb.fw";
1149 case keyspan_usa19_pre_product_id:
1150 fw_name = "keyspan/usa19.fw";
1153 case keyspan_usa19qi_pre_product_id:
1154 fw_name = "keyspan/usa19qi.fw";
1157 case keyspan_mpr_pre_product_id:
1158 fw_name = "keyspan/mpr.fw";
1161 case keyspan_usa19qw_pre_product_id:
1162 fw_name = "keyspan/usa19qw.fw";
1165 case keyspan_usa18x_pre_product_id:
1166 fw_name = "keyspan/usa18x.fw";
1169 case keyspan_usa19w_pre_product_id:
1170 fw_name = "keyspan/usa19w.fw";
1173 case keyspan_usa49w_pre_product_id:
1174 fw_name = "keyspan/usa49w.fw";
1177 case keyspan_usa49wlc_pre_product_id:
1178 fw_name = "keyspan/usa49wlc.fw";
1182 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1183 le16_to_cpu(serial->dev->descriptor.idProduct));
1187 dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1189 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1190 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1195 /* after downloading firmware Renumeration will occur in a
1196 moment and the new device will bind to the real driver */
1198 /* we don't want this device to have a driver assigned to it. */
1202 /* Helper functions used by keyspan_setup_urbs */
1203 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1206 struct usb_host_interface *iface_desc;
1207 struct usb_endpoint_descriptor *ep;
1210 iface_desc = serial->interface->cur_altsetting;
1211 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1212 ep = &iface_desc->endpoint[i].desc;
1213 if (ep->bEndpointAddress == endpoint)
1216 dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1217 "endpoint %x\n", endpoint);
1221 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1222 int dir, void *ctx, char *buf, int len,
1223 void (*callback)(struct urb *))
1226 struct usb_endpoint_descriptor const *ep_desc;
1227 char const *ep_type_name;
1230 return NULL; /* endpoint not needed */
1232 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
1233 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1235 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d failed.\n", __func__, endpoint);
1239 if (endpoint == 0) {
1240 /* control EP filled in when used */
1244 ep_desc = find_ep(serial, endpoint);
1246 /* leak the urb, something's wrong and the callers don't care */
1249 if (usb_endpoint_xfer_int(ep_desc)) {
1250 ep_type_name = "INT";
1251 usb_fill_int_urb(urb, serial->dev,
1252 usb_sndintpipe(serial->dev, endpoint) | dir,
1253 buf, len, callback, ctx,
1254 ep_desc->bInterval);
1255 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1256 ep_type_name = "BULK";
1257 usb_fill_bulk_urb(urb, serial->dev,
1258 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1259 buf, len, callback, ctx);
1261 dev_warn(&serial->interface->dev,
1262 "unsupported endpoint type %x\n",
1263 usb_endpoint_type(ep_desc));
1268 dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1269 __func__, urb, ep_type_name, endpoint);
1273 static struct callbacks {
1274 void (*instat_callback)(struct urb *);
1275 void (*glocont_callback)(struct urb *);
1276 void (*indat_callback)(struct urb *);
1277 void (*outdat_callback)(struct urb *);
1278 void (*inack_callback)(struct urb *);
1279 void (*outcont_callback)(struct urb *);
1280 } keyspan_callbacks[] = {
1282 /* msg_usa26 callbacks */
1283 .instat_callback = usa26_instat_callback,
1284 .glocont_callback = usa26_glocont_callback,
1285 .indat_callback = usa26_indat_callback,
1286 .outdat_callback = usa2x_outdat_callback,
1287 .inack_callback = usa26_inack_callback,
1288 .outcont_callback = usa26_outcont_callback,
1290 /* msg_usa28 callbacks */
1291 .instat_callback = usa28_instat_callback,
1292 .glocont_callback = usa28_glocont_callback,
1293 .indat_callback = usa28_indat_callback,
1294 .outdat_callback = usa2x_outdat_callback,
1295 .inack_callback = usa28_inack_callback,
1296 .outcont_callback = usa28_outcont_callback,
1298 /* msg_usa49 callbacks */
1299 .instat_callback = usa49_instat_callback,
1300 .glocont_callback = usa49_glocont_callback,
1301 .indat_callback = usa49_indat_callback,
1302 .outdat_callback = usa2x_outdat_callback,
1303 .inack_callback = usa49_inack_callback,
1304 .outcont_callback = usa49_outcont_callback,
1306 /* msg_usa90 callbacks */
1307 .instat_callback = usa90_instat_callback,
1308 .glocont_callback = usa28_glocont_callback,
1309 .indat_callback = usa90_indat_callback,
1310 .outdat_callback = usa2x_outdat_callback,
1311 .inack_callback = usa28_inack_callback,
1312 .outcont_callback = usa90_outcont_callback,
1314 /* msg_usa67 callbacks */
1315 .instat_callback = usa67_instat_callback,
1316 .glocont_callback = usa67_glocont_callback,
1317 .indat_callback = usa26_indat_callback,
1318 .outdat_callback = usa2x_outdat_callback,
1319 .inack_callback = usa26_inack_callback,
1320 .outcont_callback = usa26_outcont_callback,
1324 /* Generic setup urbs function that uses
1325 data in device_details */
1326 static void keyspan_setup_urbs(struct usb_serial *serial)
1328 struct keyspan_serial_private *s_priv;
1329 const struct keyspan_device_details *d_details;
1330 struct callbacks *cback;
1332 s_priv = usb_get_serial_data(serial);
1333 d_details = s_priv->device_details;
1335 /* Setup values for the various callback routines */
1336 cback = &keyspan_callbacks[d_details->msg_format];
1338 /* Allocate and set up urbs for each one that is in use,
1339 starting with instat endpoints */
1340 s_priv->instat_urb = keyspan_setup_urb
1341 (serial, d_details->instat_endpoint, USB_DIR_IN,
1342 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1343 cback->instat_callback);
1345 s_priv->indat_urb = keyspan_setup_urb
1346 (serial, d_details->indat_endpoint, USB_DIR_IN,
1347 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1348 usa49wg_indat_callback);
1350 s_priv->glocont_urb = keyspan_setup_urb
1351 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1352 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1353 cback->glocont_callback);
1356 /* usa19 function doesn't require prescaler */
1357 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1358 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1359 u8 *rate_low, u8 *prescaler, int portnum)
1361 u32 b16, /* baud rate times 16 (actual rate used internally) */
1363 cnt; /* inverse of divisor (programmed into 8051) */
1365 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1367 /* prevent divide by zero... */
1368 b16 = baud_rate * 16L;
1370 return KEYSPAN_INVALID_BAUD_RATE;
1371 /* Any "standard" rate over 57k6 is marginal on the USA-19
1372 as we run out of divisor resolution. */
1373 if (baud_rate > 57600)
1374 return KEYSPAN_INVALID_BAUD_RATE;
1376 /* calculate the divisor and the counter (its inverse) */
1377 div = baudclk / b16;
1379 return KEYSPAN_INVALID_BAUD_RATE;
1384 return KEYSPAN_INVALID_BAUD_RATE;
1386 /* return the counter values if non-null */
1388 *rate_low = (u8) (cnt & 0xff);
1390 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1391 if (rate_low && rate_hi)
1392 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1393 __func__, baud_rate, *rate_hi, *rate_low);
1394 return KEYSPAN_BAUD_RATE_OK;
1397 /* usa19hs function doesn't require prescaler */
1398 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1399 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1400 u8 *rate_low, u8 *prescaler, int portnum)
1402 u32 b16, /* baud rate times 16 (actual rate used internally) */
1405 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1407 /* prevent divide by zero... */
1408 b16 = baud_rate * 16L;
1410 return KEYSPAN_INVALID_BAUD_RATE;
1412 /* calculate the divisor */
1413 div = baudclk / b16;
1415 return KEYSPAN_INVALID_BAUD_RATE;
1418 return KEYSPAN_INVALID_BAUD_RATE;
1420 /* return the counter values if non-null */
1422 *rate_low = (u8) (div & 0xff);
1425 *rate_hi = (u8) ((div >> 8) & 0xff);
1427 if (rate_low && rate_hi)
1428 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1429 __func__, baud_rate, *rate_hi, *rate_low);
1431 return KEYSPAN_BAUD_RATE_OK;
1434 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1435 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1436 u8 *rate_low, u8 *prescaler, int portnum)
1438 u32 b16, /* baud rate times 16 (actual rate used internally) */
1439 clk, /* clock with 13/8 prescaler */
1440 div, /* divisor using 13/8 prescaler */
1441 res, /* resulting baud rate using 13/8 prescaler */
1442 diff, /* error using 13/8 prescaler */
1447 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1449 /* prevent divide by zero */
1450 b16 = baud_rate * 16L;
1452 return KEYSPAN_INVALID_BAUD_RATE;
1454 /* Calculate prescaler by trying them all and looking
1457 /* start with largest possible difference */
1458 smallest_diff = 0xffffffff;
1460 /* 0 is an invalid prescaler, used as a flag */
1463 for (i = 8; i <= 0xff; ++i) {
1464 clk = (baudclk * 8) / (u32) i;
1471 diff = (res > b16) ? (res-b16) : (b16-res);
1473 if (diff < smallest_diff) {
1475 smallest_diff = diff;
1479 if (best_prescaler == 0)
1480 return KEYSPAN_INVALID_BAUD_RATE;
1482 clk = (baudclk * 8) / (u32) best_prescaler;
1485 /* return the divisor and prescaler if non-null */
1487 *rate_low = (u8) (div & 0xff);
1489 *rate_hi = (u8) ((div >> 8) & 0xff);
1491 *prescaler = best_prescaler;
1492 /* dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1494 return KEYSPAN_BAUD_RATE_OK;
1497 /* USA-28 supports different maximum baud rates on each port */
1498 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1499 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1500 u8 *rate_low, u8 *prescaler, int portnum)
1502 u32 b16, /* baud rate times 16 (actual rate used internally) */
1504 cnt; /* inverse of divisor (programmed into 8051) */
1506 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1508 /* prevent divide by zero */
1509 b16 = baud_rate * 16L;
1511 return KEYSPAN_INVALID_BAUD_RATE;
1513 /* calculate the divisor and the counter (its inverse) */
1514 div = KEYSPAN_USA28_BAUDCLK / b16;
1516 return KEYSPAN_INVALID_BAUD_RATE;
1520 /* check for out of range, based on portnum,
1521 and return result */
1524 return KEYSPAN_INVALID_BAUD_RATE;
1528 return KEYSPAN_INVALID_BAUD_RATE;
1530 return KEYSPAN_INVALID_BAUD_RATE;
1533 /* return the counter values if not NULL
1534 (port 1 will ignore retHi) */
1536 *rate_low = (u8) (cnt & 0xff);
1538 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1539 dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
1540 return KEYSPAN_BAUD_RATE_OK;
1543 static int keyspan_usa26_send_setup(struct usb_serial *serial,
1544 struct usb_serial_port *port,
1547 struct keyspan_usa26_portControlMessage msg;
1548 struct keyspan_serial_private *s_priv;
1549 struct keyspan_port_private *p_priv;
1550 const struct keyspan_device_details *d_details;
1551 struct urb *this_urb;
1552 int device_port, err;
1554 dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
1556 s_priv = usb_get_serial_data(serial);
1557 p_priv = usb_get_serial_port_data(port);
1558 d_details = s_priv->device_details;
1559 device_port = port->number - port->serial->minor;
1561 this_urb = p_priv->outcont_urb;
1563 dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
1565 /* Make sure we have an urb then send the message */
1566 if (this_urb == NULL) {
1567 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1571 /* Save reset port val for resend.
1572 Don't overwrite resend for open/close condition. */
1573 if ((reset_port + 1) > p_priv->resend_cont)
1574 p_priv->resend_cont = reset_port + 1;
1575 if (this_urb->status == -EINPROGRESS) {
1576 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1581 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
1583 /* Only set baud rate if it's changed */
1584 if (p_priv->old_baud != p_priv->baud) {
1585 p_priv->old_baud = p_priv->baud;
1586 msg.setClocking = 0xff;
1587 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1588 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1589 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1590 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1591 __func__, p_priv->baud);
1593 msg.baudHi = 125; /* Values for 9600 baud */
1596 msg.setPrescaler = 0xff;
1599 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1600 switch (p_priv->cflag & CSIZE) {
1602 msg.lcr |= USA_DATABITS_5;
1605 msg.lcr |= USA_DATABITS_6;
1608 msg.lcr |= USA_DATABITS_7;
1611 msg.lcr |= USA_DATABITS_8;
1614 if (p_priv->cflag & PARENB) {
1615 /* note USA_PARITY_NONE == 0 */
1616 msg.lcr |= (p_priv->cflag & PARODD) ?
1617 USA_PARITY_ODD : USA_PARITY_EVEN;
1621 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1622 msg.xonFlowControl = 0;
1623 msg.setFlowControl = 0xff;
1624 msg.forwardingLength = 16;
1629 if (reset_port == 1) {
1638 msg.returnStatus = 0;
1639 msg.resetDataToggle = 0xff;
1643 else if (reset_port == 2) {
1652 msg.returnStatus = 0;
1653 msg.resetDataToggle = 0;
1656 /* Sending intermediate configs */
1658 msg._txOn = (!p_priv->break_on);
1661 msg.txBreak = (p_priv->break_on);
1666 msg.returnStatus = 0;
1667 msg.resetDataToggle = 0x0;
1670 /* Do handshaking outputs */
1671 msg.setTxTriState_setRts = 0xff;
1672 msg.txTriState_rts = p_priv->rts_state;
1674 msg.setHskoa_setDtr = 0xff;
1675 msg.hskoa_dtr = p_priv->dtr_state;
1677 p_priv->resend_cont = 0;
1678 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1680 /* send the data out the device on control endpoint */
1681 this_urb->transfer_buffer_length = sizeof(msg);
1683 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1685 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1689 static int keyspan_usa28_send_setup(struct usb_serial *serial,
1690 struct usb_serial_port *port,
1693 struct keyspan_usa28_portControlMessage msg;
1694 struct keyspan_serial_private *s_priv;
1695 struct keyspan_port_private *p_priv;
1696 const struct keyspan_device_details *d_details;
1697 struct urb *this_urb;
1698 int device_port, err;
1700 s_priv = usb_get_serial_data(serial);
1701 p_priv = usb_get_serial_port_data(port);
1702 d_details = s_priv->device_details;
1703 device_port = port->number - port->serial->minor;
1705 /* only do something if we have a bulk out endpoint */
1706 this_urb = p_priv->outcont_urb;
1707 if (this_urb == NULL) {
1708 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1712 /* Save reset port val for resend.
1713 Don't overwrite resend for open/close condition. */
1714 if ((reset_port + 1) > p_priv->resend_cont)
1715 p_priv->resend_cont = reset_port + 1;
1716 if (this_urb->status == -EINPROGRESS) {
1717 dev_dbg(&port->dev, "%s already writing\n", __func__);
1722 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
1724 msg.setBaudRate = 1;
1725 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1726 &msg.baudHi, &msg.baudLo, NULL,
1727 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1728 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
1729 __func__, p_priv->baud);
1731 msg.baudHi = 0xb2; /* Values for 9600 baud */
1734 /* If parity is enabled, we must calculate it ourselves. */
1735 msg.parity = 0; /* XXX for now */
1737 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1738 msg.xonFlowControl = 0;
1740 /* Do handshaking outputs, DTR is inverted relative to RTS */
1741 msg.rts = p_priv->rts_state;
1742 msg.dtr = p_priv->dtr_state;
1744 msg.forwardingLength = 16;
1746 msg.breakThreshold = 45;
1750 /*msg.returnStatus = 1;
1751 msg.resetDataToggle = 0xff;*/
1753 if (reset_port == 1) {
1757 msg.txForceXoff = 0;
1763 msg.returnStatus = 0;
1764 msg.resetDataToggle = 0xff;
1767 else if (reset_port == 2) {
1771 msg.txForceXoff = 0;
1777 msg.returnStatus = 0;
1778 msg.resetDataToggle = 0;
1780 /* Sending intermediate configs */
1782 msg._txOn = (!p_priv->break_on);
1785 msg.txForceXoff = 0;
1786 msg.txBreak = (p_priv->break_on);
1791 msg.returnStatus = 0;
1792 msg.resetDataToggle = 0x0;
1795 p_priv->resend_cont = 0;
1796 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1798 /* send the data out the device on control endpoint */
1799 this_urb->transfer_buffer_length = sizeof(msg);
1801 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1803 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
1806 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) OK %d bytes\n", __func__,
1807 this_urb->transfer_buffer_length);
1814 static int keyspan_usa49_send_setup(struct usb_serial *serial,
1815 struct usb_serial_port *port,
1818 struct keyspan_usa49_portControlMessage msg;
1819 struct usb_ctrlrequest *dr = NULL;
1820 struct keyspan_serial_private *s_priv;
1821 struct keyspan_port_private *p_priv;
1822 const struct keyspan_device_details *d_details;
1823 struct urb *this_urb;
1824 int err, device_port;
1826 s_priv = usb_get_serial_data(serial);
1827 p_priv = usb_get_serial_port_data(port);
1828 d_details = s_priv->device_details;
1830 this_urb = s_priv->glocont_urb;
1832 /* Work out which port within the device is being setup */
1833 device_port = port->number - port->serial->minor;
1835 /* Make sure we have an urb then send the message */
1836 if (this_urb == NULL) {
1837 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__, port->number);
1841 dev_dbg(&port->dev, "%s - endpoint %d port %d (%d)\n",
1842 __func__, usb_pipeendpoint(this_urb->pipe),
1843 port->number, device_port);
1845 /* Save reset port val for resend.
1846 Don't overwrite resend for open/close condition. */
1847 if ((reset_port + 1) > p_priv->resend_cont)
1848 p_priv->resend_cont = reset_port + 1;
1850 if (this_urb->status == -EINPROGRESS) {
1851 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1856 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
1858 /*msg.portNumber = port->number;*/
1859 msg.portNumber = device_port;
1861 /* Only set baud rate if it's changed */
1862 if (p_priv->old_baud != p_priv->baud) {
1863 p_priv->old_baud = p_priv->baud;
1864 msg.setClocking = 0xff;
1865 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1866 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1867 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1868 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1869 __func__, p_priv->baud);
1871 msg.baudHi = 125; /* Values for 9600 baud */
1874 /* msg.setPrescaler = 0xff; */
1877 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1878 switch (p_priv->cflag & CSIZE) {
1880 msg.lcr |= USA_DATABITS_5;
1883 msg.lcr |= USA_DATABITS_6;
1886 msg.lcr |= USA_DATABITS_7;
1889 msg.lcr |= USA_DATABITS_8;
1892 if (p_priv->cflag & PARENB) {
1893 /* note USA_PARITY_NONE == 0 */
1894 msg.lcr |= (p_priv->cflag & PARODD) ?
1895 USA_PARITY_ODD : USA_PARITY_EVEN;
1899 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1900 msg.xonFlowControl = 0;
1901 msg.setFlowControl = 0xff;
1903 msg.forwardingLength = 16;
1908 if (reset_port == 1) {
1917 msg.returnStatus = 0;
1918 msg.resetDataToggle = 0xff;
1920 msg.disablePort = 0;
1923 else if (reset_port == 2) {
1932 msg.returnStatus = 0;
1933 msg.resetDataToggle = 0;
1935 msg.disablePort = 1;
1937 /* Sending intermediate configs */
1939 msg._txOn = (!p_priv->break_on);
1942 msg.txBreak = (p_priv->break_on);
1947 msg.returnStatus = 0;
1948 msg.resetDataToggle = 0x0;
1950 msg.disablePort = 0;
1953 /* Do handshaking outputs */
1955 msg.rts = p_priv->rts_state;
1958 msg.dtr = p_priv->dtr_state;
1960 p_priv->resend_cont = 0;
1962 /* if the device is a 49wg, we send control message on usb
1965 if (d_details->product_id == keyspan_usa49wg_product_id) {
1966 dr = (void *)(s_priv->ctrl_buf);
1967 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
1968 dr->bRequest = 0xB0; /* 49wg control message */;
1971 dr->wLength = cpu_to_le16(sizeof(msg));
1973 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
1975 usb_fill_control_urb(this_urb, serial->dev,
1976 usb_sndctrlpipe(serial->dev, 0),
1977 (unsigned char *)dr, s_priv->glocont_buf,
1978 sizeof(msg), usa49_glocont_callback, serial);
1981 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1983 /* send the data out the device on control endpoint */
1984 this_urb->transfer_buffer_length = sizeof(msg);
1986 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1988 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1991 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__,
1992 outcont_urb, this_urb->transfer_buffer_length,
1993 usb_pipeendpoint(this_urb->pipe));
2000 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2001 struct usb_serial_port *port,
2004 struct keyspan_usa90_portControlMessage msg;
2005 struct keyspan_serial_private *s_priv;
2006 struct keyspan_port_private *p_priv;
2007 const struct keyspan_device_details *d_details;
2008 struct urb *this_urb;
2012 s_priv = usb_get_serial_data(serial);
2013 p_priv = usb_get_serial_port_data(port);
2014 d_details = s_priv->device_details;
2016 /* only do something if we have a bulk out endpoint */
2017 this_urb = p_priv->outcont_urb;
2018 if (this_urb == NULL) {
2019 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2023 /* Save reset port val for resend.
2024 Don't overwrite resend for open/close condition. */
2025 if ((reset_port + 1) > p_priv->resend_cont)
2026 p_priv->resend_cont = reset_port + 1;
2027 if (this_urb->status == -EINPROGRESS) {
2028 dev_dbg(&port->dev, "%s already writing\n", __func__);
2033 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2035 /* Only set baud rate if it's changed */
2036 if (p_priv->old_baud != p_priv->baud) {
2037 p_priv->old_baud = p_priv->baud;
2038 msg.setClocking = 0x01;
2039 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2040 &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2041 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2042 __func__, p_priv->baud);
2043 p_priv->baud = 9600;
2044 d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2045 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2051 /* modes must always be correctly specified */
2052 if (p_priv->baud > 57600) {
2053 msg.rxMode = RXMODE_DMA;
2054 msg.txMode = TXMODE_DMA;
2056 msg.rxMode = RXMODE_BYHAND;
2057 msg.txMode = TXMODE_BYHAND;
2060 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2061 switch (p_priv->cflag & CSIZE) {
2063 msg.lcr |= USA_DATABITS_5;
2066 msg.lcr |= USA_DATABITS_6;
2069 msg.lcr |= USA_DATABITS_7;
2072 msg.lcr |= USA_DATABITS_8;
2075 if (p_priv->cflag & PARENB) {
2076 /* note USA_PARITY_NONE == 0 */
2077 msg.lcr |= (p_priv->cflag & PARODD) ?
2078 USA_PARITY_ODD : USA_PARITY_EVEN;
2080 if (p_priv->old_cflag != p_priv->cflag) {
2081 p_priv->old_cflag = p_priv->cflag;
2085 if (p_priv->flow_control == flow_cts)
2086 msg.txFlowControl = TXFLOW_CTS;
2087 msg.setTxFlowControl = 0x01;
2088 msg.setRxFlowControl = 0x01;
2090 msg.rxForwardingLength = 16;
2091 msg.rxForwardingTimeout = 16;
2092 msg.txAckSetting = 0;
2097 if (reset_port == 1) {
2098 msg.portEnabled = 1;
2100 msg.txBreak = (p_priv->break_on);
2103 else if (reset_port == 2)
2104 msg.portEnabled = 0;
2105 /* Sending intermediate configs */
2107 msg.portEnabled = 1;
2108 msg.txBreak = (p_priv->break_on);
2111 /* Do handshaking outputs */
2113 msg.rts = p_priv->rts_state;
2116 msg.dtr = p_priv->dtr_state;
2118 p_priv->resend_cont = 0;
2119 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2121 /* send the data out the device on control endpoint */
2122 this_urb->transfer_buffer_length = sizeof(msg);
2124 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2126 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2130 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2131 struct usb_serial_port *port,
2134 struct keyspan_usa67_portControlMessage msg;
2135 struct keyspan_serial_private *s_priv;
2136 struct keyspan_port_private *p_priv;
2137 const struct keyspan_device_details *d_details;
2138 struct urb *this_urb;
2139 int err, device_port;
2141 s_priv = usb_get_serial_data(serial);
2142 p_priv = usb_get_serial_port_data(port);
2143 d_details = s_priv->device_details;
2145 this_urb = s_priv->glocont_urb;
2147 /* Work out which port within the device is being setup */
2148 device_port = port->number - port->serial->minor;
2150 /* Make sure we have an urb then send the message */
2151 if (this_urb == NULL) {
2152 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__,
2157 /* Save reset port val for resend.
2158 Don't overwrite resend for open/close condition. */
2159 if ((reset_port + 1) > p_priv->resend_cont)
2160 p_priv->resend_cont = reset_port + 1;
2161 if (this_urb->status == -EINPROGRESS) {
2162 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2167 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2169 msg.port = device_port;
2171 /* Only set baud rate if it's changed */
2172 if (p_priv->old_baud != p_priv->baud) {
2173 p_priv->old_baud = p_priv->baud;
2174 msg.setClocking = 0xff;
2175 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2176 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2177 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2178 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2179 __func__, p_priv->baud);
2181 msg.baudHi = 125; /* Values for 9600 baud */
2184 msg.setPrescaler = 0xff;
2187 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2188 switch (p_priv->cflag & CSIZE) {
2190 msg.lcr |= USA_DATABITS_5;
2193 msg.lcr |= USA_DATABITS_6;
2196 msg.lcr |= USA_DATABITS_7;
2199 msg.lcr |= USA_DATABITS_8;
2202 if (p_priv->cflag & PARENB) {
2203 /* note USA_PARITY_NONE == 0 */
2204 msg.lcr |= (p_priv->cflag & PARODD) ?
2205 USA_PARITY_ODD : USA_PARITY_EVEN;
2209 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2210 msg.xonFlowControl = 0;
2211 msg.setFlowControl = 0xff;
2212 msg.forwardingLength = 16;
2216 if (reset_port == 1) {
2226 msg.returnStatus = 0;
2227 msg.resetDataToggle = 0xff;
2228 } else if (reset_port == 2) {
2238 msg.returnStatus = 0;
2239 msg.resetDataToggle = 0;
2241 /* Sending intermediate configs */
2242 msg._txOn = (!p_priv->break_on);
2245 msg.txBreak = (p_priv->break_on);
2250 msg.returnStatus = 0;
2251 msg.resetDataToggle = 0x0;
2254 /* Do handshaking outputs */
2255 msg.setTxTriState_setRts = 0xff;
2256 msg.txTriState_rts = p_priv->rts_state;
2258 msg.setHskoa_setDtr = 0xff;
2259 msg.hskoa_dtr = p_priv->dtr_state;
2261 p_priv->resend_cont = 0;
2263 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2265 /* send the data out the device on control endpoint */
2266 this_urb->transfer_buffer_length = sizeof(msg);
2268 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2270 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2274 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2276 struct usb_serial *serial = port->serial;
2277 struct keyspan_serial_private *s_priv;
2278 const struct keyspan_device_details *d_details;
2280 s_priv = usb_get_serial_data(serial);
2281 d_details = s_priv->device_details;
2283 switch (d_details->msg_format) {
2285 keyspan_usa26_send_setup(serial, port, reset_port);
2288 keyspan_usa28_send_setup(serial, port, reset_port);
2291 keyspan_usa49_send_setup(serial, port, reset_port);
2294 keyspan_usa90_send_setup(serial, port, reset_port);
2297 keyspan_usa67_send_setup(serial, port, reset_port);
2303 /* Gets called by the "real" driver (ie once firmware is loaded
2304 and renumeration has taken place. */
2305 static int keyspan_startup(struct usb_serial *serial)
2308 struct keyspan_serial_private *s_priv;
2309 const struct keyspan_device_details *d_details;
2311 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2312 if (d_details->product_id ==
2313 le16_to_cpu(serial->dev->descriptor.idProduct))
2315 if (d_details == NULL) {
2316 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2317 __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2321 /* Setup private data for serial driver */
2322 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2324 dev_dbg(&serial->dev->dev, "%s - kmalloc for keyspan_serial_private failed.\n", __func__);
2328 s_priv->device_details = d_details;
2329 usb_set_serial_data(serial, s_priv);
2331 keyspan_setup_urbs(serial);
2333 if (s_priv->instat_urb != NULL) {
2334 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2336 dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2338 if (s_priv->indat_urb != NULL) {
2339 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2341 dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2347 static void keyspan_disconnect(struct usb_serial *serial)
2349 struct keyspan_serial_private *s_priv;
2351 s_priv = usb_get_serial_data(serial);
2353 stop_urb(s_priv->instat_urb);
2354 stop_urb(s_priv->glocont_urb);
2355 stop_urb(s_priv->indat_urb);
2358 static void keyspan_release(struct usb_serial *serial)
2360 struct keyspan_serial_private *s_priv;
2362 s_priv = usb_get_serial_data(serial);
2364 usb_free_urb(s_priv->instat_urb);
2365 usb_free_urb(s_priv->indat_urb);
2366 usb_free_urb(s_priv->glocont_urb);
2371 static int keyspan_port_probe(struct usb_serial_port *port)
2373 struct usb_serial *serial = port->serial;
2374 struct keyspan_serial_private *s_priv;
2375 struct keyspan_port_private *p_priv;
2376 const struct keyspan_device_details *d_details;
2377 struct callbacks *cback;
2382 s_priv = usb_get_serial_data(serial);
2383 d_details = s_priv->device_details;
2385 p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2389 p_priv->device_details = d_details;
2391 /* Setup values for the various callback routines */
2392 cback = &keyspan_callbacks[d_details->msg_format];
2394 port_num = port->number - port->serial->minor;
2396 /* Do indat endpoints first, once for each flip */
2397 endp = d_details->indat_endpoints[port_num];
2398 for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2399 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2401 p_priv->in_buffer[i], 64,
2402 cback->indat_callback);
2404 /* outdat endpoints also have flip */
2405 endp = d_details->outdat_endpoints[port_num];
2406 for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2407 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2409 p_priv->out_buffer[i], 64,
2410 cback->outdat_callback);
2412 /* inack endpoint */
2413 p_priv->inack_urb = keyspan_setup_urb(serial,
2414 d_details->inack_endpoints[port_num],
2416 p_priv->inack_buffer, 1,
2417 cback->inack_callback);
2418 /* outcont endpoint */
2419 p_priv->outcont_urb = keyspan_setup_urb(serial,
2420 d_details->outcont_endpoints[port_num],
2422 p_priv->outcont_buffer, 64,
2423 cback->outcont_callback);
2425 usb_set_serial_port_data(port, p_priv);
2430 static int keyspan_port_remove(struct usb_serial_port *port)
2432 struct keyspan_port_private *p_priv;
2435 p_priv = usb_get_serial_port_data(port);
2437 stop_urb(p_priv->inack_urb);
2438 stop_urb(p_priv->outcont_urb);
2439 for (i = 0; i < 2; i++) {
2440 stop_urb(p_priv->in_urbs[i]);
2441 stop_urb(p_priv->out_urbs[i]);
2444 usb_free_urb(p_priv->inack_urb);
2445 usb_free_urb(p_priv->outcont_urb);
2446 for (i = 0; i < 2; i++) {
2447 usb_free_urb(p_priv->in_urbs[i]);
2448 usb_free_urb(p_priv->out_urbs[i]);
2456 MODULE_AUTHOR(DRIVER_AUTHOR);
2457 MODULE_DESCRIPTION(DRIVER_DESC);
2458 MODULE_LICENSE("GPL");
2460 MODULE_FIRMWARE("keyspan/usa28.fw");
2461 MODULE_FIRMWARE("keyspan/usa28x.fw");
2462 MODULE_FIRMWARE("keyspan/usa28xa.fw");
2463 MODULE_FIRMWARE("keyspan/usa28xb.fw");
2464 MODULE_FIRMWARE("keyspan/usa19.fw");
2465 MODULE_FIRMWARE("keyspan/usa19qi.fw");
2466 MODULE_FIRMWARE("keyspan/mpr.fw");
2467 MODULE_FIRMWARE("keyspan/usa19qw.fw");
2468 MODULE_FIRMWARE("keyspan/usa18x.fw");
2469 MODULE_FIRMWARE("keyspan/usa19w.fw");
2470 MODULE_FIRMWARE("keyspan/usa49w.fw");
2471 MODULE_FIRMWARE("keyspan/usa49wlc.fw");