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 struct tty_struct *tty;
382 int old_dcd_state, err;
383 int status = urb->status;
385 serial = urb->context;
388 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
391 if (urb->actual_length != 9) {
392 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
396 msg = (struct keyspan_usa26_portStatusMessage *)data;
399 dev_dbg(&urb->dev->dev,
400 "%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
401 __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr,
402 msg->ri, msg->_txOff, msg->_txXoff, msg->rxEnabled,
403 msg->controlResponse);
406 /* Now do something useful with the data */
409 /* Check port number from message and retrieve private data */
410 if (msg->port >= serial->num_ports) {
411 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
414 port = serial->port[msg->port];
415 p_priv = usb_get_serial_port_data(port);
417 /* Update handshaking pin state information */
418 old_dcd_state = p_priv->dcd_state;
419 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
420 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
421 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
422 p_priv->ri_state = ((msg->ri) ? 1 : 0);
424 if (old_dcd_state != p_priv->dcd_state) {
425 tty = tty_port_tty_get(&port->port);
426 if (tty && !C_CLOCAL(tty))
431 /* Resubmit urb so we continue receiving */
432 err = usb_submit_urb(urb, GFP_ATOMIC);
434 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
438 static void usa26_glocont_callback(struct urb *urb)
443 static void usa28_indat_callback(struct urb *urb)
446 struct usb_serial_port *port;
448 struct keyspan_port_private *p_priv;
449 int status = urb->status;
452 p_priv = usb_get_serial_port_data(port);
453 data = urb->transfer_buffer;
455 if (urb != p_priv->in_urbs[p_priv->in_flip])
460 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
461 __func__, status, usb_pipeendpoint(urb->pipe));
466 p_priv = usb_get_serial_port_data(port);
467 data = urb->transfer_buffer;
469 if (urb->actual_length) {
470 tty_insert_flip_string(&port->port, data,
472 tty_flip_buffer_push(&port->port);
475 /* Resubmit urb so we continue receiving */
476 err = usb_submit_urb(urb, GFP_ATOMIC);
478 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
480 p_priv->in_flip ^= 1;
482 urb = p_priv->in_urbs[p_priv->in_flip];
483 } while (urb->status != -EINPROGRESS);
486 static void usa28_inack_callback(struct urb *urb)
490 static void usa28_outcont_callback(struct urb *urb)
492 struct usb_serial_port *port;
493 struct keyspan_port_private *p_priv;
496 p_priv = usb_get_serial_port_data(port);
498 if (p_priv->resend_cont) {
499 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
500 keyspan_usa28_send_setup(port->serial, port,
501 p_priv->resend_cont - 1);
505 static void usa28_instat_callback(struct urb *urb)
508 unsigned char *data = urb->transfer_buffer;
509 struct keyspan_usa28_portStatusMessage *msg;
510 struct usb_serial *serial;
511 struct usb_serial_port *port;
512 struct keyspan_port_private *p_priv;
513 struct tty_struct *tty;
515 int status = urb->status;
517 serial = urb->context;
520 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
524 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
525 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
530 dev_dbg(&urb->dev->dev,
531 "%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__,
532 data[0], data[1], data[2], data[3], data[4], data[5],
533 data[6], data[7], data[8], data[9], data[10], data[11]);
536 /* Now do something useful with the data */
537 msg = (struct keyspan_usa28_portStatusMessage *)data;
539 /* Check port number from message and retrieve private data */
540 if (msg->port >= serial->num_ports) {
541 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
544 port = serial->port[msg->port];
545 p_priv = usb_get_serial_port_data(port);
547 /* Update handshaking pin state information */
548 old_dcd_state = p_priv->dcd_state;
549 p_priv->cts_state = ((msg->cts) ? 1 : 0);
550 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
551 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
552 p_priv->ri_state = ((msg->ri) ? 1 : 0);
554 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
555 tty = tty_port_tty_get(&port->port);
556 if (tty && !C_CLOCAL(tty))
561 /* Resubmit urb so we continue receiving */
562 err = usb_submit_urb(urb, GFP_ATOMIC);
564 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
568 static void usa28_glocont_callback(struct urb *urb)
573 static void usa49_glocont_callback(struct urb *urb)
575 struct usb_serial *serial;
576 struct usb_serial_port *port;
577 struct keyspan_port_private *p_priv;
580 serial = urb->context;
581 for (i = 0; i < serial->num_ports; ++i) {
582 port = serial->port[i];
583 p_priv = usb_get_serial_port_data(port);
585 if (p_priv->resend_cont) {
586 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
587 keyspan_usa49_send_setup(serial, port,
588 p_priv->resend_cont - 1);
594 /* This is actually called glostat in the Keyspan
596 static void usa49_instat_callback(struct urb *urb)
599 unsigned char *data = urb->transfer_buffer;
600 struct keyspan_usa49_portStatusMessage *msg;
601 struct usb_serial *serial;
602 struct usb_serial_port *port;
603 struct keyspan_port_private *p_priv;
605 int status = urb->status;
607 serial = urb->context;
610 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
614 if (urb->actual_length !=
615 sizeof(struct keyspan_usa49_portStatusMessage)) {
616 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
621 dev_dbg(&urb->dev->dev, "%s: %x %x %x %x %x %x %x %x %x %x %x",
622 __func__, data[0], data[1], data[2], data[3], data[4],
623 data[5], data[6], data[7], data[8], data[9], data[10]);
626 /* Now do something useful with the data */
627 msg = (struct keyspan_usa49_portStatusMessage *)data;
629 /* Check port number from message and retrieve private data */
630 if (msg->portNumber >= serial->num_ports) {
631 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
632 __func__, msg->portNumber);
635 port = serial->port[msg->portNumber];
636 p_priv = usb_get_serial_port_data(port);
638 /* Update handshaking pin state information */
639 old_dcd_state = p_priv->dcd_state;
640 p_priv->cts_state = ((msg->cts) ? 1 : 0);
641 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
642 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
643 p_priv->ri_state = ((msg->ri) ? 1 : 0);
645 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
646 struct tty_struct *tty = tty_port_tty_get(&port->port);
647 if (tty && !C_CLOCAL(tty))
652 /* Resubmit urb so we continue receiving */
653 err = usb_submit_urb(urb, GFP_ATOMIC);
655 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
659 static void usa49_inack_callback(struct urb *urb)
663 static void usa49_indat_callback(struct urb *urb)
667 struct usb_serial_port *port;
668 unsigned char *data = urb->transfer_buffer;
669 int status = urb->status;
671 endpoint = usb_pipeendpoint(urb->pipe);
674 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
675 __func__, status, endpoint);
680 if (urb->actual_length) {
681 /* 0x80 bit is error flag */
682 if ((data[0] & 0x80) == 0) {
683 /* no error on any byte */
684 tty_insert_flip_string(&port->port, data + 1,
685 urb->actual_length - 1);
687 /* some bytes had errors, every byte has status */
688 for (i = 0; i + 1 < urb->actual_length; i += 2) {
689 int stat = data[i], flag = 0;
690 if (stat & RXERROR_OVERRUN)
692 if (stat & RXERROR_FRAMING)
694 if (stat & RXERROR_PARITY)
696 /* XXX should handle break (0x10) */
697 tty_insert_flip_char(&port->port, data[i+1],
701 tty_flip_buffer_push(&port->port);
704 /* Resubmit urb so we continue receiving */
705 err = usb_submit_urb(urb, GFP_ATOMIC);
707 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
710 static void usa49wg_indat_callback(struct urb *urb)
713 struct usb_serial *serial;
714 struct usb_serial_port *port;
715 unsigned char *data = urb->transfer_buffer;
716 int status = urb->status;
718 serial = urb->context;
721 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
725 /* inbound data is in the form P#, len, status, data */
729 if (urb->actual_length) {
730 while (i < urb->actual_length) {
732 /* Check port number from message*/
733 if (data[i] >= serial->num_ports) {
734 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
738 port = serial->port[data[i++]];
741 /* 0x80 bit is error flag */
742 if ((data[i] & 0x80) == 0) {
743 /* no error on any byte */
745 for (x = 1; x < len ; ++x)
746 tty_insert_flip_char(&port->port,
750 * some bytes had errors, every byte has status
752 for (x = 0; x + 1 < len; x += 2) {
753 int stat = data[i], flag = 0;
754 if (stat & RXERROR_OVERRUN)
756 if (stat & RXERROR_FRAMING)
758 if (stat & RXERROR_PARITY)
760 /* XXX should handle break (0x10) */
761 tty_insert_flip_char(&port->port,
766 tty_flip_buffer_push(&port->port);
770 /* Resubmit urb so we continue receiving */
771 err = usb_submit_urb(urb, GFP_ATOMIC);
773 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
776 /* not used, usa-49 doesn't have per-port control endpoints */
777 static void usa49_outcont_callback(struct urb *urb)
781 static void usa90_indat_callback(struct urb *urb)
785 struct usb_serial_port *port;
786 struct keyspan_port_private *p_priv;
787 unsigned char *data = urb->transfer_buffer;
788 int status = urb->status;
790 endpoint = usb_pipeendpoint(urb->pipe);
793 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
794 __func__, status, endpoint);
799 p_priv = usb_get_serial_port_data(port);
801 if (urb->actual_length) {
802 /* if current mode is DMA, looks like usa28 format
803 otherwise looks like usa26 data format */
805 if (p_priv->baud > 57600)
806 tty_insert_flip_string(&port->port, data,
809 /* 0x80 bit is error flag */
810 if ((data[0] & 0x80) == 0) {
811 /* no errors on individual bytes, only
812 possible overrun err*/
813 if (data[0] & RXERROR_OVERRUN)
817 for (i = 1; i < urb->actual_length ; ++i)
818 tty_insert_flip_char(&port->port,
821 /* some bytes had errors, every byte has status */
822 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
823 for (i = 0; i + 1 < urb->actual_length; i += 2) {
824 int stat = data[i], flag = 0;
825 if (stat & RXERROR_OVERRUN)
827 if (stat & RXERROR_FRAMING)
829 if (stat & RXERROR_PARITY)
831 /* XXX should handle break (0x10) */
832 tty_insert_flip_char(&port->port,
837 tty_flip_buffer_push(&port->port);
840 /* Resubmit urb so we continue receiving */
841 err = usb_submit_urb(urb, GFP_ATOMIC);
843 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
847 static void usa90_instat_callback(struct urb *urb)
849 unsigned char *data = urb->transfer_buffer;
850 struct keyspan_usa90_portStatusMessage *msg;
851 struct usb_serial *serial;
852 struct usb_serial_port *port;
853 struct keyspan_port_private *p_priv;
854 struct tty_struct *tty;
855 int old_dcd_state, err;
856 int status = urb->status;
858 serial = urb->context;
861 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
864 if (urb->actual_length < 14) {
865 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
869 msg = (struct keyspan_usa90_portStatusMessage *)data;
871 /* Now do something useful with the data */
873 port = serial->port[0];
874 p_priv = usb_get_serial_port_data(port);
876 /* Update handshaking pin state information */
877 old_dcd_state = p_priv->dcd_state;
878 p_priv->cts_state = ((msg->cts) ? 1 : 0);
879 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
880 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
881 p_priv->ri_state = ((msg->ri) ? 1 : 0);
883 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
884 tty = tty_port_tty_get(&port->port);
885 if (tty && !C_CLOCAL(tty))
890 /* Resubmit urb so we continue receiving */
891 err = usb_submit_urb(urb, GFP_ATOMIC);
893 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
898 static void usa90_outcont_callback(struct urb *urb)
900 struct usb_serial_port *port;
901 struct keyspan_port_private *p_priv;
904 p_priv = usb_get_serial_port_data(port);
906 if (p_priv->resend_cont) {
907 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
908 keyspan_usa90_send_setup(port->serial, port,
909 p_priv->resend_cont - 1);
913 /* Status messages from the 28xg */
914 static void usa67_instat_callback(struct urb *urb)
917 unsigned char *data = urb->transfer_buffer;
918 struct keyspan_usa67_portStatusMessage *msg;
919 struct usb_serial *serial;
920 struct usb_serial_port *port;
921 struct keyspan_port_private *p_priv;
923 int status = urb->status;
925 serial = urb->context;
928 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
932 if (urb->actual_length !=
933 sizeof(struct keyspan_usa67_portStatusMessage)) {
934 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
939 /* Now do something useful with the data */
940 msg = (struct keyspan_usa67_portStatusMessage *)data;
942 /* Check port number from message and retrieve private data */
943 if (msg->port >= serial->num_ports) {
944 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
948 port = serial->port[msg->port];
949 p_priv = usb_get_serial_port_data(port);
951 /* Update handshaking pin state information */
952 old_dcd_state = p_priv->dcd_state;
953 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
954 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
956 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
957 struct tty_struct *tty = tty_port_tty_get(&port->port);
958 if (tty && !C_CLOCAL(tty))
963 /* Resubmit urb so we continue receiving */
964 err = usb_submit_urb(urb, GFP_ATOMIC);
966 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
969 static void usa67_glocont_callback(struct urb *urb)
971 struct usb_serial *serial;
972 struct usb_serial_port *port;
973 struct keyspan_port_private *p_priv;
976 serial = urb->context;
977 for (i = 0; i < serial->num_ports; ++i) {
978 port = serial->port[i];
979 p_priv = usb_get_serial_port_data(port);
981 if (p_priv->resend_cont) {
982 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
983 keyspan_usa67_send_setup(serial, port,
984 p_priv->resend_cont - 1);
990 static int keyspan_write_room(struct tty_struct *tty)
992 struct usb_serial_port *port = tty->driver_data;
993 struct keyspan_port_private *p_priv;
994 const struct keyspan_device_details *d_details;
997 struct urb *this_urb;
999 p_priv = usb_get_serial_port_data(port);
1000 d_details = p_priv->device_details;
1002 /* FIXME: locking */
1003 if (d_details->msg_format == msg_usa90)
1008 flip = p_priv->out_flip;
1010 /* Check both endpoints to see if any are available. */
1011 this_urb = p_priv->out_urbs[flip];
1012 if (this_urb != NULL) {
1013 if (this_urb->status != -EINPROGRESS)
1015 flip = (flip + 1) & d_details->outdat_endp_flip;
1016 this_urb = p_priv->out_urbs[flip];
1017 if (this_urb != NULL) {
1018 if (this_urb->status != -EINPROGRESS)
1026 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1028 struct keyspan_port_private *p_priv;
1029 const struct keyspan_device_details *d_details;
1031 int baud_rate, device_port;
1033 unsigned int cflag = 0;
1035 p_priv = usb_get_serial_port_data(port);
1036 d_details = p_priv->device_details;
1038 /* Set some sane defaults */
1039 p_priv->rts_state = 1;
1040 p_priv->dtr_state = 1;
1041 p_priv->baud = 9600;
1043 /* force baud and lcr to be set on open */
1044 p_priv->old_baud = 0;
1045 p_priv->old_cflag = 0;
1047 p_priv->out_flip = 0;
1048 p_priv->in_flip = 0;
1050 /* Reset low level data toggle and start reading from endpoints */
1051 for (i = 0; i < 2; i++) {
1052 urb = p_priv->in_urbs[i];
1056 /* make sure endpoint data toggle is synchronized
1058 usb_clear_halt(urb->dev, urb->pipe);
1059 err = usb_submit_urb(urb, GFP_KERNEL);
1061 dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1064 /* Reset low level data toggle on out endpoints */
1065 for (i = 0; i < 2; i++) {
1066 urb = p_priv->out_urbs[i];
1069 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1070 usb_pipeout(urb->pipe), 0); */
1073 /* get the terminal config for the setup message now so we don't
1074 * need to send 2 of them */
1076 device_port = port->number - port->serial->minor;
1078 cflag = tty->termios.c_cflag;
1079 /* Baud rate calculation takes baud rate as an integer
1080 so other rates can be generated if desired. */
1081 baud_rate = tty_get_baud_rate(tty);
1082 /* If no match or invalid, leave as default */
1084 && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1085 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1086 p_priv->baud = baud_rate;
1089 /* set CTS/RTS handshake etc. */
1090 p_priv->cflag = cflag;
1091 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1093 keyspan_send_setup(port, 1);
1095 /* keyspan_set_termios(port, NULL); */
1100 static inline void stop_urb(struct urb *urb)
1102 if (urb && urb->status == -EINPROGRESS)
1106 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1108 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1110 p_priv->rts_state = on;
1111 p_priv->dtr_state = on;
1112 keyspan_send_setup(port, 0);
1115 static void keyspan_close(struct usb_serial_port *port)
1118 struct usb_serial *serial = port->serial;
1119 struct keyspan_port_private *p_priv;
1121 p_priv = usb_get_serial_port_data(port);
1123 p_priv->rts_state = 0;
1124 p_priv->dtr_state = 0;
1127 keyspan_send_setup(port, 2);
1128 /* pilot-xfer seems to work best with this delay */
1130 /* keyspan_set_termios(port, NULL); */
1133 /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
1134 dev_dbg(&port->dev, "%s - urb in progress\n", __func__);
1137 p_priv->out_flip = 0;
1138 p_priv->in_flip = 0;
1141 /* Stop reading/writing urbs */
1142 stop_urb(p_priv->inack_urb);
1143 /* stop_urb(p_priv->outcont_urb); */
1144 for (i = 0; i < 2; i++) {
1145 stop_urb(p_priv->in_urbs[i]);
1146 stop_urb(p_priv->out_urbs[i]);
1151 /* download the firmware to a pre-renumeration device */
1152 static int keyspan_fake_startup(struct usb_serial *serial)
1156 dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1157 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1158 le16_to_cpu(serial->dev->descriptor.idProduct));
1160 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1162 dev_dbg(&serial->dev->dev, "Firmware already loaded. Quitting.\n");
1166 /* Select firmware image on the basis of idProduct */
1167 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1168 case keyspan_usa28_pre_product_id:
1169 fw_name = "keyspan/usa28.fw";
1172 case keyspan_usa28x_pre_product_id:
1173 fw_name = "keyspan/usa28x.fw";
1176 case keyspan_usa28xa_pre_product_id:
1177 fw_name = "keyspan/usa28xa.fw";
1180 case keyspan_usa28xb_pre_product_id:
1181 fw_name = "keyspan/usa28xb.fw";
1184 case keyspan_usa19_pre_product_id:
1185 fw_name = "keyspan/usa19.fw";
1188 case keyspan_usa19qi_pre_product_id:
1189 fw_name = "keyspan/usa19qi.fw";
1192 case keyspan_mpr_pre_product_id:
1193 fw_name = "keyspan/mpr.fw";
1196 case keyspan_usa19qw_pre_product_id:
1197 fw_name = "keyspan/usa19qw.fw";
1200 case keyspan_usa18x_pre_product_id:
1201 fw_name = "keyspan/usa18x.fw";
1204 case keyspan_usa19w_pre_product_id:
1205 fw_name = "keyspan/usa19w.fw";
1208 case keyspan_usa49w_pre_product_id:
1209 fw_name = "keyspan/usa49w.fw";
1212 case keyspan_usa49wlc_pre_product_id:
1213 fw_name = "keyspan/usa49wlc.fw";
1217 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1218 le16_to_cpu(serial->dev->descriptor.idProduct));
1222 dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1224 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1225 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1230 /* after downloading firmware Renumeration will occur in a
1231 moment and the new device will bind to the real driver */
1233 /* we don't want this device to have a driver assigned to it. */
1237 /* Helper functions used by keyspan_setup_urbs */
1238 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1241 struct usb_host_interface *iface_desc;
1242 struct usb_endpoint_descriptor *ep;
1245 iface_desc = serial->interface->cur_altsetting;
1246 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1247 ep = &iface_desc->endpoint[i].desc;
1248 if (ep->bEndpointAddress == endpoint)
1251 dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1252 "endpoint %x\n", endpoint);
1256 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1257 int dir, void *ctx, char *buf, int len,
1258 void (*callback)(struct urb *))
1261 struct usb_endpoint_descriptor const *ep_desc;
1262 char const *ep_type_name;
1265 return NULL; /* endpoint not needed */
1267 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
1268 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1270 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d failed.\n", __func__, endpoint);
1274 if (endpoint == 0) {
1275 /* control EP filled in when used */
1279 ep_desc = find_ep(serial, endpoint);
1281 /* leak the urb, something's wrong and the callers don't care */
1284 if (usb_endpoint_xfer_int(ep_desc)) {
1285 ep_type_name = "INT";
1286 usb_fill_int_urb(urb, serial->dev,
1287 usb_sndintpipe(serial->dev, endpoint) | dir,
1288 buf, len, callback, ctx,
1289 ep_desc->bInterval);
1290 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1291 ep_type_name = "BULK";
1292 usb_fill_bulk_urb(urb, serial->dev,
1293 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1294 buf, len, callback, ctx);
1296 dev_warn(&serial->interface->dev,
1297 "unsupported endpoint type %x\n",
1298 usb_endpoint_type(ep_desc));
1303 dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1304 __func__, urb, ep_type_name, endpoint);
1308 static struct callbacks {
1309 void (*instat_callback)(struct urb *);
1310 void (*glocont_callback)(struct urb *);
1311 void (*indat_callback)(struct urb *);
1312 void (*outdat_callback)(struct urb *);
1313 void (*inack_callback)(struct urb *);
1314 void (*outcont_callback)(struct urb *);
1315 } keyspan_callbacks[] = {
1317 /* msg_usa26 callbacks */
1318 .instat_callback = usa26_instat_callback,
1319 .glocont_callback = usa26_glocont_callback,
1320 .indat_callback = usa26_indat_callback,
1321 .outdat_callback = usa2x_outdat_callback,
1322 .inack_callback = usa26_inack_callback,
1323 .outcont_callback = usa26_outcont_callback,
1325 /* msg_usa28 callbacks */
1326 .instat_callback = usa28_instat_callback,
1327 .glocont_callback = usa28_glocont_callback,
1328 .indat_callback = usa28_indat_callback,
1329 .outdat_callback = usa2x_outdat_callback,
1330 .inack_callback = usa28_inack_callback,
1331 .outcont_callback = usa28_outcont_callback,
1333 /* msg_usa49 callbacks */
1334 .instat_callback = usa49_instat_callback,
1335 .glocont_callback = usa49_glocont_callback,
1336 .indat_callback = usa49_indat_callback,
1337 .outdat_callback = usa2x_outdat_callback,
1338 .inack_callback = usa49_inack_callback,
1339 .outcont_callback = usa49_outcont_callback,
1341 /* msg_usa90 callbacks */
1342 .instat_callback = usa90_instat_callback,
1343 .glocont_callback = usa28_glocont_callback,
1344 .indat_callback = usa90_indat_callback,
1345 .outdat_callback = usa2x_outdat_callback,
1346 .inack_callback = usa28_inack_callback,
1347 .outcont_callback = usa90_outcont_callback,
1349 /* msg_usa67 callbacks */
1350 .instat_callback = usa67_instat_callback,
1351 .glocont_callback = usa67_glocont_callback,
1352 .indat_callback = usa26_indat_callback,
1353 .outdat_callback = usa2x_outdat_callback,
1354 .inack_callback = usa26_inack_callback,
1355 .outcont_callback = usa26_outcont_callback,
1359 /* Generic setup urbs function that uses
1360 data in device_details */
1361 static void keyspan_setup_urbs(struct usb_serial *serial)
1363 struct keyspan_serial_private *s_priv;
1364 const struct keyspan_device_details *d_details;
1365 struct callbacks *cback;
1367 s_priv = usb_get_serial_data(serial);
1368 d_details = s_priv->device_details;
1370 /* Setup values for the various callback routines */
1371 cback = &keyspan_callbacks[d_details->msg_format];
1373 /* Allocate and set up urbs for each one that is in use,
1374 starting with instat endpoints */
1375 s_priv->instat_urb = keyspan_setup_urb
1376 (serial, d_details->instat_endpoint, USB_DIR_IN,
1377 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1378 cback->instat_callback);
1380 s_priv->indat_urb = keyspan_setup_urb
1381 (serial, d_details->indat_endpoint, USB_DIR_IN,
1382 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1383 usa49wg_indat_callback);
1385 s_priv->glocont_urb = keyspan_setup_urb
1386 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1387 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1388 cback->glocont_callback);
1391 /* usa19 function doesn't require prescaler */
1392 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1393 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1394 u8 *rate_low, u8 *prescaler, int portnum)
1396 u32 b16, /* baud rate times 16 (actual rate used internally) */
1398 cnt; /* inverse of divisor (programmed into 8051) */
1400 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1402 /* prevent divide by zero... */
1403 b16 = baud_rate * 16L;
1405 return KEYSPAN_INVALID_BAUD_RATE;
1406 /* Any "standard" rate over 57k6 is marginal on the USA-19
1407 as we run out of divisor resolution. */
1408 if (baud_rate > 57600)
1409 return KEYSPAN_INVALID_BAUD_RATE;
1411 /* calculate the divisor and the counter (its inverse) */
1412 div = baudclk / b16;
1414 return KEYSPAN_INVALID_BAUD_RATE;
1419 return KEYSPAN_INVALID_BAUD_RATE;
1421 /* return the counter values if non-null */
1423 *rate_low = (u8) (cnt & 0xff);
1425 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1426 if (rate_low && rate_hi)
1427 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1428 __func__, baud_rate, *rate_hi, *rate_low);
1429 return KEYSPAN_BAUD_RATE_OK;
1432 /* usa19hs function doesn't require prescaler */
1433 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1434 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1435 u8 *rate_low, u8 *prescaler, int portnum)
1437 u32 b16, /* baud rate times 16 (actual rate used internally) */
1440 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1442 /* prevent divide by zero... */
1443 b16 = baud_rate * 16L;
1445 return KEYSPAN_INVALID_BAUD_RATE;
1447 /* calculate the divisor */
1448 div = baudclk / b16;
1450 return KEYSPAN_INVALID_BAUD_RATE;
1453 return KEYSPAN_INVALID_BAUD_RATE;
1455 /* return the counter values if non-null */
1457 *rate_low = (u8) (div & 0xff);
1460 *rate_hi = (u8) ((div >> 8) & 0xff);
1462 if (rate_low && rate_hi)
1463 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1464 __func__, baud_rate, *rate_hi, *rate_low);
1466 return KEYSPAN_BAUD_RATE_OK;
1469 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1470 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1471 u8 *rate_low, u8 *prescaler, int portnum)
1473 u32 b16, /* baud rate times 16 (actual rate used internally) */
1474 clk, /* clock with 13/8 prescaler */
1475 div, /* divisor using 13/8 prescaler */
1476 res, /* resulting baud rate using 13/8 prescaler */
1477 diff, /* error using 13/8 prescaler */
1482 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1484 /* prevent divide by zero */
1485 b16 = baud_rate * 16L;
1487 return KEYSPAN_INVALID_BAUD_RATE;
1489 /* Calculate prescaler by trying them all and looking
1492 /* start with largest possible difference */
1493 smallest_diff = 0xffffffff;
1495 /* 0 is an invalid prescaler, used as a flag */
1498 for (i = 8; i <= 0xff; ++i) {
1499 clk = (baudclk * 8) / (u32) i;
1506 diff = (res > b16) ? (res-b16) : (b16-res);
1508 if (diff < smallest_diff) {
1510 smallest_diff = diff;
1514 if (best_prescaler == 0)
1515 return KEYSPAN_INVALID_BAUD_RATE;
1517 clk = (baudclk * 8) / (u32) best_prescaler;
1520 /* return the divisor and prescaler if non-null */
1522 *rate_low = (u8) (div & 0xff);
1524 *rate_hi = (u8) ((div >> 8) & 0xff);
1526 *prescaler = best_prescaler;
1527 /* dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1529 return KEYSPAN_BAUD_RATE_OK;
1532 /* USA-28 supports different maximum baud rates on each port */
1533 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1534 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1535 u8 *rate_low, u8 *prescaler, int portnum)
1537 u32 b16, /* baud rate times 16 (actual rate used internally) */
1539 cnt; /* inverse of divisor (programmed into 8051) */
1541 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1543 /* prevent divide by zero */
1544 b16 = baud_rate * 16L;
1546 return KEYSPAN_INVALID_BAUD_RATE;
1548 /* calculate the divisor and the counter (its inverse) */
1549 div = KEYSPAN_USA28_BAUDCLK / b16;
1551 return KEYSPAN_INVALID_BAUD_RATE;
1555 /* check for out of range, based on portnum,
1556 and return result */
1559 return KEYSPAN_INVALID_BAUD_RATE;
1563 return KEYSPAN_INVALID_BAUD_RATE;
1565 return KEYSPAN_INVALID_BAUD_RATE;
1568 /* return the counter values if not NULL
1569 (port 1 will ignore retHi) */
1571 *rate_low = (u8) (cnt & 0xff);
1573 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1574 dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
1575 return KEYSPAN_BAUD_RATE_OK;
1578 static int keyspan_usa26_send_setup(struct usb_serial *serial,
1579 struct usb_serial_port *port,
1582 struct keyspan_usa26_portControlMessage msg;
1583 struct keyspan_serial_private *s_priv;
1584 struct keyspan_port_private *p_priv;
1585 const struct keyspan_device_details *d_details;
1587 struct urb *this_urb;
1588 int device_port, err;
1590 dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
1592 s_priv = usb_get_serial_data(serial);
1593 p_priv = usb_get_serial_port_data(port);
1594 d_details = s_priv->device_details;
1595 device_port = port->number - port->serial->minor;
1597 outcont_urb = d_details->outcont_endpoints[port->number];
1598 this_urb = p_priv->outcont_urb;
1600 dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
1602 /* Make sure we have an urb then send the message */
1603 if (this_urb == NULL) {
1604 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1608 /* Save reset port val for resend.
1609 Don't overwrite resend for open/close condition. */
1610 if ((reset_port + 1) > p_priv->resend_cont)
1611 p_priv->resend_cont = reset_port + 1;
1612 if (this_urb->status == -EINPROGRESS) {
1613 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1618 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
1620 /* Only set baud rate if it's changed */
1621 if (p_priv->old_baud != p_priv->baud) {
1622 p_priv->old_baud = p_priv->baud;
1623 msg.setClocking = 0xff;
1624 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1625 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1626 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1627 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1628 __func__, p_priv->baud);
1630 msg.baudHi = 125; /* Values for 9600 baud */
1633 msg.setPrescaler = 0xff;
1636 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1637 switch (p_priv->cflag & CSIZE) {
1639 msg.lcr |= USA_DATABITS_5;
1642 msg.lcr |= USA_DATABITS_6;
1645 msg.lcr |= USA_DATABITS_7;
1648 msg.lcr |= USA_DATABITS_8;
1651 if (p_priv->cflag & PARENB) {
1652 /* note USA_PARITY_NONE == 0 */
1653 msg.lcr |= (p_priv->cflag & PARODD) ?
1654 USA_PARITY_ODD : USA_PARITY_EVEN;
1658 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1659 msg.xonFlowControl = 0;
1660 msg.setFlowControl = 0xff;
1661 msg.forwardingLength = 16;
1666 if (reset_port == 1) {
1675 msg.returnStatus = 0;
1676 msg.resetDataToggle = 0xff;
1680 else if (reset_port == 2) {
1689 msg.returnStatus = 0;
1690 msg.resetDataToggle = 0;
1693 /* Sending intermediate configs */
1695 msg._txOn = (!p_priv->break_on);
1698 msg.txBreak = (p_priv->break_on);
1703 msg.returnStatus = 0;
1704 msg.resetDataToggle = 0x0;
1707 /* Do handshaking outputs */
1708 msg.setTxTriState_setRts = 0xff;
1709 msg.txTriState_rts = p_priv->rts_state;
1711 msg.setHskoa_setDtr = 0xff;
1712 msg.hskoa_dtr = p_priv->dtr_state;
1714 p_priv->resend_cont = 0;
1715 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1717 /* send the data out the device on control endpoint */
1718 this_urb->transfer_buffer_length = sizeof(msg);
1720 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1722 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1725 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__
1726 outcont_urb, this_urb->transfer_buffer_length,
1727 usb_pipeendpoint(this_urb->pipe));
1734 static int keyspan_usa28_send_setup(struct usb_serial *serial,
1735 struct usb_serial_port *port,
1738 struct keyspan_usa28_portControlMessage msg;
1739 struct keyspan_serial_private *s_priv;
1740 struct keyspan_port_private *p_priv;
1741 const struct keyspan_device_details *d_details;
1742 struct urb *this_urb;
1743 int device_port, err;
1745 s_priv = usb_get_serial_data(serial);
1746 p_priv = usb_get_serial_port_data(port);
1747 d_details = s_priv->device_details;
1748 device_port = port->number - port->serial->minor;
1750 /* only do something if we have a bulk out endpoint */
1751 this_urb = p_priv->outcont_urb;
1752 if (this_urb == NULL) {
1753 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1757 /* Save reset port val for resend.
1758 Don't overwrite resend for open/close condition. */
1759 if ((reset_port + 1) > p_priv->resend_cont)
1760 p_priv->resend_cont = reset_port + 1;
1761 if (this_urb->status == -EINPROGRESS) {
1762 dev_dbg(&port->dev, "%s already writing\n", __func__);
1767 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
1769 msg.setBaudRate = 1;
1770 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1771 &msg.baudHi, &msg.baudLo, NULL,
1772 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1773 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
1774 __func__, p_priv->baud);
1776 msg.baudHi = 0xb2; /* Values for 9600 baud */
1779 /* If parity is enabled, we must calculate it ourselves. */
1780 msg.parity = 0; /* XXX for now */
1782 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1783 msg.xonFlowControl = 0;
1785 /* Do handshaking outputs, DTR is inverted relative to RTS */
1786 msg.rts = p_priv->rts_state;
1787 msg.dtr = p_priv->dtr_state;
1789 msg.forwardingLength = 16;
1791 msg.breakThreshold = 45;
1795 /*msg.returnStatus = 1;
1796 msg.resetDataToggle = 0xff;*/
1798 if (reset_port == 1) {
1802 msg.txForceXoff = 0;
1808 msg.returnStatus = 0;
1809 msg.resetDataToggle = 0xff;
1812 else if (reset_port == 2) {
1816 msg.txForceXoff = 0;
1822 msg.returnStatus = 0;
1823 msg.resetDataToggle = 0;
1825 /* Sending intermediate configs */
1827 msg._txOn = (!p_priv->break_on);
1830 msg.txForceXoff = 0;
1831 msg.txBreak = (p_priv->break_on);
1836 msg.returnStatus = 0;
1837 msg.resetDataToggle = 0x0;
1840 p_priv->resend_cont = 0;
1841 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1843 /* send the data out the device on control endpoint */
1844 this_urb->transfer_buffer_length = sizeof(msg);
1846 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1848 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
1851 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) OK %d bytes\n", __func__,
1852 this_urb->transfer_buffer_length);
1859 static int keyspan_usa49_send_setup(struct usb_serial *serial,
1860 struct usb_serial_port *port,
1863 struct keyspan_usa49_portControlMessage msg;
1864 struct usb_ctrlrequest *dr = NULL;
1865 struct keyspan_serial_private *s_priv;
1866 struct keyspan_port_private *p_priv;
1867 const struct keyspan_device_details *d_details;
1868 struct urb *this_urb;
1869 int err, device_port;
1871 s_priv = usb_get_serial_data(serial);
1872 p_priv = usb_get_serial_port_data(port);
1873 d_details = s_priv->device_details;
1875 this_urb = s_priv->glocont_urb;
1877 /* Work out which port within the device is being setup */
1878 device_port = port->number - port->serial->minor;
1880 /* Make sure we have an urb then send the message */
1881 if (this_urb == NULL) {
1882 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__, port->number);
1886 dev_dbg(&port->dev, "%s - endpoint %d port %d (%d)\n",
1887 __func__, usb_pipeendpoint(this_urb->pipe),
1888 port->number, device_port);
1890 /* Save reset port val for resend.
1891 Don't overwrite resend for open/close condition. */
1892 if ((reset_port + 1) > p_priv->resend_cont)
1893 p_priv->resend_cont = reset_port + 1;
1895 if (this_urb->status == -EINPROGRESS) {
1896 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1901 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
1903 /*msg.portNumber = port->number;*/
1904 msg.portNumber = device_port;
1906 /* Only set baud rate if it's changed */
1907 if (p_priv->old_baud != p_priv->baud) {
1908 p_priv->old_baud = p_priv->baud;
1909 msg.setClocking = 0xff;
1910 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1911 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1912 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1913 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1914 __func__, p_priv->baud);
1916 msg.baudHi = 125; /* Values for 9600 baud */
1919 /* msg.setPrescaler = 0xff; */
1922 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1923 switch (p_priv->cflag & CSIZE) {
1925 msg.lcr |= USA_DATABITS_5;
1928 msg.lcr |= USA_DATABITS_6;
1931 msg.lcr |= USA_DATABITS_7;
1934 msg.lcr |= USA_DATABITS_8;
1937 if (p_priv->cflag & PARENB) {
1938 /* note USA_PARITY_NONE == 0 */
1939 msg.lcr |= (p_priv->cflag & PARODD) ?
1940 USA_PARITY_ODD : USA_PARITY_EVEN;
1944 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1945 msg.xonFlowControl = 0;
1946 msg.setFlowControl = 0xff;
1948 msg.forwardingLength = 16;
1953 if (reset_port == 1) {
1962 msg.returnStatus = 0;
1963 msg.resetDataToggle = 0xff;
1965 msg.disablePort = 0;
1968 else if (reset_port == 2) {
1977 msg.returnStatus = 0;
1978 msg.resetDataToggle = 0;
1980 msg.disablePort = 1;
1982 /* Sending intermediate configs */
1984 msg._txOn = (!p_priv->break_on);
1987 msg.txBreak = (p_priv->break_on);
1992 msg.returnStatus = 0;
1993 msg.resetDataToggle = 0x0;
1995 msg.disablePort = 0;
1998 /* Do handshaking outputs */
2000 msg.rts = p_priv->rts_state;
2003 msg.dtr = p_priv->dtr_state;
2005 p_priv->resend_cont = 0;
2007 /* if the device is a 49wg, we send control message on usb
2010 if (d_details->product_id == keyspan_usa49wg_product_id) {
2011 dr = (void *)(s_priv->ctrl_buf);
2012 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2013 dr->bRequest = 0xB0; /* 49wg control message */;
2016 dr->wLength = cpu_to_le16(sizeof(msg));
2018 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
2020 usb_fill_control_urb(this_urb, serial->dev,
2021 usb_sndctrlpipe(serial->dev, 0),
2022 (unsigned char *)dr, s_priv->glocont_buf,
2023 sizeof(msg), usa49_glocont_callback, serial);
2026 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2028 /* send the data out the device on control endpoint */
2029 this_urb->transfer_buffer_length = sizeof(msg);
2031 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2033 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2036 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__,
2037 outcont_urb, this_urb->transfer_buffer_length,
2038 usb_pipeendpoint(this_urb->pipe));
2045 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2046 struct usb_serial_port *port,
2049 struct keyspan_usa90_portControlMessage msg;
2050 struct keyspan_serial_private *s_priv;
2051 struct keyspan_port_private *p_priv;
2052 const struct keyspan_device_details *d_details;
2053 struct urb *this_urb;
2057 s_priv = usb_get_serial_data(serial);
2058 p_priv = usb_get_serial_port_data(port);
2059 d_details = s_priv->device_details;
2061 /* only do something if we have a bulk out endpoint */
2062 this_urb = p_priv->outcont_urb;
2063 if (this_urb == NULL) {
2064 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2068 /* Save reset port val for resend.
2069 Don't overwrite resend for open/close condition. */
2070 if ((reset_port + 1) > p_priv->resend_cont)
2071 p_priv->resend_cont = reset_port + 1;
2072 if (this_urb->status == -EINPROGRESS) {
2073 dev_dbg(&port->dev, "%s already writing\n", __func__);
2078 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2080 /* Only set baud rate if it's changed */
2081 if (p_priv->old_baud != p_priv->baud) {
2082 p_priv->old_baud = p_priv->baud;
2083 msg.setClocking = 0x01;
2084 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2085 &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2086 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2087 __func__, p_priv->baud);
2088 p_priv->baud = 9600;
2089 d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2090 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2096 /* modes must always be correctly specified */
2097 if (p_priv->baud > 57600) {
2098 msg.rxMode = RXMODE_DMA;
2099 msg.txMode = TXMODE_DMA;
2101 msg.rxMode = RXMODE_BYHAND;
2102 msg.txMode = TXMODE_BYHAND;
2105 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2106 switch (p_priv->cflag & CSIZE) {
2108 msg.lcr |= USA_DATABITS_5;
2111 msg.lcr |= USA_DATABITS_6;
2114 msg.lcr |= USA_DATABITS_7;
2117 msg.lcr |= USA_DATABITS_8;
2120 if (p_priv->cflag & PARENB) {
2121 /* note USA_PARITY_NONE == 0 */
2122 msg.lcr |= (p_priv->cflag & PARODD) ?
2123 USA_PARITY_ODD : USA_PARITY_EVEN;
2125 if (p_priv->old_cflag != p_priv->cflag) {
2126 p_priv->old_cflag = p_priv->cflag;
2130 if (p_priv->flow_control == flow_cts)
2131 msg.txFlowControl = TXFLOW_CTS;
2132 msg.setTxFlowControl = 0x01;
2133 msg.setRxFlowControl = 0x01;
2135 msg.rxForwardingLength = 16;
2136 msg.rxForwardingTimeout = 16;
2137 msg.txAckSetting = 0;
2142 if (reset_port == 1) {
2143 msg.portEnabled = 1;
2145 msg.txBreak = (p_priv->break_on);
2148 else if (reset_port == 2)
2149 msg.portEnabled = 0;
2150 /* Sending intermediate configs */
2152 msg.portEnabled = 1;
2153 msg.txBreak = (p_priv->break_on);
2156 /* Do handshaking outputs */
2158 msg.rts = p_priv->rts_state;
2161 msg.dtr = p_priv->dtr_state;
2163 p_priv->resend_cont = 0;
2164 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2166 /* send the data out the device on control endpoint */
2167 this_urb->transfer_buffer_length = sizeof(msg);
2169 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2171 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2175 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2176 struct usb_serial_port *port,
2179 struct keyspan_usa67_portControlMessage msg;
2180 struct keyspan_serial_private *s_priv;
2181 struct keyspan_port_private *p_priv;
2182 const struct keyspan_device_details *d_details;
2183 struct urb *this_urb;
2184 int err, device_port;
2186 s_priv = usb_get_serial_data(serial);
2187 p_priv = usb_get_serial_port_data(port);
2188 d_details = s_priv->device_details;
2190 this_urb = s_priv->glocont_urb;
2192 /* Work out which port within the device is being setup */
2193 device_port = port->number - port->serial->minor;
2195 /* Make sure we have an urb then send the message */
2196 if (this_urb == NULL) {
2197 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__,
2202 /* Save reset port val for resend.
2203 Don't overwrite resend for open/close condition. */
2204 if ((reset_port + 1) > p_priv->resend_cont)
2205 p_priv->resend_cont = reset_port + 1;
2206 if (this_urb->status == -EINPROGRESS) {
2207 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2212 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2214 msg.port = device_port;
2216 /* Only set baud rate if it's changed */
2217 if (p_priv->old_baud != p_priv->baud) {
2218 p_priv->old_baud = p_priv->baud;
2219 msg.setClocking = 0xff;
2220 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2221 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2222 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2223 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2224 __func__, p_priv->baud);
2226 msg.baudHi = 125; /* Values for 9600 baud */
2229 msg.setPrescaler = 0xff;
2232 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2233 switch (p_priv->cflag & CSIZE) {
2235 msg.lcr |= USA_DATABITS_5;
2238 msg.lcr |= USA_DATABITS_6;
2241 msg.lcr |= USA_DATABITS_7;
2244 msg.lcr |= USA_DATABITS_8;
2247 if (p_priv->cflag & PARENB) {
2248 /* note USA_PARITY_NONE == 0 */
2249 msg.lcr |= (p_priv->cflag & PARODD) ?
2250 USA_PARITY_ODD : USA_PARITY_EVEN;
2254 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2255 msg.xonFlowControl = 0;
2256 msg.setFlowControl = 0xff;
2257 msg.forwardingLength = 16;
2261 if (reset_port == 1) {
2271 msg.returnStatus = 0;
2272 msg.resetDataToggle = 0xff;
2273 } else if (reset_port == 2) {
2283 msg.returnStatus = 0;
2284 msg.resetDataToggle = 0;
2286 /* Sending intermediate configs */
2287 msg._txOn = (!p_priv->break_on);
2290 msg.txBreak = (p_priv->break_on);
2295 msg.returnStatus = 0;
2296 msg.resetDataToggle = 0x0;
2299 /* Do handshaking outputs */
2300 msg.setTxTriState_setRts = 0xff;
2301 msg.txTriState_rts = p_priv->rts_state;
2303 msg.setHskoa_setDtr = 0xff;
2304 msg.hskoa_dtr = p_priv->dtr_state;
2306 p_priv->resend_cont = 0;
2308 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2310 /* send the data out the device on control endpoint */
2311 this_urb->transfer_buffer_length = sizeof(msg);
2313 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2315 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2319 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2321 struct usb_serial *serial = port->serial;
2322 struct keyspan_serial_private *s_priv;
2323 const struct keyspan_device_details *d_details;
2325 s_priv = usb_get_serial_data(serial);
2326 d_details = s_priv->device_details;
2328 switch (d_details->msg_format) {
2330 keyspan_usa26_send_setup(serial, port, reset_port);
2333 keyspan_usa28_send_setup(serial, port, reset_port);
2336 keyspan_usa49_send_setup(serial, port, reset_port);
2339 keyspan_usa90_send_setup(serial, port, reset_port);
2342 keyspan_usa67_send_setup(serial, port, reset_port);
2348 /* Gets called by the "real" driver (ie once firmware is loaded
2349 and renumeration has taken place. */
2350 static int keyspan_startup(struct usb_serial *serial)
2353 struct keyspan_serial_private *s_priv;
2354 const struct keyspan_device_details *d_details;
2356 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2357 if (d_details->product_id ==
2358 le16_to_cpu(serial->dev->descriptor.idProduct))
2360 if (d_details == NULL) {
2361 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2362 __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2366 /* Setup private data for serial driver */
2367 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2369 dev_dbg(&serial->dev->dev, "%s - kmalloc for keyspan_serial_private failed.\n", __func__);
2373 s_priv->device_details = d_details;
2374 usb_set_serial_data(serial, s_priv);
2376 keyspan_setup_urbs(serial);
2378 if (s_priv->instat_urb != NULL) {
2379 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2381 dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2383 if (s_priv->indat_urb != NULL) {
2384 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2386 dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2392 static void keyspan_disconnect(struct usb_serial *serial)
2394 struct keyspan_serial_private *s_priv;
2396 s_priv = usb_get_serial_data(serial);
2398 stop_urb(s_priv->instat_urb);
2399 stop_urb(s_priv->glocont_urb);
2400 stop_urb(s_priv->indat_urb);
2403 static void keyspan_release(struct usb_serial *serial)
2405 struct keyspan_serial_private *s_priv;
2407 s_priv = usb_get_serial_data(serial);
2409 usb_free_urb(s_priv->instat_urb);
2410 usb_free_urb(s_priv->indat_urb);
2411 usb_free_urb(s_priv->glocont_urb);
2416 static int keyspan_port_probe(struct usb_serial_port *port)
2418 struct usb_serial *serial = port->serial;
2419 struct keyspan_serial_private *s_priv;
2420 struct keyspan_port_private *p_priv;
2421 const struct keyspan_device_details *d_details;
2422 struct callbacks *cback;
2427 s_priv = usb_get_serial_data(serial);
2428 d_details = s_priv->device_details;
2430 p_priv = kzalloc(sizeof(*p_priv), GFP_KERNEL);
2434 p_priv->device_details = d_details;
2436 /* Setup values for the various callback routines */
2437 cback = &keyspan_callbacks[d_details->msg_format];
2439 port_num = port->number - port->serial->minor;
2441 /* Do indat endpoints first, once for each flip */
2442 endp = d_details->indat_endpoints[port_num];
2443 for (i = 0; i <= d_details->indat_endp_flip; ++i, ++endp) {
2444 p_priv->in_urbs[i] = keyspan_setup_urb(serial, endp,
2446 p_priv->in_buffer[i], 64,
2447 cback->indat_callback);
2449 /* outdat endpoints also have flip */
2450 endp = d_details->outdat_endpoints[port_num];
2451 for (i = 0; i <= d_details->outdat_endp_flip; ++i, ++endp) {
2452 p_priv->out_urbs[i] = keyspan_setup_urb(serial, endp,
2454 p_priv->out_buffer[i], 64,
2455 cback->outdat_callback);
2457 /* inack endpoint */
2458 p_priv->inack_urb = keyspan_setup_urb(serial,
2459 d_details->inack_endpoints[port_num],
2461 p_priv->inack_buffer, 1,
2462 cback->inack_callback);
2463 /* outcont endpoint */
2464 p_priv->outcont_urb = keyspan_setup_urb(serial,
2465 d_details->outcont_endpoints[port_num],
2467 p_priv->outcont_buffer, 64,
2468 cback->outcont_callback);
2470 usb_set_serial_port_data(port, p_priv);
2475 static int keyspan_port_remove(struct usb_serial_port *port)
2477 struct keyspan_port_private *p_priv;
2480 p_priv = usb_get_serial_port_data(port);
2482 stop_urb(p_priv->inack_urb);
2483 stop_urb(p_priv->outcont_urb);
2484 for (i = 0; i < 2; i++) {
2485 stop_urb(p_priv->in_urbs[i]);
2486 stop_urb(p_priv->out_urbs[i]);
2489 usb_free_urb(p_priv->inack_urb);
2490 usb_free_urb(p_priv->outcont_urb);
2491 for (i = 0; i < 2; i++) {
2492 usb_free_urb(p_priv->in_urbs[i]);
2493 usb_free_urb(p_priv->out_urbs[i]);
2501 MODULE_AUTHOR(DRIVER_AUTHOR);
2502 MODULE_DESCRIPTION(DRIVER_DESC);
2503 MODULE_LICENSE("GPL");
2505 MODULE_FIRMWARE("keyspan/usa28.fw");
2506 MODULE_FIRMWARE("keyspan/usa28x.fw");
2507 MODULE_FIRMWARE("keyspan/usa28xa.fw");
2508 MODULE_FIRMWARE("keyspan/usa28xb.fw");
2509 MODULE_FIRMWARE("keyspan/usa19.fw");
2510 MODULE_FIRMWARE("keyspan/usa19qi.fw");
2511 MODULE_FIRMWARE("keyspan/mpr.fw");
2512 MODULE_FIRMWARE("keyspan/usa19qw.fw");
2513 MODULE_FIRMWARE("keyspan/usa18x.fw");
2514 MODULE_FIRMWARE("keyspan/usa19w.fw");
2515 MODULE_FIRMWARE("keyspan/usa49w.fw");
2516 MODULE_FIRMWARE("keyspan/usa49wlc.fw");