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>
50 #define DRIVER_VERSION "v1.1.5"
51 #define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
52 #define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
54 #define INSTAT_BUFLEN 32
55 #define GLOCONT_BUFLEN 64
56 #define INDAT49W_BUFLEN 512
58 /* Per device and per port private data */
59 struct keyspan_serial_private {
60 const struct keyspan_device_details *device_details;
62 struct urb *instat_urb;
63 char instat_buf[INSTAT_BUFLEN];
65 /* added to support 49wg, where data from all 4 ports comes in
66 on 1 EP and high-speed supported */
67 struct urb *indat_urb;
68 char indat_buf[INDAT49W_BUFLEN];
70 /* XXX this one probably will need a lock */
71 struct urb *glocont_urb;
72 char glocont_buf[GLOCONT_BUFLEN];
73 char ctrl_buf[8]; /* for EP0 control message */
76 struct keyspan_port_private {
77 /* Keep track of which input & output endpoints to use */
81 /* Keep duplicate of device details in each port
82 structure as well - simplifies some of the
83 callback functions etc. */
84 const struct keyspan_device_details *device_details;
86 /* Input endpoints and buffer for this port */
87 struct urb *in_urbs[2];
88 char in_buffer[2][64];
89 /* Output endpoints and buffer for this port */
90 struct urb *out_urbs[2];
91 char out_buffer[2][64];
93 /* Input ack endpoint */
94 struct urb *inack_urb;
97 /* Output control endpoint */
98 struct urb *outcont_urb;
99 char outcont_buffer[64];
101 /* Settings for the port */
105 unsigned int old_cflag;
106 enum {flow_none, flow_cts, flow_xon} flow_control;
107 int rts_state; /* Handshaking pins (outputs) */
109 int cts_state; /* Handshaking pins (inputs) */
115 unsigned long tx_start_time[2];
116 int resend_cont; /* need to resend control packet */
119 /* Include Keyspan message headers. All current Keyspan Adapters
120 make use of one of five message formats which are referred
121 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
122 within this driver. */
123 #include "keyspan_usa26msg.h"
124 #include "keyspan_usa28msg.h"
125 #include "keyspan_usa49msg.h"
126 #include "keyspan_usa90msg.h"
127 #include "keyspan_usa67msg.h"
130 module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
132 static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
134 struct usb_serial_port *port = tty->driver_data;
135 struct keyspan_port_private *p_priv;
137 p_priv = usb_get_serial_port_data(port);
139 if (break_state == -1)
140 p_priv->break_on = 1;
142 p_priv->break_on = 0;
144 keyspan_send_setup(port, 0);
148 static void keyspan_set_termios(struct tty_struct *tty,
149 struct usb_serial_port *port, struct ktermios *old_termios)
151 int baud_rate, device_port;
152 struct keyspan_port_private *p_priv;
153 const struct keyspan_device_details *d_details;
156 p_priv = usb_get_serial_port_data(port);
157 d_details = p_priv->device_details;
158 cflag = tty->termios.c_cflag;
159 device_port = port->number - port->serial->minor;
161 /* Baud rate calculation takes baud rate as an integer
162 so other rates can be generated if desired. */
163 baud_rate = tty_get_baud_rate(tty);
164 /* If no match or invalid, don't change */
165 if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
166 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
167 /* FIXME - more to do here to ensure rate changes cleanly */
168 /* FIXME - calcuate exact rate from divisor ? */
169 p_priv->baud = baud_rate;
171 baud_rate = tty_termios_baud_rate(old_termios);
173 tty_encode_baud_rate(tty, baud_rate, baud_rate);
174 /* set CTS/RTS handshake etc. */
175 p_priv->cflag = cflag;
176 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
178 /* Mark/Space not supported */
179 tty->termios.c_cflag &= ~CMSPAR;
181 keyspan_send_setup(port, 0);
184 static int keyspan_tiocmget(struct tty_struct *tty)
186 struct usb_serial_port *port = tty->driver_data;
187 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
190 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
191 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
192 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
193 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
194 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
195 ((p_priv->ri_state) ? TIOCM_RNG : 0);
200 static int keyspan_tiocmset(struct tty_struct *tty,
201 unsigned int set, unsigned int clear)
203 struct usb_serial_port *port = tty->driver_data;
204 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
207 p_priv->rts_state = 1;
209 p_priv->dtr_state = 1;
210 if (clear & TIOCM_RTS)
211 p_priv->rts_state = 0;
212 if (clear & TIOCM_DTR)
213 p_priv->dtr_state = 0;
214 keyspan_send_setup(port, 0);
218 /* Write function is similar for the four protocols used
219 with only a minor change for usa90 (usa19hs) required */
220 static int keyspan_write(struct tty_struct *tty,
221 struct usb_serial_port *port, const unsigned char *buf, int count)
223 struct keyspan_port_private *p_priv;
224 const struct keyspan_device_details *d_details;
227 struct urb *this_urb;
228 int err, maxDataLen, dataOffset;
230 p_priv = usb_get_serial_port_data(port);
231 d_details = p_priv->device_details;
233 if (d_details->msg_format == msg_usa90) {
241 dev_dbg(&port->dev, "%s - for port %d (%d chars), flip=%d\n",
242 __func__, port->number, count, p_priv->out_flip);
244 for (left = count; left > 0; left -= todo) {
246 if (todo > maxDataLen)
249 flip = p_priv->out_flip;
251 /* Check we have a valid urb/endpoint before we use it... */
252 this_urb = p_priv->out_urbs[flip];
253 if (this_urb == NULL) {
254 /* no bulk out, so return 0 bytes written */
255 dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
259 dev_dbg(&port->dev, "%s - endpoint %d flip %d\n",
260 __func__, usb_pipeendpoint(this_urb->pipe), flip);
262 if (this_urb->status == -EINPROGRESS) {
263 if (time_before(jiffies,
264 p_priv->tx_start_time[flip] + 10 * HZ))
266 usb_unlink_urb(this_urb);
270 /* First byte in buffer is "last flag" (except for usa19hx)
271 - unused so for now so set to zero */
272 ((char *)this_urb->transfer_buffer)[0] = 0;
274 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
277 /* send the data out the bulk port */
278 this_urb->transfer_buffer_length = todo + dataOffset;
280 err = usb_submit_urb(this_urb, GFP_ATOMIC);
282 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
283 p_priv->tx_start_time[flip] = jiffies;
285 /* Flip for next time if usa26 or usa28 interface
286 (not used on usa49) */
287 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
293 static void usa26_indat_callback(struct urb *urb)
297 struct usb_serial_port *port;
298 struct tty_struct *tty;
299 unsigned char *data = urb->transfer_buffer;
300 int status = urb->status;
302 endpoint = usb_pipeendpoint(urb->pipe);
305 dev_dbg(&urb->dev->dev,"%s - nonzero status: %x on endpoint %d.\n",
306 __func__, status, endpoint);
311 tty = tty_port_tty_get(&port->port);
312 if (tty && urb->actual_length) {
313 /* 0x80 bit is error flag */
314 if ((data[0] & 0x80) == 0) {
315 /* no errors on individual bytes, only
316 possible overrun err */
317 if (data[0] & RXERROR_OVERRUN)
321 for (i = 1; i < urb->actual_length ; ++i)
322 tty_insert_flip_char(tty, data[i], err);
324 /* some bytes had errors, every byte has status */
325 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
326 for (i = 0; i + 1 < urb->actual_length; i += 2) {
327 int stat = data[i], flag = 0;
328 if (stat & RXERROR_OVERRUN)
330 if (stat & RXERROR_FRAMING)
332 if (stat & RXERROR_PARITY)
334 /* XXX should handle break (0x10) */
335 tty_insert_flip_char(tty, data[i+1], flag);
338 tty_flip_buffer_push(tty);
342 /* Resubmit urb so we continue receiving */
343 err = usb_submit_urb(urb, GFP_ATOMIC);
345 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
348 /* Outdat handling is common for all devices */
349 static void usa2x_outdat_callback(struct urb *urb)
351 struct usb_serial_port *port;
352 struct keyspan_port_private *p_priv;
355 p_priv = usb_get_serial_port_data(port);
356 dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
358 usb_serial_port_softint(port);
361 static void usa26_inack_callback(struct urb *urb)
365 static void usa26_outcont_callback(struct urb *urb)
367 struct usb_serial_port *port;
368 struct keyspan_port_private *p_priv;
371 p_priv = usb_get_serial_port_data(port);
373 if (p_priv->resend_cont) {
374 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
375 keyspan_usa26_send_setup(port->serial, port,
376 p_priv->resend_cont - 1);
380 static void usa26_instat_callback(struct urb *urb)
382 unsigned char *data = urb->transfer_buffer;
383 struct keyspan_usa26_portStatusMessage *msg;
384 struct usb_serial *serial;
385 struct usb_serial_port *port;
386 struct keyspan_port_private *p_priv;
387 struct tty_struct *tty;
388 int old_dcd_state, err;
389 int status = urb->status;
391 serial = urb->context;
394 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
397 if (urb->actual_length != 9) {
398 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
402 msg = (struct keyspan_usa26_portStatusMessage *)data;
405 dev_dbg(&urb->dev->dev,
406 "%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
407 __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr,
408 msg->ri, msg->_txOff, msg->_txXoff, msg->rxEnabled,
409 msg->controlResponse);
412 /* Now do something useful with the data */
415 /* Check port number from message and retrieve private data */
416 if (msg->port >= serial->num_ports) {
417 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
420 port = serial->port[msg->port];
421 p_priv = usb_get_serial_port_data(port);
423 /* Update handshaking pin state information */
424 old_dcd_state = p_priv->dcd_state;
425 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
426 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
427 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
428 p_priv->ri_state = ((msg->ri) ? 1 : 0);
430 if (old_dcd_state != p_priv->dcd_state) {
431 tty = tty_port_tty_get(&port->port);
432 if (tty && !C_CLOCAL(tty))
437 /* Resubmit urb so we continue receiving */
438 err = usb_submit_urb(urb, GFP_ATOMIC);
440 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
444 static void usa26_glocont_callback(struct urb *urb)
449 static void usa28_indat_callback(struct urb *urb)
452 struct usb_serial_port *port;
453 struct tty_struct *tty;
455 struct keyspan_port_private *p_priv;
456 int status = urb->status;
459 p_priv = usb_get_serial_port_data(port);
460 data = urb->transfer_buffer;
462 if (urb != p_priv->in_urbs[p_priv->in_flip])
467 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
468 __func__, status, usb_pipeendpoint(urb->pipe));
473 p_priv = usb_get_serial_port_data(port);
474 data = urb->transfer_buffer;
476 tty = tty_port_tty_get(&port->port);
477 if (tty && urb->actual_length) {
478 tty_insert_flip_string(tty, data, urb->actual_length);
479 tty_flip_buffer_push(tty);
483 /* Resubmit urb so we continue receiving */
484 err = usb_submit_urb(urb, GFP_ATOMIC);
486 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
488 p_priv->in_flip ^= 1;
490 urb = p_priv->in_urbs[p_priv->in_flip];
491 } while (urb->status != -EINPROGRESS);
494 static void usa28_inack_callback(struct urb *urb)
498 static void usa28_outcont_callback(struct urb *urb)
500 struct usb_serial_port *port;
501 struct keyspan_port_private *p_priv;
504 p_priv = usb_get_serial_port_data(port);
506 if (p_priv->resend_cont) {
507 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
508 keyspan_usa28_send_setup(port->serial, port,
509 p_priv->resend_cont - 1);
513 static void usa28_instat_callback(struct urb *urb)
516 unsigned char *data = urb->transfer_buffer;
517 struct keyspan_usa28_portStatusMessage *msg;
518 struct usb_serial *serial;
519 struct usb_serial_port *port;
520 struct keyspan_port_private *p_priv;
521 struct tty_struct *tty;
523 int status = urb->status;
525 serial = urb->context;
528 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
532 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
533 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
538 dev_dbg(&urb->dev->dev,
539 "%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__,
540 data[0], data[1], data[2], data[3], data[4], data[5],
541 data[6], data[7], data[8], data[9], data[10], data[11]);
544 /* Now do something useful with the data */
545 msg = (struct keyspan_usa28_portStatusMessage *)data;
547 /* Check port number from message and retrieve private data */
548 if (msg->port >= serial->num_ports) {
549 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
552 port = serial->port[msg->port];
553 p_priv = usb_get_serial_port_data(port);
555 /* Update handshaking pin state information */
556 old_dcd_state = p_priv->dcd_state;
557 p_priv->cts_state = ((msg->cts) ? 1 : 0);
558 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
559 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
560 p_priv->ri_state = ((msg->ri) ? 1 : 0);
562 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
563 tty = tty_port_tty_get(&port->port);
564 if (tty && !C_CLOCAL(tty))
569 /* Resubmit urb so we continue receiving */
570 err = usb_submit_urb(urb, GFP_ATOMIC);
572 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
576 static void usa28_glocont_callback(struct urb *urb)
581 static void usa49_glocont_callback(struct urb *urb)
583 struct usb_serial *serial;
584 struct usb_serial_port *port;
585 struct keyspan_port_private *p_priv;
588 serial = urb->context;
589 for (i = 0; i < serial->num_ports; ++i) {
590 port = serial->port[i];
591 p_priv = usb_get_serial_port_data(port);
593 if (p_priv->resend_cont) {
594 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
595 keyspan_usa49_send_setup(serial, port,
596 p_priv->resend_cont - 1);
602 /* This is actually called glostat in the Keyspan
604 static void usa49_instat_callback(struct urb *urb)
607 unsigned char *data = urb->transfer_buffer;
608 struct keyspan_usa49_portStatusMessage *msg;
609 struct usb_serial *serial;
610 struct usb_serial_port *port;
611 struct keyspan_port_private *p_priv;
613 int status = urb->status;
615 serial = urb->context;
618 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
622 if (urb->actual_length !=
623 sizeof(struct keyspan_usa49_portStatusMessage)) {
624 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
629 dev_dbg(&urb->dev->dev, "%s: %x %x %x %x %x %x %x %x %x %x %x",
630 __func__, data[0], data[1], data[2], data[3], data[4],
631 data[5], data[6], data[7], data[8], data[9], data[10]);
634 /* Now do something useful with the data */
635 msg = (struct keyspan_usa49_portStatusMessage *)data;
637 /* Check port number from message and retrieve private data */
638 if (msg->portNumber >= serial->num_ports) {
639 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
640 __func__, msg->portNumber);
643 port = serial->port[msg->portNumber];
644 p_priv = usb_get_serial_port_data(port);
646 /* Update handshaking pin state information */
647 old_dcd_state = p_priv->dcd_state;
648 p_priv->cts_state = ((msg->cts) ? 1 : 0);
649 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
650 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
651 p_priv->ri_state = ((msg->ri) ? 1 : 0);
653 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
654 struct tty_struct *tty = tty_port_tty_get(&port->port);
655 if (tty && !C_CLOCAL(tty))
660 /* Resubmit urb so we continue receiving */
661 err = usb_submit_urb(urb, GFP_ATOMIC);
663 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
667 static void usa49_inack_callback(struct urb *urb)
671 static void usa49_indat_callback(struct urb *urb)
675 struct usb_serial_port *port;
676 struct tty_struct *tty;
677 unsigned char *data = urb->transfer_buffer;
678 int status = urb->status;
680 endpoint = usb_pipeendpoint(urb->pipe);
683 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
684 __func__, status, endpoint);
689 tty = tty_port_tty_get(&port->port);
690 if (tty && urb->actual_length) {
691 /* 0x80 bit is error flag */
692 if ((data[0] & 0x80) == 0) {
693 /* no error on any byte */
694 tty_insert_flip_string(tty, data + 1,
695 urb->actual_length - 1);
697 /* some bytes had errors, every byte has status */
698 for (i = 0; i + 1 < urb->actual_length; i += 2) {
699 int stat = data[i], flag = 0;
700 if (stat & RXERROR_OVERRUN)
702 if (stat & RXERROR_FRAMING)
704 if (stat & RXERROR_PARITY)
706 /* XXX should handle break (0x10) */
707 tty_insert_flip_char(tty, data[i+1], flag);
710 tty_flip_buffer_push(tty);
714 /* Resubmit urb so we continue receiving */
715 err = usb_submit_urb(urb, GFP_ATOMIC);
717 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
720 static void usa49wg_indat_callback(struct urb *urb)
723 struct usb_serial *serial;
724 struct usb_serial_port *port;
725 struct tty_struct *tty;
726 unsigned char *data = urb->transfer_buffer;
727 int status = urb->status;
729 serial = urb->context;
732 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
736 /* inbound data is in the form P#, len, status, data */
740 if (urb->actual_length) {
741 while (i < urb->actual_length) {
743 /* Check port number from message*/
744 if (data[i] >= serial->num_ports) {
745 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
749 port = serial->port[data[i++]];
750 tty = tty_port_tty_get(&port->port);
753 /* 0x80 bit is error flag */
754 if ((data[i] & 0x80) == 0) {
755 /* no error on any byte */
757 for (x = 1; x < len ; ++x)
758 tty_insert_flip_char(tty, data[i++], 0);
761 * some bytes had errors, every byte has status
763 for (x = 0; x + 1 < len; x += 2) {
764 int stat = data[i], flag = 0;
765 if (stat & RXERROR_OVERRUN)
767 if (stat & RXERROR_FRAMING)
769 if (stat & RXERROR_PARITY)
771 /* XXX should handle break (0x10) */
772 tty_insert_flip_char(tty,
777 tty_flip_buffer_push(tty);
782 /* Resubmit urb so we continue receiving */
783 err = usb_submit_urb(urb, GFP_ATOMIC);
785 dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
788 /* not used, usa-49 doesn't have per-port control endpoints */
789 static void usa49_outcont_callback(struct urb *urb)
793 static void usa90_indat_callback(struct urb *urb)
797 struct usb_serial_port *port;
798 struct keyspan_port_private *p_priv;
799 struct tty_struct *tty;
800 unsigned char *data = urb->transfer_buffer;
801 int status = urb->status;
803 endpoint = usb_pipeendpoint(urb->pipe);
806 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
807 __func__, status, endpoint);
812 p_priv = usb_get_serial_port_data(port);
814 if (urb->actual_length) {
815 tty = tty_port_tty_get(&port->port);
816 /* if current mode is DMA, looks like usa28 format
817 otherwise looks like usa26 data format */
819 if (p_priv->baud > 57600)
820 tty_insert_flip_string(tty, data, urb->actual_length);
822 /* 0x80 bit is error flag */
823 if ((data[0] & 0x80) == 0) {
824 /* no errors on individual bytes, only
825 possible overrun err*/
826 if (data[0] & RXERROR_OVERRUN)
830 for (i = 1; i < urb->actual_length ; ++i)
831 tty_insert_flip_char(tty, data[i],
834 /* some bytes had errors, every byte has status */
835 dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
836 for (i = 0; i + 1 < urb->actual_length; i += 2) {
837 int stat = data[i], flag = 0;
838 if (stat & RXERROR_OVERRUN)
840 if (stat & RXERROR_FRAMING)
842 if (stat & RXERROR_PARITY)
844 /* XXX should handle break (0x10) */
845 tty_insert_flip_char(tty, data[i+1],
850 tty_flip_buffer_push(tty);
854 /* Resubmit urb so we continue receiving */
855 err = usb_submit_urb(urb, GFP_ATOMIC);
857 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
861 static void usa90_instat_callback(struct urb *urb)
863 unsigned char *data = urb->transfer_buffer;
864 struct keyspan_usa90_portStatusMessage *msg;
865 struct usb_serial *serial;
866 struct usb_serial_port *port;
867 struct keyspan_port_private *p_priv;
868 struct tty_struct *tty;
869 int old_dcd_state, err;
870 int status = urb->status;
872 serial = urb->context;
875 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
878 if (urb->actual_length < 14) {
879 dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
883 msg = (struct keyspan_usa90_portStatusMessage *)data;
885 /* Now do something useful with the data */
887 port = serial->port[0];
888 p_priv = usb_get_serial_port_data(port);
890 /* Update handshaking pin state information */
891 old_dcd_state = p_priv->dcd_state;
892 p_priv->cts_state = ((msg->cts) ? 1 : 0);
893 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
894 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
895 p_priv->ri_state = ((msg->ri) ? 1 : 0);
897 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
898 tty = tty_port_tty_get(&port->port);
899 if (tty && !C_CLOCAL(tty))
904 /* Resubmit urb so we continue receiving */
905 err = usb_submit_urb(urb, GFP_ATOMIC);
907 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
912 static void usa90_outcont_callback(struct urb *urb)
914 struct usb_serial_port *port;
915 struct keyspan_port_private *p_priv;
918 p_priv = usb_get_serial_port_data(port);
920 if (p_priv->resend_cont) {
921 dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
922 keyspan_usa90_send_setup(port->serial, port,
923 p_priv->resend_cont - 1);
927 /* Status messages from the 28xg */
928 static void usa67_instat_callback(struct urb *urb)
931 unsigned char *data = urb->transfer_buffer;
932 struct keyspan_usa67_portStatusMessage *msg;
933 struct usb_serial *serial;
934 struct usb_serial_port *port;
935 struct keyspan_port_private *p_priv;
937 int status = urb->status;
939 serial = urb->context;
942 dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
946 if (urb->actual_length !=
947 sizeof(struct keyspan_usa67_portStatusMessage)) {
948 dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
953 /* Now do something useful with the data */
954 msg = (struct keyspan_usa67_portStatusMessage *)data;
956 /* Check port number from message and retrieve private data */
957 if (msg->port >= serial->num_ports) {
958 dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
962 port = serial->port[msg->port];
963 p_priv = usb_get_serial_port_data(port);
965 /* Update handshaking pin state information */
966 old_dcd_state = p_priv->dcd_state;
967 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
968 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
970 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
971 struct tty_struct *tty = tty_port_tty_get(&port->port);
972 if (tty && !C_CLOCAL(tty))
977 /* Resubmit urb so we continue receiving */
978 err = usb_submit_urb(urb, GFP_ATOMIC);
980 dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
983 static void usa67_glocont_callback(struct urb *urb)
985 struct usb_serial *serial;
986 struct usb_serial_port *port;
987 struct keyspan_port_private *p_priv;
990 serial = urb->context;
991 for (i = 0; i < serial->num_ports; ++i) {
992 port = serial->port[i];
993 p_priv = usb_get_serial_port_data(port);
995 if (p_priv->resend_cont) {
996 dev_dbg(&port->dev, "%s - sending setup\n", __func__);
997 keyspan_usa67_send_setup(serial, port,
998 p_priv->resend_cont - 1);
1004 static int keyspan_write_room(struct tty_struct *tty)
1006 struct usb_serial_port *port = tty->driver_data;
1007 struct keyspan_port_private *p_priv;
1008 const struct keyspan_device_details *d_details;
1011 struct urb *this_urb;
1013 p_priv = usb_get_serial_port_data(port);
1014 d_details = p_priv->device_details;
1016 /* FIXME: locking */
1017 if (d_details->msg_format == msg_usa90)
1022 flip = p_priv->out_flip;
1024 /* Check both endpoints to see if any are available. */
1025 this_urb = p_priv->out_urbs[flip];
1026 if (this_urb != NULL) {
1027 if (this_urb->status != -EINPROGRESS)
1029 flip = (flip + 1) & d_details->outdat_endp_flip;
1030 this_urb = p_priv->out_urbs[flip];
1031 if (this_urb != NULL) {
1032 if (this_urb->status != -EINPROGRESS)
1040 static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1042 struct keyspan_port_private *p_priv;
1043 const struct keyspan_device_details *d_details;
1045 int baud_rate, device_port;
1047 unsigned int cflag = 0;
1049 p_priv = usb_get_serial_port_data(port);
1050 d_details = p_priv->device_details;
1052 /* Set some sane defaults */
1053 p_priv->rts_state = 1;
1054 p_priv->dtr_state = 1;
1055 p_priv->baud = 9600;
1057 /* force baud and lcr to be set on open */
1058 p_priv->old_baud = 0;
1059 p_priv->old_cflag = 0;
1061 p_priv->out_flip = 0;
1062 p_priv->in_flip = 0;
1064 /* Reset low level data toggle and start reading from endpoints */
1065 for (i = 0; i < 2; i++) {
1066 urb = p_priv->in_urbs[i];
1070 /* make sure endpoint data toggle is synchronized
1072 usb_clear_halt(urb->dev, urb->pipe);
1073 err = usb_submit_urb(urb, GFP_KERNEL);
1075 dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
1078 /* Reset low level data toggle on out endpoints */
1079 for (i = 0; i < 2; i++) {
1080 urb = p_priv->out_urbs[i];
1083 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1084 usb_pipeout(urb->pipe), 0); */
1087 /* get the terminal config for the setup message now so we don't
1088 * need to send 2 of them */
1090 device_port = port->number - port->serial->minor;
1092 cflag = tty->termios.c_cflag;
1093 /* Baud rate calculation takes baud rate as an integer
1094 so other rates can be generated if desired. */
1095 baud_rate = tty_get_baud_rate(tty);
1096 /* If no match or invalid, leave as default */
1098 && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
1099 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1100 p_priv->baud = baud_rate;
1103 /* set CTS/RTS handshake etc. */
1104 p_priv->cflag = cflag;
1105 p_priv->flow_control = (cflag & CRTSCTS) ? flow_cts : flow_none;
1107 keyspan_send_setup(port, 1);
1109 /* keyspan_set_termios(port, NULL); */
1114 static inline void stop_urb(struct urb *urb)
1116 if (urb && urb->status == -EINPROGRESS)
1120 static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1122 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1124 p_priv->rts_state = on;
1125 p_priv->dtr_state = on;
1126 keyspan_send_setup(port, 0);
1129 static void keyspan_close(struct usb_serial_port *port)
1132 struct usb_serial *serial = port->serial;
1133 struct keyspan_port_private *p_priv;
1135 p_priv = usb_get_serial_port_data(port);
1137 p_priv->rts_state = 0;
1138 p_priv->dtr_state = 0;
1141 keyspan_send_setup(port, 2);
1142 /* pilot-xfer seems to work best with this delay */
1144 /* keyspan_set_termios(port, NULL); */
1147 /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
1148 dev_dbg(&port->dev, "%s - urb in progress\n", __func__);
1151 p_priv->out_flip = 0;
1152 p_priv->in_flip = 0;
1155 /* Stop reading/writing urbs */
1156 stop_urb(p_priv->inack_urb);
1157 /* stop_urb(p_priv->outcont_urb); */
1158 for (i = 0; i < 2; i++) {
1159 stop_urb(p_priv->in_urbs[i]);
1160 stop_urb(p_priv->out_urbs[i]);
1165 /* download the firmware to a pre-renumeration device */
1166 static int keyspan_fake_startup(struct usb_serial *serial)
1170 dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
1171 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1172 le16_to_cpu(serial->dev->descriptor.idProduct));
1174 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1176 dev_dbg(&serial->dev->dev, "Firmware already loaded. Quitting.\n");
1180 /* Select firmware image on the basis of idProduct */
1181 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1182 case keyspan_usa28_pre_product_id:
1183 fw_name = "keyspan/usa28.fw";
1186 case keyspan_usa28x_pre_product_id:
1187 fw_name = "keyspan/usa28x.fw";
1190 case keyspan_usa28xa_pre_product_id:
1191 fw_name = "keyspan/usa28xa.fw";
1194 case keyspan_usa28xb_pre_product_id:
1195 fw_name = "keyspan/usa28xb.fw";
1198 case keyspan_usa19_pre_product_id:
1199 fw_name = "keyspan/usa19.fw";
1202 case keyspan_usa19qi_pre_product_id:
1203 fw_name = "keyspan/usa19qi.fw";
1206 case keyspan_mpr_pre_product_id:
1207 fw_name = "keyspan/mpr.fw";
1210 case keyspan_usa19qw_pre_product_id:
1211 fw_name = "keyspan/usa19qw.fw";
1214 case keyspan_usa18x_pre_product_id:
1215 fw_name = "keyspan/usa18x.fw";
1218 case keyspan_usa19w_pre_product_id:
1219 fw_name = "keyspan/usa19w.fw";
1222 case keyspan_usa49w_pre_product_id:
1223 fw_name = "keyspan/usa49w.fw";
1226 case keyspan_usa49wlc_pre_product_id:
1227 fw_name = "keyspan/usa49wlc.fw";
1231 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1232 le16_to_cpu(serial->dev->descriptor.idProduct));
1236 dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
1238 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
1239 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
1244 /* after downloading firmware Renumeration will occur in a
1245 moment and the new device will bind to the real driver */
1247 /* we don't want this device to have a driver assigned to it. */
1251 /* Helper functions used by keyspan_setup_urbs */
1252 static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1255 struct usb_host_interface *iface_desc;
1256 struct usb_endpoint_descriptor *ep;
1259 iface_desc = serial->interface->cur_altsetting;
1260 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1261 ep = &iface_desc->endpoint[i].desc;
1262 if (ep->bEndpointAddress == endpoint)
1265 dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1266 "endpoint %x\n", endpoint);
1270 static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
1271 int dir, void *ctx, char *buf, int len,
1272 void (*callback)(struct urb *))
1275 struct usb_endpoint_descriptor const *ep_desc;
1276 char const *ep_type_name;
1279 return NULL; /* endpoint not needed */
1281 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
1282 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1284 dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d failed.\n", __func__, endpoint);
1288 if (endpoint == 0) {
1289 /* control EP filled in when used */
1293 ep_desc = find_ep(serial, endpoint);
1295 /* leak the urb, something's wrong and the callers don't care */
1298 if (usb_endpoint_xfer_int(ep_desc)) {
1299 ep_type_name = "INT";
1300 usb_fill_int_urb(urb, serial->dev,
1301 usb_sndintpipe(serial->dev, endpoint) | dir,
1302 buf, len, callback, ctx,
1303 ep_desc->bInterval);
1304 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1305 ep_type_name = "BULK";
1306 usb_fill_bulk_urb(urb, serial->dev,
1307 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1308 buf, len, callback, ctx);
1310 dev_warn(&serial->interface->dev,
1311 "unsupported endpoint type %x\n",
1312 usb_endpoint_type(ep_desc));
1317 dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
1318 __func__, urb, ep_type_name, endpoint);
1322 static struct callbacks {
1323 void (*instat_callback)(struct urb *);
1324 void (*glocont_callback)(struct urb *);
1325 void (*indat_callback)(struct urb *);
1326 void (*outdat_callback)(struct urb *);
1327 void (*inack_callback)(struct urb *);
1328 void (*outcont_callback)(struct urb *);
1329 } keyspan_callbacks[] = {
1331 /* msg_usa26 callbacks */
1332 .instat_callback = usa26_instat_callback,
1333 .glocont_callback = usa26_glocont_callback,
1334 .indat_callback = usa26_indat_callback,
1335 .outdat_callback = usa2x_outdat_callback,
1336 .inack_callback = usa26_inack_callback,
1337 .outcont_callback = usa26_outcont_callback,
1339 /* msg_usa28 callbacks */
1340 .instat_callback = usa28_instat_callback,
1341 .glocont_callback = usa28_glocont_callback,
1342 .indat_callback = usa28_indat_callback,
1343 .outdat_callback = usa2x_outdat_callback,
1344 .inack_callback = usa28_inack_callback,
1345 .outcont_callback = usa28_outcont_callback,
1347 /* msg_usa49 callbacks */
1348 .instat_callback = usa49_instat_callback,
1349 .glocont_callback = usa49_glocont_callback,
1350 .indat_callback = usa49_indat_callback,
1351 .outdat_callback = usa2x_outdat_callback,
1352 .inack_callback = usa49_inack_callback,
1353 .outcont_callback = usa49_outcont_callback,
1355 /* msg_usa90 callbacks */
1356 .instat_callback = usa90_instat_callback,
1357 .glocont_callback = usa28_glocont_callback,
1358 .indat_callback = usa90_indat_callback,
1359 .outdat_callback = usa2x_outdat_callback,
1360 .inack_callback = usa28_inack_callback,
1361 .outcont_callback = usa90_outcont_callback,
1363 /* msg_usa67 callbacks */
1364 .instat_callback = usa67_instat_callback,
1365 .glocont_callback = usa67_glocont_callback,
1366 .indat_callback = usa26_indat_callback,
1367 .outdat_callback = usa2x_outdat_callback,
1368 .inack_callback = usa26_inack_callback,
1369 .outcont_callback = usa26_outcont_callback,
1373 /* Generic setup urbs function that uses
1374 data in device_details */
1375 static void keyspan_setup_urbs(struct usb_serial *serial)
1378 struct keyspan_serial_private *s_priv;
1379 const struct keyspan_device_details *d_details;
1380 struct usb_serial_port *port;
1381 struct keyspan_port_private *p_priv;
1382 struct callbacks *cback;
1385 s_priv = usb_get_serial_data(serial);
1386 d_details = s_priv->device_details;
1388 /* Setup values for the various callback routines */
1389 cback = &keyspan_callbacks[d_details->msg_format];
1391 /* Allocate and set up urbs for each one that is in use,
1392 starting with instat endpoints */
1393 s_priv->instat_urb = keyspan_setup_urb
1394 (serial, d_details->instat_endpoint, USB_DIR_IN,
1395 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1396 cback->instat_callback);
1398 s_priv->indat_urb = keyspan_setup_urb
1399 (serial, d_details->indat_endpoint, USB_DIR_IN,
1400 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1401 usa49wg_indat_callback);
1403 s_priv->glocont_urb = keyspan_setup_urb
1404 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1405 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1406 cback->glocont_callback);
1408 /* Setup endpoints for each port specific thing */
1409 for (i = 0; i < d_details->num_ports; i++) {
1410 port = serial->port[i];
1411 p_priv = usb_get_serial_port_data(port);
1413 /* Do indat endpoints first, once for each flip */
1414 endp = d_details->indat_endpoints[i];
1415 for (j = 0; j <= d_details->indat_endp_flip; ++j, ++endp) {
1416 p_priv->in_urbs[j] = keyspan_setup_urb
1417 (serial, endp, USB_DIR_IN, port,
1418 p_priv->in_buffer[j], 64,
1419 cback->indat_callback);
1422 p_priv->in_urbs[j] = NULL;
1424 /* outdat endpoints also have flip */
1425 endp = d_details->outdat_endpoints[i];
1426 for (j = 0; j <= d_details->outdat_endp_flip; ++j, ++endp) {
1427 p_priv->out_urbs[j] = keyspan_setup_urb
1428 (serial, endp, USB_DIR_OUT, port,
1429 p_priv->out_buffer[j], 64,
1430 cback->outdat_callback);
1433 p_priv->out_urbs[j] = NULL;
1435 /* inack endpoint */
1436 p_priv->inack_urb = keyspan_setup_urb
1437 (serial, d_details->inack_endpoints[i], USB_DIR_IN,
1438 port, p_priv->inack_buffer, 1, cback->inack_callback);
1440 /* outcont endpoint */
1441 p_priv->outcont_urb = keyspan_setup_urb
1442 (serial, d_details->outcont_endpoints[i], USB_DIR_OUT,
1443 port, p_priv->outcont_buffer, 64,
1444 cback->outcont_callback);
1448 /* usa19 function doesn't require prescaler */
1449 static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
1450 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1451 u8 *rate_low, u8 *prescaler, int portnum)
1453 u32 b16, /* baud rate times 16 (actual rate used internally) */
1455 cnt; /* inverse of divisor (programmed into 8051) */
1457 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1459 /* prevent divide by zero... */
1460 b16 = baud_rate * 16L;
1462 return KEYSPAN_INVALID_BAUD_RATE;
1463 /* Any "standard" rate over 57k6 is marginal on the USA-19
1464 as we run out of divisor resolution. */
1465 if (baud_rate > 57600)
1466 return KEYSPAN_INVALID_BAUD_RATE;
1468 /* calculate the divisor and the counter (its inverse) */
1469 div = baudclk / b16;
1471 return KEYSPAN_INVALID_BAUD_RATE;
1476 return KEYSPAN_INVALID_BAUD_RATE;
1478 /* return the counter values if non-null */
1480 *rate_low = (u8) (cnt & 0xff);
1482 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1483 if (rate_low && rate_hi)
1484 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1485 __func__, baud_rate, *rate_hi, *rate_low);
1486 return KEYSPAN_BAUD_RATE_OK;
1489 /* usa19hs function doesn't require prescaler */
1490 static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
1491 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1492 u8 *rate_low, u8 *prescaler, int portnum)
1494 u32 b16, /* baud rate times 16 (actual rate used internally) */
1497 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1499 /* prevent divide by zero... */
1500 b16 = baud_rate * 16L;
1502 return KEYSPAN_INVALID_BAUD_RATE;
1504 /* calculate the divisor */
1505 div = baudclk / b16;
1507 return KEYSPAN_INVALID_BAUD_RATE;
1510 return KEYSPAN_INVALID_BAUD_RATE;
1512 /* return the counter values if non-null */
1514 *rate_low = (u8) (div & 0xff);
1517 *rate_hi = (u8) ((div >> 8) & 0xff);
1519 if (rate_low && rate_hi)
1520 dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
1521 __func__, baud_rate, *rate_hi, *rate_low);
1523 return KEYSPAN_BAUD_RATE_OK;
1526 static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
1527 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1528 u8 *rate_low, u8 *prescaler, int portnum)
1530 u32 b16, /* baud rate times 16 (actual rate used internally) */
1531 clk, /* clock with 13/8 prescaler */
1532 div, /* divisor using 13/8 prescaler */
1533 res, /* resulting baud rate using 13/8 prescaler */
1534 diff, /* error using 13/8 prescaler */
1539 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1541 /* prevent divide by zero */
1542 b16 = baud_rate * 16L;
1544 return KEYSPAN_INVALID_BAUD_RATE;
1546 /* Calculate prescaler by trying them all and looking
1549 /* start with largest possible difference */
1550 smallest_diff = 0xffffffff;
1552 /* 0 is an invalid prescaler, used as a flag */
1555 for (i = 8; i <= 0xff; ++i) {
1556 clk = (baudclk * 8) / (u32) i;
1563 diff = (res > b16) ? (res-b16) : (b16-res);
1565 if (diff < smallest_diff) {
1567 smallest_diff = diff;
1571 if (best_prescaler == 0)
1572 return KEYSPAN_INVALID_BAUD_RATE;
1574 clk = (baudclk * 8) / (u32) best_prescaler;
1577 /* return the divisor and prescaler if non-null */
1579 *rate_low = (u8) (div & 0xff);
1581 *rate_hi = (u8) ((div >> 8) & 0xff);
1583 *prescaler = best_prescaler;
1584 /* dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
1586 return KEYSPAN_BAUD_RATE_OK;
1589 /* USA-28 supports different maximum baud rates on each port */
1590 static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
1591 u32 baud_rate, u32 baudclk, u8 *rate_hi,
1592 u8 *rate_low, u8 *prescaler, int portnum)
1594 u32 b16, /* baud rate times 16 (actual rate used internally) */
1596 cnt; /* inverse of divisor (programmed into 8051) */
1598 dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
1600 /* prevent divide by zero */
1601 b16 = baud_rate * 16L;
1603 return KEYSPAN_INVALID_BAUD_RATE;
1605 /* calculate the divisor and the counter (its inverse) */
1606 div = KEYSPAN_USA28_BAUDCLK / b16;
1608 return KEYSPAN_INVALID_BAUD_RATE;
1612 /* check for out of range, based on portnum,
1613 and return result */
1616 return KEYSPAN_INVALID_BAUD_RATE;
1620 return KEYSPAN_INVALID_BAUD_RATE;
1622 return KEYSPAN_INVALID_BAUD_RATE;
1625 /* return the counter values if not NULL
1626 (port 1 will ignore retHi) */
1628 *rate_low = (u8) (cnt & 0xff);
1630 *rate_hi = (u8) ((cnt >> 8) & 0xff);
1631 dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
1632 return KEYSPAN_BAUD_RATE_OK;
1635 static int keyspan_usa26_send_setup(struct usb_serial *serial,
1636 struct usb_serial_port *port,
1639 struct keyspan_usa26_portControlMessage msg;
1640 struct keyspan_serial_private *s_priv;
1641 struct keyspan_port_private *p_priv;
1642 const struct keyspan_device_details *d_details;
1644 struct urb *this_urb;
1645 int device_port, err;
1647 dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
1649 s_priv = usb_get_serial_data(serial);
1650 p_priv = usb_get_serial_port_data(port);
1651 d_details = s_priv->device_details;
1652 device_port = port->number - port->serial->minor;
1654 outcont_urb = d_details->outcont_endpoints[port->number];
1655 this_urb = p_priv->outcont_urb;
1657 dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
1659 /* Make sure we have an urb then send the message */
1660 if (this_urb == NULL) {
1661 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1665 /* Save reset port val for resend.
1666 Don't overwrite resend for open/close condition. */
1667 if ((reset_port + 1) > p_priv->resend_cont)
1668 p_priv->resend_cont = reset_port + 1;
1669 if (this_urb->status == -EINPROGRESS) {
1670 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1675 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
1677 /* Only set baud rate if it's changed */
1678 if (p_priv->old_baud != p_priv->baud) {
1679 p_priv->old_baud = p_priv->baud;
1680 msg.setClocking = 0xff;
1681 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1682 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1683 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1684 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1685 __func__, p_priv->baud);
1687 msg.baudHi = 125; /* Values for 9600 baud */
1690 msg.setPrescaler = 0xff;
1693 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1694 switch (p_priv->cflag & CSIZE) {
1696 msg.lcr |= USA_DATABITS_5;
1699 msg.lcr |= USA_DATABITS_6;
1702 msg.lcr |= USA_DATABITS_7;
1705 msg.lcr |= USA_DATABITS_8;
1708 if (p_priv->cflag & PARENB) {
1709 /* note USA_PARITY_NONE == 0 */
1710 msg.lcr |= (p_priv->cflag & PARODD) ?
1711 USA_PARITY_ODD : USA_PARITY_EVEN;
1715 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1716 msg.xonFlowControl = 0;
1717 msg.setFlowControl = 0xff;
1718 msg.forwardingLength = 16;
1723 if (reset_port == 1) {
1732 msg.returnStatus = 0;
1733 msg.resetDataToggle = 0xff;
1737 else if (reset_port == 2) {
1746 msg.returnStatus = 0;
1747 msg.resetDataToggle = 0;
1750 /* Sending intermediate configs */
1752 msg._txOn = (!p_priv->break_on);
1755 msg.txBreak = (p_priv->break_on);
1760 msg.returnStatus = 0;
1761 msg.resetDataToggle = 0x0;
1764 /* Do handshaking outputs */
1765 msg.setTxTriState_setRts = 0xff;
1766 msg.txTriState_rts = p_priv->rts_state;
1768 msg.setHskoa_setDtr = 0xff;
1769 msg.hskoa_dtr = p_priv->dtr_state;
1771 p_priv->resend_cont = 0;
1772 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1774 /* send the data out the device on control endpoint */
1775 this_urb->transfer_buffer_length = sizeof(msg);
1777 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1779 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
1782 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__
1783 outcont_urb, this_urb->transfer_buffer_length,
1784 usb_pipeendpoint(this_urb->pipe));
1791 static int keyspan_usa28_send_setup(struct usb_serial *serial,
1792 struct usb_serial_port *port,
1795 struct keyspan_usa28_portControlMessage msg;
1796 struct keyspan_serial_private *s_priv;
1797 struct keyspan_port_private *p_priv;
1798 const struct keyspan_device_details *d_details;
1799 struct urb *this_urb;
1800 int device_port, err;
1802 s_priv = usb_get_serial_data(serial);
1803 p_priv = usb_get_serial_port_data(port);
1804 d_details = s_priv->device_details;
1805 device_port = port->number - port->serial->minor;
1807 /* only do something if we have a bulk out endpoint */
1808 this_urb = p_priv->outcont_urb;
1809 if (this_urb == NULL) {
1810 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
1814 /* Save reset port val for resend.
1815 Don't overwrite resend for open/close condition. */
1816 if ((reset_port + 1) > p_priv->resend_cont)
1817 p_priv->resend_cont = reset_port + 1;
1818 if (this_urb->status == -EINPROGRESS) {
1819 dev_dbg(&port->dev, "%s already writing\n", __func__);
1824 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
1826 msg.setBaudRate = 1;
1827 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1828 &msg.baudHi, &msg.baudLo, NULL,
1829 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1830 dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
1831 __func__, p_priv->baud);
1833 msg.baudHi = 0xb2; /* Values for 9600 baud */
1836 /* If parity is enabled, we must calculate it ourselves. */
1837 msg.parity = 0; /* XXX for now */
1839 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1840 msg.xonFlowControl = 0;
1842 /* Do handshaking outputs, DTR is inverted relative to RTS */
1843 msg.rts = p_priv->rts_state;
1844 msg.dtr = p_priv->dtr_state;
1846 msg.forwardingLength = 16;
1848 msg.breakThreshold = 45;
1852 /*msg.returnStatus = 1;
1853 msg.resetDataToggle = 0xff;*/
1855 if (reset_port == 1) {
1859 msg.txForceXoff = 0;
1865 msg.returnStatus = 0;
1866 msg.resetDataToggle = 0xff;
1869 else if (reset_port == 2) {
1873 msg.txForceXoff = 0;
1879 msg.returnStatus = 0;
1880 msg.resetDataToggle = 0;
1882 /* Sending intermediate configs */
1884 msg._txOn = (!p_priv->break_on);
1887 msg.txForceXoff = 0;
1888 msg.txBreak = (p_priv->break_on);
1893 msg.returnStatus = 0;
1894 msg.resetDataToggle = 0x0;
1897 p_priv->resend_cont = 0;
1898 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1900 /* send the data out the device on control endpoint */
1901 this_urb->transfer_buffer_length = sizeof(msg);
1903 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1905 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
1908 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) OK %d bytes\n", __func__,
1909 this_urb->transfer_buffer_length);
1916 static int keyspan_usa49_send_setup(struct usb_serial *serial,
1917 struct usb_serial_port *port,
1920 struct keyspan_usa49_portControlMessage msg;
1921 struct usb_ctrlrequest *dr = NULL;
1922 struct keyspan_serial_private *s_priv;
1923 struct keyspan_port_private *p_priv;
1924 const struct keyspan_device_details *d_details;
1925 struct urb *this_urb;
1926 int err, device_port;
1928 s_priv = usb_get_serial_data(serial);
1929 p_priv = usb_get_serial_port_data(port);
1930 d_details = s_priv->device_details;
1932 this_urb = s_priv->glocont_urb;
1934 /* Work out which port within the device is being setup */
1935 device_port = port->number - port->serial->minor;
1937 /* Make sure we have an urb then send the message */
1938 if (this_urb == NULL) {
1939 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__, port->number);
1943 dev_dbg(&port->dev, "%s - endpoint %d port %d (%d)\n",
1944 __func__, usb_pipeendpoint(this_urb->pipe),
1945 port->number, device_port);
1947 /* Save reset port val for resend.
1948 Don't overwrite resend for open/close condition. */
1949 if ((reset_port + 1) > p_priv->resend_cont)
1950 p_priv->resend_cont = reset_port + 1;
1952 if (this_urb->status == -EINPROGRESS) {
1953 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
1958 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
1960 /*msg.portNumber = port->number;*/
1961 msg.portNumber = device_port;
1963 /* Only set baud rate if it's changed */
1964 if (p_priv->old_baud != p_priv->baud) {
1965 p_priv->old_baud = p_priv->baud;
1966 msg.setClocking = 0xff;
1967 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
1968 &msg.baudHi, &msg.baudLo, &msg.prescaler,
1969 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1970 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
1971 __func__, p_priv->baud);
1973 msg.baudHi = 125; /* Values for 9600 baud */
1976 /* msg.setPrescaler = 0xff; */
1979 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
1980 switch (p_priv->cflag & CSIZE) {
1982 msg.lcr |= USA_DATABITS_5;
1985 msg.lcr |= USA_DATABITS_6;
1988 msg.lcr |= USA_DATABITS_7;
1991 msg.lcr |= USA_DATABITS_8;
1994 if (p_priv->cflag & PARENB) {
1995 /* note USA_PARITY_NONE == 0 */
1996 msg.lcr |= (p_priv->cflag & PARODD) ?
1997 USA_PARITY_ODD : USA_PARITY_EVEN;
2001 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2002 msg.xonFlowControl = 0;
2003 msg.setFlowControl = 0xff;
2005 msg.forwardingLength = 16;
2010 if (reset_port == 1) {
2019 msg.returnStatus = 0;
2020 msg.resetDataToggle = 0xff;
2022 msg.disablePort = 0;
2025 else if (reset_port == 2) {
2034 msg.returnStatus = 0;
2035 msg.resetDataToggle = 0;
2037 msg.disablePort = 1;
2039 /* Sending intermediate configs */
2041 msg._txOn = (!p_priv->break_on);
2044 msg.txBreak = (p_priv->break_on);
2049 msg.returnStatus = 0;
2050 msg.resetDataToggle = 0x0;
2052 msg.disablePort = 0;
2055 /* Do handshaking outputs */
2057 msg.rts = p_priv->rts_state;
2060 msg.dtr = p_priv->dtr_state;
2062 p_priv->resend_cont = 0;
2064 /* if the device is a 49wg, we send control message on usb
2067 if (d_details->product_id == keyspan_usa49wg_product_id) {
2068 dr = (void *)(s_priv->ctrl_buf);
2069 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2070 dr->bRequest = 0xB0; /* 49wg control message */;
2073 dr->wLength = cpu_to_le16(sizeof(msg));
2075 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
2077 usb_fill_control_urb(this_urb, serial->dev,
2078 usb_sndctrlpipe(serial->dev, 0),
2079 (unsigned char *)dr, s_priv->glocont_buf,
2080 sizeof(msg), usa49_glocont_callback, serial);
2083 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2085 /* send the data out the device on control endpoint */
2086 this_urb->transfer_buffer_length = sizeof(msg);
2088 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2090 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2093 dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__,
2094 outcont_urb, this_urb->transfer_buffer_length,
2095 usb_pipeendpoint(this_urb->pipe));
2102 static int keyspan_usa90_send_setup(struct usb_serial *serial,
2103 struct usb_serial_port *port,
2106 struct keyspan_usa90_portControlMessage msg;
2107 struct keyspan_serial_private *s_priv;
2108 struct keyspan_port_private *p_priv;
2109 const struct keyspan_device_details *d_details;
2110 struct urb *this_urb;
2114 s_priv = usb_get_serial_data(serial);
2115 p_priv = usb_get_serial_port_data(port);
2116 d_details = s_priv->device_details;
2118 /* only do something if we have a bulk out endpoint */
2119 this_urb = p_priv->outcont_urb;
2120 if (this_urb == NULL) {
2121 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
2125 /* Save reset port val for resend.
2126 Don't overwrite resend for open/close condition. */
2127 if ((reset_port + 1) > p_priv->resend_cont)
2128 p_priv->resend_cont = reset_port + 1;
2129 if (this_urb->status == -EINPROGRESS) {
2130 dev_dbg(&port->dev, "%s already writing\n", __func__);
2135 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
2137 /* Only set baud rate if it's changed */
2138 if (p_priv->old_baud != p_priv->baud) {
2139 p_priv->old_baud = p_priv->baud;
2140 msg.setClocking = 0x01;
2141 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2142 &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2143 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2144 __func__, p_priv->baud);
2145 p_priv->baud = 9600;
2146 d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2147 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2153 /* modes must always be correctly specified */
2154 if (p_priv->baud > 57600) {
2155 msg.rxMode = RXMODE_DMA;
2156 msg.txMode = TXMODE_DMA;
2158 msg.rxMode = RXMODE_BYHAND;
2159 msg.txMode = TXMODE_BYHAND;
2162 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2163 switch (p_priv->cflag & CSIZE) {
2165 msg.lcr |= USA_DATABITS_5;
2168 msg.lcr |= USA_DATABITS_6;
2171 msg.lcr |= USA_DATABITS_7;
2174 msg.lcr |= USA_DATABITS_8;
2177 if (p_priv->cflag & PARENB) {
2178 /* note USA_PARITY_NONE == 0 */
2179 msg.lcr |= (p_priv->cflag & PARODD) ?
2180 USA_PARITY_ODD : USA_PARITY_EVEN;
2182 if (p_priv->old_cflag != p_priv->cflag) {
2183 p_priv->old_cflag = p_priv->cflag;
2187 if (p_priv->flow_control == flow_cts)
2188 msg.txFlowControl = TXFLOW_CTS;
2189 msg.setTxFlowControl = 0x01;
2190 msg.setRxFlowControl = 0x01;
2192 msg.rxForwardingLength = 16;
2193 msg.rxForwardingTimeout = 16;
2194 msg.txAckSetting = 0;
2199 if (reset_port == 1) {
2200 msg.portEnabled = 1;
2202 msg.txBreak = (p_priv->break_on);
2205 else if (reset_port == 2)
2206 msg.portEnabled = 0;
2207 /* Sending intermediate configs */
2209 msg.portEnabled = 1;
2210 msg.txBreak = (p_priv->break_on);
2213 /* Do handshaking outputs */
2215 msg.rts = p_priv->rts_state;
2218 msg.dtr = p_priv->dtr_state;
2220 p_priv->resend_cont = 0;
2221 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2223 /* send the data out the device on control endpoint */
2224 this_urb->transfer_buffer_length = sizeof(msg);
2226 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2228 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2232 static int keyspan_usa67_send_setup(struct usb_serial *serial,
2233 struct usb_serial_port *port,
2236 struct keyspan_usa67_portControlMessage msg;
2237 struct keyspan_serial_private *s_priv;
2238 struct keyspan_port_private *p_priv;
2239 const struct keyspan_device_details *d_details;
2240 struct urb *this_urb;
2241 int err, device_port;
2243 s_priv = usb_get_serial_data(serial);
2244 p_priv = usb_get_serial_port_data(port);
2245 d_details = s_priv->device_details;
2247 this_urb = s_priv->glocont_urb;
2249 /* Work out which port within the device is being setup */
2250 device_port = port->number - port->serial->minor;
2252 /* Make sure we have an urb then send the message */
2253 if (this_urb == NULL) {
2254 dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__,
2259 /* Save reset port val for resend.
2260 Don't overwrite resend for open/close condition. */
2261 if ((reset_port + 1) > p_priv->resend_cont)
2262 p_priv->resend_cont = reset_port + 1;
2263 if (this_urb->status == -EINPROGRESS) {
2264 /* dev_dbg(&port->dev, "%s - already writing\n", __func__); */
2269 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2271 msg.port = device_port;
2273 /* Only set baud rate if it's changed */
2274 if (p_priv->old_baud != p_priv->baud) {
2275 p_priv->old_baud = p_priv->baud;
2276 msg.setClocking = 0xff;
2277 if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
2278 &msg.baudHi, &msg.baudLo, &msg.prescaler,
2279 device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2280 dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
2281 __func__, p_priv->baud);
2283 msg.baudHi = 125; /* Values for 9600 baud */
2286 msg.setPrescaler = 0xff;
2289 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2290 switch (p_priv->cflag & CSIZE) {
2292 msg.lcr |= USA_DATABITS_5;
2295 msg.lcr |= USA_DATABITS_6;
2298 msg.lcr |= USA_DATABITS_7;
2301 msg.lcr |= USA_DATABITS_8;
2304 if (p_priv->cflag & PARENB) {
2305 /* note USA_PARITY_NONE == 0 */
2306 msg.lcr |= (p_priv->cflag & PARODD) ?
2307 USA_PARITY_ODD : USA_PARITY_EVEN;
2311 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2312 msg.xonFlowControl = 0;
2313 msg.setFlowControl = 0xff;
2314 msg.forwardingLength = 16;
2318 if (reset_port == 1) {
2328 msg.returnStatus = 0;
2329 msg.resetDataToggle = 0xff;
2330 } else if (reset_port == 2) {
2340 msg.returnStatus = 0;
2341 msg.resetDataToggle = 0;
2343 /* Sending intermediate configs */
2344 msg._txOn = (!p_priv->break_on);
2347 msg.txBreak = (p_priv->break_on);
2352 msg.returnStatus = 0;
2353 msg.resetDataToggle = 0x0;
2356 /* Do handshaking outputs */
2357 msg.setTxTriState_setRts = 0xff;
2358 msg.txTriState_rts = p_priv->rts_state;
2360 msg.setHskoa_setDtr = 0xff;
2361 msg.hskoa_dtr = p_priv->dtr_state;
2363 p_priv->resend_cont = 0;
2365 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2367 /* send the data out the device on control endpoint */
2368 this_urb->transfer_buffer_length = sizeof(msg);
2370 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2372 dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
2376 static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2378 struct usb_serial *serial = port->serial;
2379 struct keyspan_serial_private *s_priv;
2380 const struct keyspan_device_details *d_details;
2382 s_priv = usb_get_serial_data(serial);
2383 d_details = s_priv->device_details;
2385 switch (d_details->msg_format) {
2387 keyspan_usa26_send_setup(serial, port, reset_port);
2390 keyspan_usa28_send_setup(serial, port, reset_port);
2393 keyspan_usa49_send_setup(serial, port, reset_port);
2396 keyspan_usa90_send_setup(serial, port, reset_port);
2399 keyspan_usa67_send_setup(serial, port, reset_port);
2405 /* Gets called by the "real" driver (ie once firmware is loaded
2406 and renumeration has taken place. */
2407 static int keyspan_startup(struct usb_serial *serial)
2410 struct usb_serial_port *port;
2411 struct keyspan_serial_private *s_priv;
2412 struct keyspan_port_private *p_priv;
2413 const struct keyspan_device_details *d_details;
2415 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
2416 if (d_details->product_id ==
2417 le16_to_cpu(serial->dev->descriptor.idProduct))
2419 if (d_details == NULL) {
2420 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2421 __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
2425 /* Setup private data for serial driver */
2426 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
2428 dev_dbg(&serial->dev->dev, "%s - kmalloc for keyspan_serial_private failed.\n", __func__);
2432 s_priv->device_details = d_details;
2433 usb_set_serial_data(serial, s_priv);
2435 /* Now setup per port private data */
2436 for (i = 0; i < serial->num_ports; i++) {
2437 port = serial->port[i];
2438 p_priv = kzalloc(sizeof(struct keyspan_port_private),
2441 dev_dbg(&port->dev, "%s - kmalloc for keyspan_port_private (%d) failed!.\n", __func__, i);
2444 p_priv->device_details = d_details;
2445 usb_set_serial_port_data(port, p_priv);
2448 keyspan_setup_urbs(serial);
2450 if (s_priv->instat_urb != NULL) {
2451 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2453 dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
2455 if (s_priv->indat_urb != NULL) {
2456 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2458 dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
2464 static void keyspan_disconnect(struct usb_serial *serial)
2467 struct usb_serial_port *port;
2468 struct keyspan_serial_private *s_priv;
2469 struct keyspan_port_private *p_priv;
2471 s_priv = usb_get_serial_data(serial);
2473 /* Stop reading/writing urbs */
2474 stop_urb(s_priv->instat_urb);
2475 stop_urb(s_priv->glocont_urb);
2476 stop_urb(s_priv->indat_urb);
2477 for (i = 0; i < serial->num_ports; ++i) {
2478 port = serial->port[i];
2479 p_priv = usb_get_serial_port_data(port);
2480 stop_urb(p_priv->inack_urb);
2481 stop_urb(p_priv->outcont_urb);
2482 for (j = 0; j < 2; j++) {
2483 stop_urb(p_priv->in_urbs[j]);
2484 stop_urb(p_priv->out_urbs[j]);
2489 usb_free_urb(s_priv->instat_urb);
2490 usb_free_urb(s_priv->indat_urb);
2491 usb_free_urb(s_priv->glocont_urb);
2492 for (i = 0; i < serial->num_ports; ++i) {
2493 port = serial->port[i];
2494 p_priv = usb_get_serial_port_data(port);
2495 usb_free_urb(p_priv->inack_urb);
2496 usb_free_urb(p_priv->outcont_urb);
2497 for (j = 0; j < 2; j++) {
2498 usb_free_urb(p_priv->in_urbs[j]);
2499 usb_free_urb(p_priv->out_urbs[j]);
2504 static void keyspan_release(struct usb_serial *serial)
2507 struct usb_serial_port *port;
2508 struct keyspan_serial_private *s_priv;
2510 s_priv = usb_get_serial_data(serial);
2514 /* Now free per port private data */
2515 for (i = 0; i < serial->num_ports; i++) {
2516 port = serial->port[i];
2517 kfree(usb_get_serial_port_data(port));
2521 MODULE_AUTHOR(DRIVER_AUTHOR);
2522 MODULE_DESCRIPTION(DRIVER_DESC);
2523 MODULE_LICENSE("GPL");
2525 MODULE_FIRMWARE("keyspan/usa28.fw");
2526 MODULE_FIRMWARE("keyspan/usa28x.fw");
2527 MODULE_FIRMWARE("keyspan/usa28xa.fw");
2528 MODULE_FIRMWARE("keyspan/usa28xb.fw");
2529 MODULE_FIRMWARE("keyspan/usa19.fw");
2530 MODULE_FIRMWARE("keyspan/usa19qi.fw");
2531 MODULE_FIRMWARE("keyspan/mpr.fw");
2532 MODULE_FIRMWARE("keyspan/usa19qw.fw");
2533 MODULE_FIRMWARE("keyspan/usa18x.fw");
2534 MODULE_FIRMWARE("keyspan/usa19w.fw");
2535 MODULE_FIRMWARE("keyspan/usa49w.fw");
2536 MODULE_FIRMWARE("keyspan/usa49wlc.fw");