blob: a1b99243dac9e77ac83be2e1b94316ff5014601c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 Keyspan USB to Serial Converter driver
Alan Coxdeb91682008-07-22 11:13:08 +01003
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 (C) Copyright (C) 2000-2001 Hugh Blemings <hugh@blemings.org>
5 (C) Copyright (C) 2002 Greg Kroah-Hartman <greg@kroah.com>
Alan Coxdeb91682008-07-22 11:13:08 +01006
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
Justin P. Mattock631dd1a2010-10-18 11:03:14 +020012 See http://blemings.org/hugh/keyspan.html for more information.
Alan Coxdeb91682008-07-22 11:13:08 +010013
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 Code in this driver inspired by and in a number of places taken
15 from Brian Warner's original Keyspan-PDA driver.
16
17 This driver has been put together with the support of Innosys, Inc.
18 and Keyspan, Inc the manufacturers of the Keyspan USB-serial products.
19 Thanks Guys :)
Alan Coxdeb91682008-07-22 11:13:08 +010020
Linus Torvalds1da177e2005-04-16 15:20:36 -070021 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
Alan Coxdeb91682008-07-22 11:13:08 +010024 stuff.
25
26 Tip 'o the hat to IBM (and previously Linuxcare :) for supporting
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 staff in their work on open source projects.
Linus Torvalds1da177e2005-04-16 15:20:36 -070028*/
29
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#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>
David Woodhouse2971c572008-05-30 14:04:03 +030041#include <linux/firmware.h>
42#include <linux/ihex.h>
Alan Coxdeb91682008-07-22 11:13:08 +010043#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070045#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070046#include "keyspan.h"
47
Rusty Russell90ab5ee2012-01-13 09:32:20 +103048static bool debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50/*
51 * Version Information
52 */
Lucy McCoy0ca12682007-05-18 12:10:41 -070053#define DRIVER_VERSION "v1.1.5"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#define DRIVER_AUTHOR "Hugh Blemings <hugh@misc.nu"
55#define DRIVER_DESC "Keyspan USB to Serial Converter Driver"
56
57#define INSTAT_BUFLEN 32
58#define GLOCONT_BUFLEN 64
Lucy McCoy0ca12682007-05-18 12:10:41 -070059#define INDAT49W_BUFLEN 512
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61 /* Per device and per port private data */
62struct keyspan_serial_private {
63 const struct keyspan_device_details *device_details;
64
65 struct urb *instat_urb;
66 char instat_buf[INSTAT_BUFLEN];
67
Alan Coxdeb91682008-07-22 11:13:08 +010068 /* added to support 49wg, where data from all 4 ports comes in
69 on 1 EP and high-speed supported */
Lucy McCoy0ca12682007-05-18 12:10:41 -070070 struct urb *indat_urb;
71 char indat_buf[INDAT49W_BUFLEN];
72
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 /* XXX this one probably will need a lock */
74 struct urb *glocont_urb;
75 char glocont_buf[GLOCONT_BUFLEN];
Alan Coxdeb91682008-07-22 11:13:08 +010076 char ctrl_buf[8]; /* for EP0 control message */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077};
78
79struct keyspan_port_private {
80 /* Keep track of which input & output endpoints to use */
81 int in_flip;
82 int out_flip;
83
84 /* Keep duplicate of device details in each port
85 structure as well - simplifies some of the
86 callback functions etc. */
87 const struct keyspan_device_details *device_details;
88
89 /* Input endpoints and buffer for this port */
90 struct urb *in_urbs[2];
91 char in_buffer[2][64];
92 /* Output endpoints and buffer for this port */
93 struct urb *out_urbs[2];
94 char out_buffer[2][64];
95
96 /* Input ack endpoint */
97 struct urb *inack_urb;
98 char inack_buffer[1];
99
100 /* Output control endpoint */
101 struct urb *outcont_urb;
102 char outcont_buffer[64];
103
104 /* Settings for the port */
105 int baud;
106 int old_baud;
107 unsigned int cflag;
108 unsigned int old_cflag;
109 enum {flow_none, flow_cts, flow_xon} flow_control;
110 int rts_state; /* Handshaking pins (outputs) */
111 int dtr_state;
112 int cts_state; /* Handshaking pins (inputs) */
113 int dsr_state;
114 int dcd_state;
115 int ri_state;
116 int break_on;
117
118 unsigned long tx_start_time[2];
119 int resend_cont; /* need to resend control packet */
120};
121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122/* Include Keyspan message headers. All current Keyspan Adapters
Lucy McCoy0ca12682007-05-18 12:10:41 -0700123 make use of one of five message formats which are referred
Alan Coxdeb91682008-07-22 11:13:08 +0100124 to as USA-26, USA-28, USA-49, USA-90, USA-67 by Keyspan and
125 within this driver. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126#include "keyspan_usa26msg.h"
127#include "keyspan_usa28msg.h"
128#include "keyspan_usa49msg.h"
129#include "keyspan_usa90msg.h"
Lucy McCoy0ca12682007-05-18 12:10:41 -0700130#include "keyspan_usa67msg.h"
Alan Coxdeb91682008-07-22 11:13:08 +0100131
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -0700133module_usb_serial_driver(serial_drivers, keyspan_ids_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Alan Cox95da3102008-07-22 11:09:07 +0100135static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
Alan Cox95da3102008-07-22 11:09:07 +0100137 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 struct keyspan_port_private *p_priv;
139
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 p_priv = usb_get_serial_port_data(port);
141
142 if (break_state == -1)
143 p_priv->break_on = 1;
144 else
145 p_priv->break_on = 0;
146
147 keyspan_send_setup(port, 0);
148}
149
150
Alan Coxdeb91682008-07-22 11:13:08 +0100151static void keyspan_set_termios(struct tty_struct *tty,
Alan Cox95da3102008-07-22 11:09:07 +0100152 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153{
154 int baud_rate, device_port;
155 struct keyspan_port_private *p_priv;
156 const struct keyspan_device_details *d_details;
157 unsigned int cflag;
158
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 p_priv = usb_get_serial_port_data(port);
160 d_details = p_priv->device_details;
Alan Cox74240b02007-10-18 01:24:20 -0700161 cflag = tty->termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 device_port = port->number - port->serial->minor;
163
164 /* Baud rate calculation takes baud rate as an integer
165 so other rates can be generated if desired. */
Alan Cox74240b02007-10-18 01:24:20 -0700166 baud_rate = tty_get_baud_rate(tty);
Alan Coxdeb91682008-07-22 11:13:08 +0100167 /* If no match or invalid, don't change */
Alan Cox74240b02007-10-18 01:24:20 -0700168 if (d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
170 /* FIXME - more to do here to ensure rate changes cleanly */
Alan Cox74240b02007-10-18 01:24:20 -0700171 /* FIXME - calcuate exact rate from divisor ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 p_priv->baud = baud_rate;
Alan Cox74240b02007-10-18 01:24:20 -0700173 } else
174 baud_rate = tty_termios_baud_rate(old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Alan Cox74240b02007-10-18 01:24:20 -0700176 tty_encode_baud_rate(tty, baud_rate, baud_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 /* set CTS/RTS handshake etc. */
178 p_priv->cflag = cflag;
179 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
180
Alan Cox74240b02007-10-18 01:24:20 -0700181 /* Mark/Space not supported */
182 tty->termios->c_cflag &= ~CMSPAR;
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 keyspan_send_setup(port, 0);
185}
186
Alan Cox60b33c12011-02-14 16:26:14 +0000187static int keyspan_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
Alan Cox95da3102008-07-22 11:09:07 +0100189 struct usb_serial_port *port = tty->driver_data;
190 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 unsigned int value;
Alan Coxdeb91682008-07-22 11:13:08 +0100192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
194 ((p_priv->dtr_state) ? TIOCM_DTR : 0) |
195 ((p_priv->cts_state) ? TIOCM_CTS : 0) |
196 ((p_priv->dsr_state) ? TIOCM_DSR : 0) |
197 ((p_priv->dcd_state) ? TIOCM_CAR : 0) |
Alan Coxdeb91682008-07-22 11:13:08 +0100198 ((p_priv->ri_state) ? TIOCM_RNG : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
200 return value;
201}
202
Alan Cox20b9d172011-02-14 16:26:50 +0000203static int keyspan_tiocmset(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 unsigned int set, unsigned int clear)
205{
Alan Cox95da3102008-07-22 11:09:07 +0100206 struct usb_serial_port *port = tty->driver_data;
207 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +0100208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 if (set & TIOCM_RTS)
210 p_priv->rts_state = 1;
211 if (set & TIOCM_DTR)
212 p_priv->dtr_state = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 if (clear & TIOCM_RTS)
214 p_priv->rts_state = 0;
215 if (clear & TIOCM_DTR)
216 p_priv->dtr_state = 0;
217 keyspan_send_setup(port, 0);
218 return 0;
219}
220
Alan Cox95da3102008-07-22 11:09:07 +0100221/* Write function is similar for the four protocols used
222 with only a minor change for usa90 (usa19hs) required */
223static int keyspan_write(struct tty_struct *tty,
224 struct usb_serial_port *port, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 struct keyspan_port_private *p_priv;
227 const struct keyspan_device_details *d_details;
228 int flip;
229 int left, todo;
230 struct urb *this_urb;
Alan Coxdeb91682008-07-22 11:13:08 +0100231 int err, maxDataLen, dataOffset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
233 p_priv = usb_get_serial_port_data(port);
234 d_details = p_priv->device_details;
235
236 if (d_details->msg_format == msg_usa90) {
Alan Coxdeb91682008-07-22 11:13:08 +0100237 maxDataLen = 64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 dataOffset = 0;
239 } else {
240 maxDataLen = 63;
241 dataOffset = 1;
242 }
Alan Coxdeb91682008-07-22 11:13:08 +0100243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 dbg("%s - for port %d (%d chars), flip=%d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800245 __func__, port->number, count, p_priv->out_flip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 for (left = count; left > 0; left -= todo) {
248 todo = left;
249 if (todo > maxDataLen)
250 todo = maxDataLen;
251
252 flip = p_priv->out_flip;
Alan Coxdeb91682008-07-22 11:13:08 +0100253
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 /* Check we have a valid urb/endpoint before we use it... */
Alan Coxdeb91682008-07-22 11:13:08 +0100255 this_urb = p_priv->out_urbs[flip];
256 if (this_urb == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 /* no bulk out, so return 0 bytes written */
Harvey Harrison441b62c2008-03-03 16:08:34 -0800258 dbg("%s - no output urb :(", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 return count;
260 }
261
Alan Coxdeb91682008-07-22 11:13:08 +0100262 dbg("%s - endpoint %d flip %d",
263 __func__, usb_pipeendpoint(this_urb->pipe), flip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264
265 if (this_urb->status == -EINPROGRESS) {
Alan Coxdeb91682008-07-22 11:13:08 +0100266 if (time_before(jiffies,
267 p_priv->tx_start_time[flip] + 10 * HZ))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 usb_unlink_urb(this_urb);
270 break;
271 }
272
Alan Coxdeb91682008-07-22 11:13:08 +0100273 /* First byte in buffer is "last flag" (except for usa19hx)
274 - unused so for now so set to zero */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 ((char *)this_urb->transfer_buffer)[0] = 0;
276
Alan Coxdeb91682008-07-22 11:13:08 +0100277 memcpy(this_urb->transfer_buffer + dataOffset, buf, todo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 buf += todo;
279
280 /* send the data out the bulk port */
281 this_urb->transfer_buffer_length = todo + dataOffset;
282
Alan Coxdeb91682008-07-22 11:13:08 +0100283 err = usb_submit_urb(this_urb, GFP_ATOMIC);
284 if (err != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 dbg("usb_submit_urb(write bulk) failed (%d)", err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 p_priv->tx_start_time[flip] = jiffies;
287
288 /* Flip for next time if usa26 or usa28 interface
289 (not used on usa49) */
290 p_priv->out_flip = (flip + 1) & d_details->outdat_endp_flip;
291 }
292
293 return count - left;
294}
295
David Howells7d12e782006-10-05 14:55:46 +0100296static void usa26_indat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
298 int i, err;
299 int endpoint;
300 struct usb_serial_port *port;
301 struct tty_struct *tty;
302 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700303 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 endpoint = usb_pipeendpoint(urb->pipe);
306
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700307 if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 dbg("%s - nonzero status: %x on endpoint %d.",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800309 __func__, status, endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 return;
311 }
312
Ming Leicdc97792008-02-24 18:41:47 +0800313 port = urb->context;
Alan Cox4a90f092008-10-13 10:39:46 +0100314 tty = tty_port_tty_get(&port->port);
Alan Coxa5569a52008-01-21 17:18:24 -0800315 if (tty && urb->actual_length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 /* 0x80 bit is error flag */
317 if ((data[0] & 0x80) == 0) {
Alan Coxdeb91682008-07-22 11:13:08 +0100318 /* no errors on individual bytes, only
319 possible overrun err */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 if (data[0] & RXERROR_OVERRUN)
Alan Coxdeb91682008-07-22 11:13:08 +0100321 err = TTY_OVERRUN;
322 else
323 err = 0;
324 for (i = 1; i < urb->actual_length ; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 tty_insert_flip_char(tty, data[i], err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 } else {
327 /* some bytes had errors, every byte has status */
Harvey Harrison441b62c2008-03-03 16:08:34 -0800328 dbg("%s - RX error!!!!", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 for (i = 0; i + 1 < urb->actual_length; i += 2) {
330 int stat = data[i], flag = 0;
331 if (stat & RXERROR_OVERRUN)
332 flag |= TTY_OVERRUN;
333 if (stat & RXERROR_FRAMING)
334 flag |= TTY_FRAME;
335 if (stat & RXERROR_PARITY)
336 flag |= TTY_PARITY;
337 /* XXX should handle break (0x10) */
338 tty_insert_flip_char(tty, data[i+1], flag);
339 }
340 }
341 tty_flip_buffer_push(tty);
342 }
Alan Cox4a90f092008-10-13 10:39:46 +0100343 tty_kref_put(tty);
Alan Coxdeb91682008-07-22 11:13:08 +0100344
345 /* Resubmit urb so we continue receiving */
Alan Stern1f871582010-02-17 10:05:47 -0500346 err = usb_submit_urb(urb, GFP_ATOMIC);
347 if (err != 0)
348 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349}
350
Alan Coxdeb91682008-07-22 11:13:08 +0100351/* Outdat handling is common for all devices */
David Howells7d12e782006-10-05 14:55:46 +0100352static void usa2x_outdat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353{
354 struct usb_serial_port *port;
355 struct keyspan_port_private *p_priv;
356
Ming Leicdc97792008-02-24 18:41:47 +0800357 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +0100359 dbg("%s - urb %d", __func__, urb == p_priv->out_urbs[1]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Alan Stern1f871582010-02-17 10:05:47 -0500361 usb_serial_port_softint(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362}
363
David Howells7d12e782006-10-05 14:55:46 +0100364static void usa26_inack_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}
367
David Howells7d12e782006-10-05 14:55:46 +0100368static void usa26_outcont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 struct usb_serial_port *port;
371 struct keyspan_port_private *p_priv;
372
Ming Leicdc97792008-02-24 18:41:47 +0800373 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 p_priv = usb_get_serial_port_data(port);
375
376 if (p_priv->resend_cont) {
Alan Coxdeb91682008-07-22 11:13:08 +0100377 dbg("%s - sending setup", __func__);
378 keyspan_usa26_send_setup(port->serial, port,
379 p_priv->resend_cont - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
381}
382
David Howells7d12e782006-10-05 14:55:46 +0100383static void usa26_instat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384{
385 unsigned char *data = urb->transfer_buffer;
386 struct keyspan_usa26_portStatusMessage *msg;
387 struct usb_serial *serial;
388 struct usb_serial_port *port;
389 struct keyspan_port_private *p_priv;
Alan Cox4a90f092008-10-13 10:39:46 +0100390 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 int old_dcd_state, err;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700392 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Ming Leicdc97792008-02-24 18:41:47 +0800394 serial = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700396 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800397 dbg("%s - nonzero status: %x", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 return;
399 }
400 if (urb->actual_length != 9) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800401 dbg("%s - %d byte report??", __func__, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 goto exit;
403 }
404
405 msg = (struct keyspan_usa26_portStatusMessage *)data;
406
407#if 0
408 dbg("%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800409 __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr, msg->ri, msg->_txOff,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410 msg->_txXoff, msg->rxEnabled, msg->controlResponse);
411#endif
412
413 /* Now do something useful with the data */
414
415
Alan Coxdeb91682008-07-22 11:13:08 +0100416 /* Check port number from message and retrieve private data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 if (msg->port >= serial->num_ports) {
Alan Coxdeb91682008-07-22 11:13:08 +0100418 dbg("%s - Unexpected port number %d", __func__, msg->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 goto exit;
420 }
421 port = serial->port[msg->port];
422 p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +0100423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 /* Update handshaking pin state information */
425 old_dcd_state = p_priv->dcd_state;
426 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
427 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
428 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
429 p_priv->ri_state = ((msg->ri) ? 1 : 0);
430
Alan Cox4a90f092008-10-13 10:39:46 +0100431 if (old_dcd_state != p_priv->dcd_state) {
432 tty = tty_port_tty_get(&port->port);
433 if (tty && !C_CLOCAL(tty))
434 tty_hangup(tty);
435 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 }
Alan Coxdeb91682008-07-22 11:13:08 +0100437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 /* Resubmit urb so we continue receiving */
Alan Coxdeb91682008-07-22 11:13:08 +0100439 err = usb_submit_urb(urb, GFP_ATOMIC);
440 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800441 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442exit: ;
443}
444
David Howells7d12e782006-10-05 14:55:46 +0100445static void usa26_glocont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447}
448
449
David Howells7d12e782006-10-05 14:55:46 +0100450static void usa28_indat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Alan Coxf035a8a2008-07-22 11:13:32 +0100452 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 struct usb_serial_port *port;
454 struct tty_struct *tty;
455 unsigned char *data;
456 struct keyspan_port_private *p_priv;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700457 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Ming Leicdc97792008-02-24 18:41:47 +0800459 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 p_priv = usb_get_serial_port_data(port);
461 data = urb->transfer_buffer;
462
463 if (urb != p_priv->in_urbs[p_priv->in_flip])
464 return;
465
466 do {
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700467 if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 dbg("%s - nonzero status: %x on endpoint %d.",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800469 __func__, status, usb_pipeendpoint(urb->pipe));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 return;
471 }
472
Ming Leicdc97792008-02-24 18:41:47 +0800473 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 p_priv = usb_get_serial_port_data(port);
475 data = urb->transfer_buffer;
476
Alan Cox4a90f092008-10-13 10:39:46 +0100477 tty =tty_port_tty_get(&port->port);
478 if (tty && urb->actual_length) {
Alan Coxf035a8a2008-07-22 11:13:32 +0100479 tty_insert_flip_string(tty, data, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 tty_flip_buffer_push(tty);
481 }
Alan Cox4a90f092008-10-13 10:39:46 +0100482 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 /* Resubmit urb so we continue receiving */
Alan Stern1f871582010-02-17 10:05:47 -0500485 err = usb_submit_urb(urb, GFP_ATOMIC);
486 if (err != 0)
487 dbg("%s - resubmit read urb failed. (%d)",
488 __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 p_priv->in_flip ^= 1;
490
491 urb = p_priv->in_urbs[p_priv->in_flip];
492 } while (urb->status != -EINPROGRESS);
493}
494
David Howells7d12e782006-10-05 14:55:46 +0100495static void usa28_inack_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497}
498
David Howells7d12e782006-10-05 14:55:46 +0100499static void usa28_outcont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
501 struct usb_serial_port *port;
502 struct keyspan_port_private *p_priv;
503
Ming Leicdc97792008-02-24 18:41:47 +0800504 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 p_priv = usb_get_serial_port_data(port);
506
507 if (p_priv->resend_cont) {
Alan Coxdeb91682008-07-22 11:13:08 +0100508 dbg("%s - sending setup", __func__);
509 keyspan_usa28_send_setup(port->serial, port,
510 p_priv->resend_cont - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
512}
513
David Howells7d12e782006-10-05 14:55:46 +0100514static void usa28_instat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
516 int err;
517 unsigned char *data = urb->transfer_buffer;
518 struct keyspan_usa28_portStatusMessage *msg;
519 struct usb_serial *serial;
520 struct usb_serial_port *port;
521 struct keyspan_port_private *p_priv;
Alan Cox4a90f092008-10-13 10:39:46 +0100522 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 int old_dcd_state;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700524 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Ming Leicdc97792008-02-24 18:41:47 +0800526 serial = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700528 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800529 dbg("%s - nonzero status: %x", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 return;
531 }
532
533 if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800534 dbg("%s - bad length %d", __func__, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 goto exit;
536 }
537
Harvey Harrison441b62c2008-03-03 16:08:34 -0800538 /*dbg("%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 data[0], data[1], data[2], data[3], data[4], data[5],
540 data[6], data[7], data[8], data[9], data[10], data[11]);*/
Alan Coxdeb91682008-07-22 11:13:08 +0100541
542 /* Now do something useful with the data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 msg = (struct keyspan_usa28_portStatusMessage *)data;
544
Alan Coxdeb91682008-07-22 11:13:08 +0100545 /* Check port number from message and retrieve private data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 if (msg->port >= serial->num_ports) {
Alan Coxdeb91682008-07-22 11:13:08 +0100547 dbg("%s - Unexpected port number %d", __func__, msg->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 goto exit;
549 }
550 port = serial->port[msg->port];
551 p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +0100552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* Update handshaking pin state information */
554 old_dcd_state = p_priv->dcd_state;
555 p_priv->cts_state = ((msg->cts) ? 1 : 0);
556 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
557 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
558 p_priv->ri_state = ((msg->ri) ? 1 : 0);
559
Alan Cox4a90f092008-10-13 10:39:46 +0100560 if( old_dcd_state != p_priv->dcd_state && old_dcd_state) {
561 tty = tty_port_tty_get(&port->port);
562 if (tty && !C_CLOCAL(tty))
563 tty_hangup(tty);
564 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 }
566
567 /* Resubmit urb so we continue receiving */
Alan Coxdeb91682008-07-22 11:13:08 +0100568 err = usb_submit_urb(urb, GFP_ATOMIC);
569 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800570 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571exit: ;
572}
573
David Howells7d12e782006-10-05 14:55:46 +0100574static void usa28_glocont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576}
577
578
David Howells7d12e782006-10-05 14:55:46 +0100579static void usa49_glocont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
581 struct usb_serial *serial;
582 struct usb_serial_port *port;
583 struct keyspan_port_private *p_priv;
584 int i;
585
Ming Leicdc97792008-02-24 18:41:47 +0800586 serial = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 for (i = 0; i < serial->num_ports; ++i) {
588 port = serial->port[i];
589 p_priv = usb_get_serial_port_data(port);
590
591 if (p_priv->resend_cont) {
Alan Coxdeb91682008-07-22 11:13:08 +0100592 dbg("%s - sending setup", __func__);
593 keyspan_usa49_send_setup(serial, port,
594 p_priv->resend_cont - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 break;
596 }
597 }
598}
599
600 /* This is actually called glostat in the Keyspan
601 doco */
David Howells7d12e782006-10-05 14:55:46 +0100602static void usa49_instat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603{
604 int err;
605 unsigned char *data = urb->transfer_buffer;
606 struct keyspan_usa49_portStatusMessage *msg;
607 struct usb_serial *serial;
608 struct usb_serial_port *port;
609 struct keyspan_port_private *p_priv;
610 int old_dcd_state;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700611 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Ming Leicdc97792008-02-24 18:41:47 +0800613 serial = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700615 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800616 dbg("%s - nonzero status: %x", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 return;
618 }
619
Alan Coxdeb91682008-07-22 11:13:08 +0100620 if (urb->actual_length !=
621 sizeof(struct keyspan_usa49_portStatusMessage)) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800622 dbg("%s - bad length %d", __func__, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 goto exit;
624 }
625
Harvey Harrison441b62c2008-03-03 16:08:34 -0800626 /*dbg(" %x %x %x %x %x %x %x %x %x %x %x", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 data[0], data[1], data[2], data[3], data[4], data[5],
628 data[6], data[7], data[8], data[9], data[10]);*/
Alan Coxdeb91682008-07-22 11:13:08 +0100629
630 /* Now do something useful with the data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 msg = (struct keyspan_usa49_portStatusMessage *)data;
632
Alan Coxdeb91682008-07-22 11:13:08 +0100633 /* Check port number from message and retrieve private data */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 if (msg->portNumber >= serial->num_ports) {
Alan Coxdeb91682008-07-22 11:13:08 +0100635 dbg("%s - Unexpected port number %d",
636 __func__, msg->portNumber);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 goto exit;
638 }
639 port = serial->port[msg->portNumber];
640 p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +0100641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /* Update handshaking pin state information */
643 old_dcd_state = p_priv->dcd_state;
644 p_priv->cts_state = ((msg->cts) ? 1 : 0);
645 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
646 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
647 p_priv->ri_state = ((msg->ri) ? 1 : 0);
648
Alan Cox4a90f092008-10-13 10:39:46 +0100649 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
650 struct tty_struct *tty = tty_port_tty_get(&port->port);
651 if (tty && !C_CLOCAL(tty))
652 tty_hangup(tty);
653 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 }
655
Alan Coxdeb91682008-07-22 11:13:08 +0100656 /* Resubmit urb so we continue receiving */
Alan Coxdeb91682008-07-22 11:13:08 +0100657 err = usb_submit_urb(urb, GFP_ATOMIC);
658 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800659 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660exit: ;
661}
662
David Howells7d12e782006-10-05 14:55:46 +0100663static void usa49_inack_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665}
666
David Howells7d12e782006-10-05 14:55:46 +0100667static void usa49_indat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668{
669 int i, err;
670 int endpoint;
671 struct usb_serial_port *port;
672 struct tty_struct *tty;
673 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700674 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 endpoint = usb_pipeendpoint(urb->pipe);
677
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700678 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800679 dbg("%s - nonzero status: %x on endpoint %d.", __func__,
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700680 status, endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 return;
682 }
683
Ming Leicdc97792008-02-24 18:41:47 +0800684 port = urb->context;
Alan Cox4a90f092008-10-13 10:39:46 +0100685 tty = tty_port_tty_get(&port->port);
Alan Cox3004e532008-01-03 16:59:04 +0000686 if (tty && urb->actual_length) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 /* 0x80 bit is error flag */
688 if ((data[0] & 0x80) == 0) {
689 /* no error on any byte */
Alan Coxf035a8a2008-07-22 11:13:32 +0100690 tty_insert_flip_string(tty, data + 1,
691 urb->actual_length - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 } else {
693 /* some bytes had errors, every byte has status */
694 for (i = 0; i + 1 < urb->actual_length; i += 2) {
695 int stat = data[i], flag = 0;
696 if (stat & RXERROR_OVERRUN)
697 flag |= TTY_OVERRUN;
698 if (stat & RXERROR_FRAMING)
699 flag |= TTY_FRAME;
700 if (stat & RXERROR_PARITY)
701 flag |= TTY_PARITY;
702 /* XXX should handle break (0x10) */
703 tty_insert_flip_char(tty, data[i+1], flag);
704 }
705 }
706 tty_flip_buffer_push(tty);
707 }
Alan Cox4a90f092008-10-13 10:39:46 +0100708 tty_kref_put(tty);
Alan Coxdeb91682008-07-22 11:13:08 +0100709
710 /* Resubmit urb so we continue receiving */
Alan Stern1f871582010-02-17 10:05:47 -0500711 err = usb_submit_urb(urb, GFP_ATOMIC);
712 if (err != 0)
713 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714}
715
Lucy McCoy0ca12682007-05-18 12:10:41 -0700716static void usa49wg_indat_callback(struct urb *urb)
717{
718 int i, len, x, err;
719 struct usb_serial *serial;
720 struct usb_serial_port *port;
721 struct tty_struct *tty;
722 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700723 int status = urb->status;
Lucy McCoy0ca12682007-05-18 12:10:41 -0700724
Lucy McCoy0ca12682007-05-18 12:10:41 -0700725 serial = urb->context;
726
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700727 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800728 dbg("%s - nonzero status: %x", __func__, status);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700729 return;
730 }
731
732 /* inbound data is in the form P#, len, status, data */
733 i = 0;
734 len = 0;
735
736 if (urb->actual_length) {
737 while (i < urb->actual_length) {
738
739 /* Check port number from message*/
740 if (data[i] >= serial->num_ports) {
Alan Coxdeb91682008-07-22 11:13:08 +0100741 dbg("%s - Unexpected port number %d",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800742 __func__, data[i]);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700743 return;
744 }
745 port = serial->port[data[i++]];
Alan Cox4a90f092008-10-13 10:39:46 +0100746 tty = tty_port_tty_get(&port->port);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700747 len = data[i++];
748
749 /* 0x80 bit is error flag */
750 if ((data[i] & 0x80) == 0) {
751 /* no error on any byte */
752 i++;
753 for (x = 1; x < len ; ++x)
Alan Stern1f871582010-02-17 10:05:47 -0500754 tty_insert_flip_char(tty, data[i++], 0);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700755 } else {
756 /*
757 * some bytes had errors, every byte has status
758 */
759 for (x = 0; x + 1 < len; x += 2) {
760 int stat = data[i], flag = 0;
761 if (stat & RXERROR_OVERRUN)
762 flag |= TTY_OVERRUN;
763 if (stat & RXERROR_FRAMING)
764 flag |= TTY_FRAME;
765 if (stat & RXERROR_PARITY)
766 flag |= TTY_PARITY;
767 /* XXX should handle break (0x10) */
Alan Stern1f871582010-02-17 10:05:47 -0500768 tty_insert_flip_char(tty,
Lucy McCoy0ca12682007-05-18 12:10:41 -0700769 data[i+1], flag);
770 i += 2;
771 }
772 }
Alan Stern1f871582010-02-17 10:05:47 -0500773 tty_flip_buffer_push(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100774 tty_kref_put(tty);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700775 }
776 }
777
778 /* Resubmit urb so we continue receiving */
Lucy McCoy0ca12682007-05-18 12:10:41 -0700779 err = usb_submit_urb(urb, GFP_ATOMIC);
780 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800781 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700782}
783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784/* not used, usa-49 doesn't have per-port control endpoints */
Lucy McCoy0ca12682007-05-18 12:10:41 -0700785static void usa49_outcont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788
Lucy McCoy0ca12682007-05-18 12:10:41 -0700789static void usa90_indat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790{
791 int i, err;
792 int endpoint;
793 struct usb_serial_port *port;
794 struct keyspan_port_private *p_priv;
795 struct tty_struct *tty;
796 unsigned char *data = urb->transfer_buffer;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700797 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 endpoint = usb_pipeendpoint(urb->pipe);
800
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700801 if (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 dbg("%s - nonzero status: %x on endpoint %d.",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800803 __func__, status, endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 return;
805 }
806
Ming Leicdc97792008-02-24 18:41:47 +0800807 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 p_priv = usb_get_serial_port_data(port);
809
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 if (urb->actual_length) {
Alan Cox4a90f092008-10-13 10:39:46 +0100811 tty = tty_port_tty_get(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 /* if current mode is DMA, looks like usa28 format
Alan Coxdeb91682008-07-22 11:13:08 +0100813 otherwise looks like usa26 data format */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Alan Coxf035a8a2008-07-22 11:13:32 +0100815 if (p_priv->baud > 57600)
816 tty_insert_flip_string(tty, data, urb->actual_length);
817 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 /* 0x80 bit is error flag */
819 if ((data[0] & 0x80) == 0) {
Alan Coxdeb91682008-07-22 11:13:08 +0100820 /* no errors on individual bytes, only
821 possible overrun err*/
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (data[0] & RXERROR_OVERRUN)
Alan Coxdeb91682008-07-22 11:13:08 +0100823 err = TTY_OVERRUN;
824 else
825 err = 0;
826 for (i = 1; i < urb->actual_length ; ++i)
827 tty_insert_flip_char(tty, data[i],
828 err);
829 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 /* some bytes had errors, every byte has status */
Harvey Harrison441b62c2008-03-03 16:08:34 -0800831 dbg("%s - RX error!!!!", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 for (i = 0; i + 1 < urb->actual_length; i += 2) {
833 int stat = data[i], flag = 0;
834 if (stat & RXERROR_OVERRUN)
835 flag |= TTY_OVERRUN;
836 if (stat & RXERROR_FRAMING)
837 flag |= TTY_FRAME;
838 if (stat & RXERROR_PARITY)
839 flag |= TTY_PARITY;
840 /* XXX should handle break (0x10) */
Alan Coxdeb91682008-07-22 11:13:08 +0100841 tty_insert_flip_char(tty, data[i+1],
842 flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 }
844 }
845 }
846 tty_flip_buffer_push(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100847 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 }
Alan Coxdeb91682008-07-22 11:13:08 +0100849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 /* Resubmit urb so we continue receiving */
Alan Stern1f871582010-02-17 10:05:47 -0500851 err = usb_submit_urb(urb, GFP_ATOMIC);
852 if (err != 0)
853 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854}
855
856
David Howells7d12e782006-10-05 14:55:46 +0100857static void usa90_instat_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
859 unsigned char *data = urb->transfer_buffer;
860 struct keyspan_usa90_portStatusMessage *msg;
861 struct usb_serial *serial;
862 struct usb_serial_port *port;
863 struct keyspan_port_private *p_priv;
Alan Cox4a90f092008-10-13 10:39:46 +0100864 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 int old_dcd_state, err;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700866 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Ming Leicdc97792008-02-24 18:41:47 +0800868 serial = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700870 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800871 dbg("%s - nonzero status: %x", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return;
873 }
874 if (urb->actual_length < 14) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800875 dbg("%s - %d byte report??", __func__, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 goto exit;
877 }
878
879 msg = (struct keyspan_usa90_portStatusMessage *)data;
880
881 /* Now do something useful with the data */
882
883 port = serial->port[0];
884 p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +0100885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 /* Update handshaking pin state information */
887 old_dcd_state = p_priv->dcd_state;
888 p_priv->cts_state = ((msg->cts) ? 1 : 0);
889 p_priv->dsr_state = ((msg->dsr) ? 1 : 0);
890 p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
891 p_priv->ri_state = ((msg->ri) ? 1 : 0);
892
Alan Cox4a90f092008-10-13 10:39:46 +0100893 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
894 tty = tty_port_tty_get(&port->port);
895 if (tty && !C_CLOCAL(tty))
896 tty_hangup(tty);
897 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 }
Alan Coxdeb91682008-07-22 11:13:08 +0100899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 /* Resubmit urb so we continue receiving */
Alan Coxdeb91682008-07-22 11:13:08 +0100901 err = usb_submit_urb(urb, GFP_ATOMIC);
902 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800903 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904exit:
905 ;
906}
907
David Howells7d12e782006-10-05 14:55:46 +0100908static void usa90_outcont_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909{
910 struct usb_serial_port *port;
911 struct keyspan_port_private *p_priv;
912
Ming Leicdc97792008-02-24 18:41:47 +0800913 port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 p_priv = usb_get_serial_port_data(port);
915
916 if (p_priv->resend_cont) {
Alan Coxdeb91682008-07-22 11:13:08 +0100917 dbg("%s - sending setup", __func__);
918 keyspan_usa90_send_setup(port->serial, port,
919 p_priv->resend_cont - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 }
921}
922
Lucy McCoy0ca12682007-05-18 12:10:41 -0700923/* Status messages from the 28xg */
924static void usa67_instat_callback(struct urb *urb)
925{
926 int err;
927 unsigned char *data = urb->transfer_buffer;
928 struct keyspan_usa67_portStatusMessage *msg;
929 struct usb_serial *serial;
930 struct usb_serial_port *port;
931 struct keyspan_port_private *p_priv;
932 int old_dcd_state;
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700933 int status = urb->status;
Lucy McCoy0ca12682007-05-18 12:10:41 -0700934
Lucy McCoy0ca12682007-05-18 12:10:41 -0700935 serial = urb->context;
936
Greg Kroah-Hartman95b93452007-06-15 15:44:13 -0700937 if (status) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800938 dbg("%s - nonzero status: %x", __func__, status);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700939 return;
940 }
941
Alan Coxdeb91682008-07-22 11:13:08 +0100942 if (urb->actual_length !=
943 sizeof(struct keyspan_usa67_portStatusMessage)) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800944 dbg("%s - bad length %d", __func__, urb->actual_length);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700945 return;
946 }
947
948
949 /* Now do something useful with the data */
950 msg = (struct keyspan_usa67_portStatusMessage *)data;
951
952 /* Check port number from message and retrieve private data */
953 if (msg->port >= serial->num_ports) {
Alan Coxdeb91682008-07-22 11:13:08 +0100954 dbg("%s - Unexpected port number %d", __func__, msg->port);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700955 return;
956 }
957
958 port = serial->port[msg->port];
959 p_priv = usb_get_serial_port_data(port);
960
961 /* Update handshaking pin state information */
962 old_dcd_state = p_priv->dcd_state;
963 p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
964 p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
965
Alan Cox4a90f092008-10-13 10:39:46 +0100966 if (old_dcd_state != p_priv->dcd_state && old_dcd_state) {
967 struct tty_struct *tty = tty_port_tty_get(&port->port);
968 if (tty && !C_CLOCAL(tty))
969 tty_hangup(tty);
970 tty_kref_put(tty);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700971 }
972
973 /* Resubmit urb so we continue receiving */
Lucy McCoy0ca12682007-05-18 12:10:41 -0700974 err = usb_submit_urb(urb, GFP_ATOMIC);
975 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800976 dbg("%s - resubmit read urb failed. (%d)", __func__, err);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700977}
978
979static void usa67_glocont_callback(struct urb *urb)
980{
981 struct usb_serial *serial;
982 struct usb_serial_port *port;
983 struct keyspan_port_private *p_priv;
984 int i;
985
Lucy McCoy0ca12682007-05-18 12:10:41 -0700986 serial = urb->context;
987 for (i = 0; i < serial->num_ports; ++i) {
988 port = serial->port[i];
989 p_priv = usb_get_serial_port_data(port);
990
991 if (p_priv->resend_cont) {
Alan Coxdeb91682008-07-22 11:13:08 +0100992 dbg("%s - sending setup", __func__);
Lucy McCoy0ca12682007-05-18 12:10:41 -0700993 keyspan_usa67_send_setup(serial, port,
994 p_priv->resend_cont - 1);
995 break;
996 }
997 }
998}
999
Alan Cox95da3102008-07-22 11:09:07 +01001000static int keyspan_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
Alan Cox95da3102008-07-22 11:09:07 +01001002 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 struct keyspan_port_private *p_priv;
1004 const struct keyspan_device_details *d_details;
1005 int flip;
1006 int data_len;
1007 struct urb *this_urb;
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 p_priv = usb_get_serial_port_data(port);
1010 d_details = p_priv->device_details;
1011
Alan Coxa5b6f602008-04-08 17:16:06 +01001012 /* FIXME: locking */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 if (d_details->msg_format == msg_usa90)
Alan Coxdeb91682008-07-22 11:13:08 +01001014 data_len = 64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 else
1016 data_len = 63;
1017
1018 flip = p_priv->out_flip;
1019
1020 /* Check both endpoints to see if any are available. */
Alan Coxdeb91682008-07-22 11:13:08 +01001021 this_urb = p_priv->out_urbs[flip];
1022 if (this_urb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 if (this_urb->status != -EINPROGRESS)
Alan Coxdeb91682008-07-22 11:13:08 +01001024 return data_len;
1025 flip = (flip + 1) & d_details->outdat_endp_flip;
1026 this_urb = p_priv->out_urbs[flip];
1027 if (this_urb != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 if (this_urb->status != -EINPROGRESS)
Alan Coxdeb91682008-07-22 11:13:08 +01001029 return data_len;
1030 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
Alan Coxa5b6f602008-04-08 17:16:06 +01001032 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033}
1034
1035
Alan Coxa509a7e2009-09-19 13:13:26 -07001036static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037{
Andrew Mortonf78ba152007-11-28 16:21:54 -08001038 struct keyspan_port_private *p_priv;
1039 struct keyspan_serial_private *s_priv;
1040 struct usb_serial *serial = port->serial;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 const struct keyspan_device_details *d_details;
1042 int i, err;
Andrew Mortonf78ba152007-11-28 16:21:54 -08001043 int baud_rate, device_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 struct urb *urb;
Alan Cox95da3102008-07-22 11:09:07 +01001045 unsigned int cflag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
1047 s_priv = usb_get_serial_data(serial);
1048 p_priv = usb_get_serial_port_data(port);
1049 d_details = p_priv->device_details;
Borislav Petkov7eea4362007-11-14 17:00:39 -08001050
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 /* Set some sane defaults */
1052 p_priv->rts_state = 1;
1053 p_priv->dtr_state = 1;
1054 p_priv->baud = 9600;
1055
1056 /* force baud and lcr to be set on open */
1057 p_priv->old_baud = 0;
1058 p_priv->old_cflag = 0;
1059
1060 p_priv->out_flip = 0;
1061 p_priv->in_flip = 0;
1062
1063 /* Reset low level data toggle and start reading from endpoints */
1064 for (i = 0; i < 2; i++) {
Alan Coxdeb91682008-07-22 11:13:08 +01001065 urb = p_priv->in_urbs[i];
1066 if (urb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
Alan Coxdeb91682008-07-22 11:13:08 +01001069 /* make sure endpoint data toggle is synchronized
1070 with the device */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 usb_clear_halt(urb->dev, urb->pipe);
Alan Coxdeb91682008-07-22 11:13:08 +01001072 err = usb_submit_urb(urb, GFP_KERNEL);
1073 if (err != 0)
1074 dbg("%s - submit urb %d failed (%d)",
1075 __func__, i, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 }
1077
1078 /* Reset low level data toggle on out endpoints */
1079 for (i = 0; i < 2; i++) {
Alan Coxdeb91682008-07-22 11:13:08 +01001080 urb = p_priv->out_urbs[i];
1081 if (urb == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 continue;
Alan Coxdeb91682008-07-22 11:13:08 +01001083 /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
1084 usb_pipeout(urb->pipe), 0); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 }
1086
Andrew Mortonf78ba152007-11-28 16:21:54 -08001087 /* get the terminal config for the setup message now so we don't
1088 * need to send 2 of them */
1089
Andrew Mortonf78ba152007-11-28 16:21:54 -08001090 device_port = port->number - port->serial->minor;
Alan Cox95da3102008-07-22 11:09:07 +01001091 if (tty) {
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 */
1097 if (baud_rate >= 0
1098 && d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
1099 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
1100 p_priv->baud = baud_rate;
1101 }
Andrew Mortonf78ba152007-11-28 16:21:54 -08001102 }
Andrew Mortonf78ba152007-11-28 16:21:54 -08001103 /* set CTS/RTS handshake etc. */
1104 p_priv->cflag = cflag;
1105 p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
1106
1107 keyspan_send_setup(port, 1);
Alan Coxdeb91682008-07-22 11:13:08 +01001108 /* mdelay(100); */
1109 /* keyspan_set_termios(port, NULL); */
Andrew Mortonf78ba152007-11-28 16:21:54 -08001110
Alan Coxa5b6f602008-04-08 17:16:06 +01001111 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112}
1113
1114static inline void stop_urb(struct urb *urb)
1115{
Greg Kroah-Hartman242cf672005-07-29 16:11:07 -04001116 if (urb && urb->status == -EINPROGRESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 usb_kill_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118}
1119
Alan Cox335f8512009-06-11 12:26:29 +01001120static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
1121{
1122 struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
1123
1124 p_priv->rts_state = on;
1125 p_priv->dtr_state = on;
1126 keyspan_send_setup(port, 0);
1127}
1128
1129static void keyspan_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
1131 int i;
1132 struct usb_serial *serial = port->serial;
1133 struct keyspan_serial_private *s_priv;
1134 struct keyspan_port_private *p_priv;
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 s_priv = usb_get_serial_data(serial);
1137 p_priv = usb_get_serial_port_data(port);
Alan Coxdeb91682008-07-22 11:13:08 +01001138
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 p_priv->rts_state = 0;
1140 p_priv->dtr_state = 0;
Alan Coxdeb91682008-07-22 11:13:08 +01001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 if (serial->dev) {
1143 keyspan_send_setup(port, 2);
1144 /* pilot-xfer seems to work best with this delay */
1145 mdelay(100);
Alan Coxdeb91682008-07-22 11:13:08 +01001146 /* keyspan_set_termios(port, NULL); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 }
1148
1149 /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08001150 dbg("%s - urb in progress", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 }*/
1152
1153 p_priv->out_flip = 0;
1154 p_priv->in_flip = 0;
1155
1156 if (serial->dev) {
1157 /* Stop reading/writing urbs */
1158 stop_urb(p_priv->inack_urb);
1159 /* stop_urb(p_priv->outcont_urb); */
1160 for (i = 0; i < 2; i++) {
1161 stop_urb(p_priv->in_urbs[i]);
1162 stop_urb(p_priv->out_urbs[i]);
1163 }
1164 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165}
1166
Alan Coxdeb91682008-07-22 11:13:08 +01001167/* download the firmware to a pre-renumeration device */
1168static int keyspan_fake_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169{
1170 int response;
David Woodhouse2971c572008-05-30 14:04:03 +03001171 const struct ihex_binrec *record;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 char *fw_name;
David Woodhouse2971c572008-05-30 14:04:03 +03001173 const struct firmware *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
1175 dbg("Keyspan startup version %04x product %04x",
1176 le16_to_cpu(serial->dev->descriptor.bcdDevice),
1177 le16_to_cpu(serial->dev->descriptor.idProduct));
Alan Coxdeb91682008-07-22 11:13:08 +01001178
1179 if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
1180 != 0x8000) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 dbg("Firmware already loaded. Quitting.");
Alan Coxdeb91682008-07-22 11:13:08 +01001182 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
1184
1185 /* Select firmware image on the basis of idProduct */
1186 switch (le16_to_cpu(serial->dev->descriptor.idProduct)) {
1187 case keyspan_usa28_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001188 fw_name = "keyspan/usa28.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 break;
1190
1191 case keyspan_usa28x_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001192 fw_name = "keyspan/usa28x.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 break;
1194
1195 case keyspan_usa28xa_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001196 fw_name = "keyspan/usa28xa.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 break;
1198
1199 case keyspan_usa28xb_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001200 fw_name = "keyspan/usa28xb.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 break;
1202
1203 case keyspan_usa19_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001204 fw_name = "keyspan/usa19.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 break;
Alan Coxdeb91682008-07-22 11:13:08 +01001206
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 case keyspan_usa19qi_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001208 fw_name = "keyspan/usa19qi.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 break;
Alan Coxdeb91682008-07-22 11:13:08 +01001210
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 case keyspan_mpr_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001212 fw_name = "keyspan/mpr.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 break;
1214
1215 case keyspan_usa19qw_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001216 fw_name = "keyspan/usa19qw.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 break;
Alan Coxdeb91682008-07-22 11:13:08 +01001218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 case keyspan_usa18x_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001220 fw_name = "keyspan/usa18x.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 break;
Alan Coxdeb91682008-07-22 11:13:08 +01001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 case keyspan_usa19w_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001224 fw_name = "keyspan/usa19w.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 break;
Alan Coxdeb91682008-07-22 11:13:08 +01001226
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 case keyspan_usa49w_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001228 fw_name = "keyspan/usa49w.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 break;
1230
1231 case keyspan_usa49wlc_pre_product_id:
David Woodhouse2971c572008-05-30 14:04:03 +03001232 fw_name = "keyspan/usa49wlc.fw";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 break;
1234
1235 default:
David Woodhouse2971c572008-05-30 14:04:03 +03001236 dev_err(&serial->dev->dev, "Unknown product ID (%04x)\n",
1237 le16_to_cpu(serial->dev->descriptor.idProduct));
1238 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239 }
1240
David Woodhouse2971c572008-05-30 14:04:03 +03001241 if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 dev_err(&serial->dev->dev, "Required keyspan firmware image (%s) unavailable.\n", fw_name);
1243 return(1);
1244 }
1245
1246 dbg("Uploading Keyspan %s firmware.", fw_name);
1247
1248 /* download the firmware image */
1249 response = ezusb_set_reset(serial, 1);
1250
David Woodhouse2971c572008-05-30 14:04:03 +03001251 record = (const struct ihex_binrec *)fw->data;
1252
1253 while (record) {
1254 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 (unsigned char *)record->data,
David Woodhouse2971c572008-05-30 14:04:03 +03001256 be16_to_cpu(record->len), 0xa0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 if (response < 0) {
Alan Coxdeb91682008-07-22 11:13:08 +01001258 dev_err(&serial->dev->dev, "ezusb_writememory failed for Keyspan firmware (%d %04X %p %d)\n",
David Woodhouse2971c572008-05-30 14:04:03 +03001259 response, be32_to_cpu(record->addr),
1260 record->data, be16_to_cpu(record->len));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 break;
1262 }
David Woodhouse2971c572008-05-30 14:04:03 +03001263 record = ihex_next_binrec(record);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 }
David Woodhouse2971c572008-05-30 14:04:03 +03001265 release_firmware(fw);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 /* bring device out of reset. Renumeration will occur in a
1267 moment and the new device will bind to the real driver */
1268 response = ezusb_set_reset(serial, 0);
1269
1270 /* we don't want this device to have a driver assigned to it. */
Alan Coxdeb91682008-07-22 11:13:08 +01001271 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272}
1273
1274/* Helper functions used by keyspan_setup_urbs */
Rainer Weikusatfdcba532007-01-03 15:36:25 +01001275static struct usb_endpoint_descriptor const *find_ep(struct usb_serial const *serial,
1276 int endpoint)
1277{
1278 struct usb_host_interface *iface_desc;
1279 struct usb_endpoint_descriptor *ep;
1280 int i;
1281
1282 iface_desc = serial->interface->cur_altsetting;
1283 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1284 ep = &iface_desc->endpoint[i].desc;
1285 if (ep->bEndpointAddress == endpoint)
1286 return ep;
1287 }
1288 dev_warn(&serial->interface->dev, "found no endpoint descriptor for "
1289 "endpoint %x\n", endpoint);
1290 return NULL;
1291}
1292
Alan Coxdeb91682008-07-22 11:13:08 +01001293static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 int dir, void *ctx, char *buf, int len,
David Howells7d12e782006-10-05 14:55:46 +01001295 void (*callback)(struct urb *))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296{
1297 struct urb *urb;
Rainer Weikusatfdcba532007-01-03 15:36:25 +01001298 struct usb_endpoint_descriptor const *ep_desc;
1299 char const *ep_type_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
1301 if (endpoint == -1)
1302 return NULL; /* endpoint not needed */
1303
Alan Coxdeb91682008-07-22 11:13:08 +01001304 dbg("%s - alloc for endpoint %d.", __func__, endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 urb = usb_alloc_urb(0, GFP_KERNEL); /* No ISO */
1306 if (urb == NULL) {
Alan Coxdeb91682008-07-22 11:13:08 +01001307 dbg("%s - alloc for endpoint %d failed.", __func__, endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 return NULL;
1309 }
1310
Lucy McCoy0ca12682007-05-18 12:10:41 -07001311 if (endpoint == 0) {
1312 /* control EP filled in when used */
1313 return urb;
1314 }
1315
Rainer Weikusatfdcba532007-01-03 15:36:25 +01001316 ep_desc = find_ep(serial, endpoint);
1317 if (!ep_desc) {
1318 /* leak the urb, something's wrong and the callers don't care */
1319 return urb;
1320 }
1321 if (usb_endpoint_xfer_int(ep_desc)) {
1322 ep_type_name = "INT";
1323 usb_fill_int_urb(urb, serial->dev,
1324 usb_sndintpipe(serial->dev, endpoint) | dir,
1325 buf, len, callback, ctx,
1326 ep_desc->bInterval);
1327 } else if (usb_endpoint_xfer_bulk(ep_desc)) {
1328 ep_type_name = "BULK";
1329 usb_fill_bulk_urb(urb, serial->dev,
1330 usb_sndbulkpipe(serial->dev, endpoint) | dir,
1331 buf, len, callback, ctx);
1332 } else {
1333 dev_warn(&serial->interface->dev,
1334 "unsupported endpoint type %x\n",
Julia Lawall2e0fe702008-12-29 11:22:14 +01001335 usb_endpoint_type(ep_desc));
Rainer Weikusatfdcba532007-01-03 15:36:25 +01001336 usb_free_urb(urb);
1337 return NULL;
1338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Rainer Weikusatfdcba532007-01-03 15:36:25 +01001340 dbg("%s - using urb %p for %s endpoint %x",
1341 __func__, urb, ep_type_name, endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 return urb;
1343}
1344
1345static struct callbacks {
David Howells7d12e782006-10-05 14:55:46 +01001346 void (*instat_callback)(struct urb *);
1347 void (*glocont_callback)(struct urb *);
1348 void (*indat_callback)(struct urb *);
1349 void (*outdat_callback)(struct urb *);
1350 void (*inack_callback)(struct urb *);
1351 void (*outcont_callback)(struct urb *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352} keyspan_callbacks[] = {
1353 {
1354 /* msg_usa26 callbacks */
1355 .instat_callback = usa26_instat_callback,
1356 .glocont_callback = usa26_glocont_callback,
1357 .indat_callback = usa26_indat_callback,
1358 .outdat_callback = usa2x_outdat_callback,
1359 .inack_callback = usa26_inack_callback,
1360 .outcont_callback = usa26_outcont_callback,
1361 }, {
1362 /* msg_usa28 callbacks */
1363 .instat_callback = usa28_instat_callback,
1364 .glocont_callback = usa28_glocont_callback,
1365 .indat_callback = usa28_indat_callback,
1366 .outdat_callback = usa2x_outdat_callback,
1367 .inack_callback = usa28_inack_callback,
1368 .outcont_callback = usa28_outcont_callback,
1369 }, {
1370 /* msg_usa49 callbacks */
1371 .instat_callback = usa49_instat_callback,
1372 .glocont_callback = usa49_glocont_callback,
1373 .indat_callback = usa49_indat_callback,
1374 .outdat_callback = usa2x_outdat_callback,
1375 .inack_callback = usa49_inack_callback,
1376 .outcont_callback = usa49_outcont_callback,
1377 }, {
1378 /* msg_usa90 callbacks */
1379 .instat_callback = usa90_instat_callback,
Alan Coxdeb91682008-07-22 11:13:08 +01001380 .glocont_callback = usa28_glocont_callback,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 .indat_callback = usa90_indat_callback,
1382 .outdat_callback = usa2x_outdat_callback,
1383 .inack_callback = usa28_inack_callback,
1384 .outcont_callback = usa90_outcont_callback,
Lucy McCoy0ca12682007-05-18 12:10:41 -07001385 }, {
1386 /* msg_usa67 callbacks */
1387 .instat_callback = usa67_instat_callback,
1388 .glocont_callback = usa67_glocont_callback,
1389 .indat_callback = usa26_indat_callback,
1390 .outdat_callback = usa2x_outdat_callback,
1391 .inack_callback = usa26_inack_callback,
1392 .outcont_callback = usa26_outcont_callback,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 }
1394};
1395
1396 /* Generic setup urbs function that uses
1397 data in device_details */
1398static void keyspan_setup_urbs(struct usb_serial *serial)
1399{
1400 int i, j;
1401 struct keyspan_serial_private *s_priv;
1402 const struct keyspan_device_details *d_details;
1403 struct usb_serial_port *port;
1404 struct keyspan_port_private *p_priv;
1405 struct callbacks *cback;
1406 int endp;
1407
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 s_priv = usb_get_serial_data(serial);
1409 d_details = s_priv->device_details;
1410
Alan Coxdeb91682008-07-22 11:13:08 +01001411 /* Setup values for the various callback routines */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 cback = &keyspan_callbacks[d_details->msg_format];
1413
Alan Coxdeb91682008-07-22 11:13:08 +01001414 /* Allocate and set up urbs for each one that is in use,
1415 starting with instat endpoints */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 s_priv->instat_urb = keyspan_setup_urb
1417 (serial, d_details->instat_endpoint, USB_DIR_IN,
1418 serial, s_priv->instat_buf, INSTAT_BUFLEN,
1419 cback->instat_callback);
1420
Lucy McCoy0ca12682007-05-18 12:10:41 -07001421 s_priv->indat_urb = keyspan_setup_urb
1422 (serial, d_details->indat_endpoint, USB_DIR_IN,
1423 serial, s_priv->indat_buf, INDAT49W_BUFLEN,
1424 usa49wg_indat_callback);
1425
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 s_priv->glocont_urb = keyspan_setup_urb
1427 (serial, d_details->glocont_endpoint, USB_DIR_OUT,
1428 serial, s_priv->glocont_buf, GLOCONT_BUFLEN,
1429 cback->glocont_callback);
1430
Alan Coxdeb91682008-07-22 11:13:08 +01001431 /* Setup endpoints for each port specific thing */
1432 for (i = 0; i < d_details->num_ports; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 port = serial->port[i];
1434 p_priv = usb_get_serial_port_data(port);
1435
1436 /* Do indat endpoints first, once for each flip */
1437 endp = d_details->indat_endpoints[i];
1438 for (j = 0; j <= d_details->indat_endp_flip; ++j, ++endp) {
1439 p_priv->in_urbs[j] = keyspan_setup_urb
1440 (serial, endp, USB_DIR_IN, port,
1441 p_priv->in_buffer[j], 64,
1442 cback->indat_callback);
1443 }
1444 for (; j < 2; ++j)
1445 p_priv->in_urbs[j] = NULL;
1446
1447 /* outdat endpoints also have flip */
1448 endp = d_details->outdat_endpoints[i];
1449 for (j = 0; j <= d_details->outdat_endp_flip; ++j, ++endp) {
1450 p_priv->out_urbs[j] = keyspan_setup_urb
1451 (serial, endp, USB_DIR_OUT, port,
1452 p_priv->out_buffer[j], 64,
1453 cback->outdat_callback);
1454 }
1455 for (; j < 2; ++j)
1456 p_priv->out_urbs[j] = NULL;
1457
1458 /* inack endpoint */
1459 p_priv->inack_urb = keyspan_setup_urb
1460 (serial, d_details->inack_endpoints[i], USB_DIR_IN,
1461 port, p_priv->inack_buffer, 1, cback->inack_callback);
1462
1463 /* outcont endpoint */
1464 p_priv->outcont_urb = keyspan_setup_urb
1465 (serial, d_details->outcont_endpoints[i], USB_DIR_OUT,
1466 port, p_priv->outcont_buffer, 64,
1467 cback->outcont_callback);
Alan Coxdeb91682008-07-22 11:13:08 +01001468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469}
1470
1471/* usa19 function doesn't require prescaler */
1472static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1473 u8 *rate_low, u8 *prescaler, int portnum)
1474{
1475 u32 b16, /* baud rate times 16 (actual rate used internally) */
Alan Coxdeb91682008-07-22 11:13:08 +01001476 div, /* divisor */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 cnt; /* inverse of divisor (programmed into 8051) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478
Alan Coxdeb91682008-07-22 11:13:08 +01001479 dbg("%s - %d.", __func__, baud_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480
Alan Coxdeb91682008-07-22 11:13:08 +01001481 /* prevent divide by zero... */
1482 b16 = baud_rate * 16L;
1483 if (b16 == 0)
1484 return KEYSPAN_INVALID_BAUD_RATE;
1485 /* Any "standard" rate over 57k6 is marginal on the USA-19
1486 as we run out of divisor resolution. */
1487 if (baud_rate > 57600)
1488 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
Alan Coxdeb91682008-07-22 11:13:08 +01001490 /* calculate the divisor and the counter (its inverse) */
1491 div = baudclk / b16;
1492 if (div == 0)
1493 return KEYSPAN_INVALID_BAUD_RATE;
1494 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 cnt = 0 - div;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
Alan Coxdeb91682008-07-22 11:13:08 +01001497 if (div > 0xffff)
1498 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
Alan Coxdeb91682008-07-22 11:13:08 +01001500 /* return the counter values if non-null */
1501 if (rate_low)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 *rate_low = (u8) (cnt & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001503 if (rate_hi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 *rate_hi = (u8) ((cnt >> 8) & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001505 if (rate_low && rate_hi)
1506 dbg("%s - %d %02x %02x.",
1507 __func__, baud_rate, *rate_hi, *rate_low);
1508 return KEYSPAN_BAUD_RATE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509}
1510
1511/* usa19hs function doesn't require prescaler */
1512static int keyspan_usa19hs_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1513 u8 *rate_low, u8 *prescaler, int portnum)
1514{
1515 u32 b16, /* baud rate times 16 (actual rate used internally) */
Alan Coxdeb91682008-07-22 11:13:08 +01001516 div; /* divisor */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517
Alan Coxdeb91682008-07-22 11:13:08 +01001518 dbg("%s - %d.", __func__, baud_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Alan Coxdeb91682008-07-22 11:13:08 +01001520 /* prevent divide by zero... */
1521 b16 = baud_rate * 16L;
1522 if (b16 == 0)
1523 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
Alan Coxdeb91682008-07-22 11:13:08 +01001525 /* calculate the divisor */
1526 div = baudclk / b16;
1527 if (div == 0)
1528 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529
Alan Coxdeb91682008-07-22 11:13:08 +01001530 if (div > 0xffff)
1531 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
Alan Coxdeb91682008-07-22 11:13:08 +01001533 /* return the counter values if non-null */
1534 if (rate_low)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 *rate_low = (u8) (div & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001536
1537 if (rate_hi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 *rate_hi = (u8) ((div >> 8) & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001539
1540 if (rate_low && rate_hi)
1541 dbg("%s - %d %02x %02x.",
1542 __func__, baud_rate, *rate_hi, *rate_low);
1543
1544 return KEYSPAN_BAUD_RATE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545}
1546
1547static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1548 u8 *rate_low, u8 *prescaler, int portnum)
1549{
1550 u32 b16, /* baud rate times 16 (actual rate used internally) */
1551 clk, /* clock with 13/8 prescaler */
Alan Coxdeb91682008-07-22 11:13:08 +01001552 div, /* divisor using 13/8 prescaler */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 res, /* resulting baud rate using 13/8 prescaler */
1554 diff, /* error using 13/8 prescaler */
1555 smallest_diff;
1556 u8 best_prescaler;
1557 int i;
1558
Alan Coxdeb91682008-07-22 11:13:08 +01001559 dbg("%s - %d.", __func__, baud_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560
Alan Coxdeb91682008-07-22 11:13:08 +01001561 /* prevent divide by zero */
1562 b16 = baud_rate * 16L;
1563 if (b16 == 0)
1564 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
Alan Coxdeb91682008-07-22 11:13:08 +01001566 /* Calculate prescaler by trying them all and looking
1567 for best fit */
1568
1569 /* start with largest possible difference */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 smallest_diff = 0xffffffff;
1571
1572 /* 0 is an invalid prescaler, used as a flag */
1573 best_prescaler = 0;
1574
Alan Coxdeb91682008-07-22 11:13:08 +01001575 for (i = 8; i <= 0xff; ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 clk = (baudclk * 8) / (u32) i;
Alan Coxdeb91682008-07-22 11:13:08 +01001577
1578 div = clk / b16;
1579 if (div == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581
1582 res = clk / div;
Alan Coxdeb91682008-07-22 11:13:08 +01001583 diff = (res > b16) ? (res-b16) : (b16-res);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584
Alan Coxdeb91682008-07-22 11:13:08 +01001585 if (diff < smallest_diff) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 best_prescaler = i;
1587 smallest_diff = diff;
1588 }
1589 }
1590
Alan Coxdeb91682008-07-22 11:13:08 +01001591 if (best_prescaler == 0)
1592 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
1594 clk = (baudclk * 8) / (u32) best_prescaler;
1595 div = clk / b16;
1596
Alan Coxdeb91682008-07-22 11:13:08 +01001597 /* return the divisor and prescaler if non-null */
1598 if (rate_low)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 *rate_low = (u8) (div & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001600 if (rate_hi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 *rate_hi = (u8) ((div >> 8) & 0xff);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 if (prescaler) {
1603 *prescaler = best_prescaler;
Harvey Harrison441b62c2008-03-03 16:08:34 -08001604 /* dbg("%s - %d %d", __func__, *prescaler, div); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 }
Alan Coxdeb91682008-07-22 11:13:08 +01001606 return KEYSPAN_BAUD_RATE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607}
1608
1609 /* USA-28 supports different maximum baud rates on each port */
1610static int keyspan_usa28_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
1611 u8 *rate_low, u8 *prescaler, int portnum)
1612{
1613 u32 b16, /* baud rate times 16 (actual rate used internally) */
Alan Coxdeb91682008-07-22 11:13:08 +01001614 div, /* divisor */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 cnt; /* inverse of divisor (programmed into 8051) */
1616
Alan Coxdeb91682008-07-22 11:13:08 +01001617 dbg("%s - %d.", __func__, baud_rate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618
1619 /* prevent divide by zero */
Alan Coxdeb91682008-07-22 11:13:08 +01001620 b16 = baud_rate * 16L;
1621 if (b16 == 0)
1622 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
Alan Coxdeb91682008-07-22 11:13:08 +01001624 /* calculate the divisor and the counter (its inverse) */
1625 div = KEYSPAN_USA28_BAUDCLK / b16;
1626 if (div == 0)
1627 return KEYSPAN_INVALID_BAUD_RATE;
1628 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 cnt = 0 - div;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
Alan Coxdeb91682008-07-22 11:13:08 +01001631 /* check for out of range, based on portnum,
1632 and return result */
1633 if (portnum == 0) {
1634 if (div > 0xffff)
1635 return KEYSPAN_INVALID_BAUD_RATE;
1636 } else {
1637 if (portnum == 1) {
1638 if (div > 0xff)
1639 return KEYSPAN_INVALID_BAUD_RATE;
1640 } else
1641 return KEYSPAN_INVALID_BAUD_RATE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 }
1643
1644 /* return the counter values if not NULL
1645 (port 1 will ignore retHi) */
Alan Coxdeb91682008-07-22 11:13:08 +01001646 if (rate_low)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 *rate_low = (u8) (cnt & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001648 if (rate_hi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 *rate_hi = (u8) ((cnt >> 8) & 0xff);
Alan Coxdeb91682008-07-22 11:13:08 +01001650 dbg("%s - %d OK.", __func__, baud_rate);
1651 return KEYSPAN_BAUD_RATE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652}
1653
1654static int keyspan_usa26_send_setup(struct usb_serial *serial,
1655 struct usb_serial_port *port,
1656 int reset_port)
1657{
Alan Coxdeb91682008-07-22 11:13:08 +01001658 struct keyspan_usa26_portControlMessage msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 struct keyspan_serial_private *s_priv;
1660 struct keyspan_port_private *p_priv;
1661 const struct keyspan_device_details *d_details;
1662 int outcont_urb;
1663 struct urb *this_urb;
1664 int device_port, err;
1665
Alan Coxdeb91682008-07-22 11:13:08 +01001666 dbg("%s reset=%d", __func__, reset_port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
1668 s_priv = usb_get_serial_data(serial);
1669 p_priv = usb_get_serial_port_data(port);
1670 d_details = s_priv->device_details;
1671 device_port = port->number - port->serial->minor;
1672
1673 outcont_urb = d_details->outcont_endpoints[port->number];
1674 this_urb = p_priv->outcont_urb;
1675
Harvey Harrison441b62c2008-03-03 16:08:34 -08001676 dbg("%s - endpoint %d", __func__, usb_pipeendpoint(this_urb->pipe));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 /* Make sure we have an urb then send the message */
1679 if (this_urb == NULL) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08001680 dbg("%s - oops no urb.", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return -1;
1682 }
1683
1684 /* Save reset port val for resend.
Lucy McCoy0ca12682007-05-18 12:10:41 -07001685 Don't overwrite resend for open/close condition. */
1686 if ((reset_port + 1) > p_priv->resend_cont)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687 p_priv->resend_cont = reset_port + 1;
1688 if (this_urb->status == -EINPROGRESS) {
Alan Coxdeb91682008-07-22 11:13:08 +01001689 /* dbg("%s - already writing", __func__); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 mdelay(5);
Alan Coxdeb91682008-07-22 11:13:08 +01001691 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 }
1693
Alan Coxdeb91682008-07-22 11:13:08 +01001694 memset(&msg, 0, sizeof(struct keyspan_usa26_portControlMessage));
1695
1696 /* Only set baud rate if it's changed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 if (p_priv->old_baud != p_priv->baud) {
1698 p_priv->old_baud = p_priv->baud;
1699 msg.setClocking = 0xff;
1700 if (d_details->calculate_baud_rate
1701 (p_priv->baud, d_details->baudclk, &msg.baudHi,
Alan Coxdeb91682008-07-22 11:13:08 +01001702 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1703 dbg("%s - Invalid baud rate %d requested, using 9600.",
1704 __func__, p_priv->baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 msg.baudLo = 0;
1706 msg.baudHi = 125; /* Values for 9600 baud */
1707 msg.prescaler = 10;
1708 }
1709 msg.setPrescaler = 0xff;
1710 }
1711
1712 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
1713 switch (p_priv->cflag & CSIZE) {
1714 case CS5:
1715 msg.lcr |= USA_DATABITS_5;
1716 break;
1717 case CS6:
1718 msg.lcr |= USA_DATABITS_6;
1719 break;
1720 case CS7:
1721 msg.lcr |= USA_DATABITS_7;
1722 break;
1723 case CS8:
1724 msg.lcr |= USA_DATABITS_8;
1725 break;
1726 }
1727 if (p_priv->cflag & PARENB) {
1728 /* note USA_PARITY_NONE == 0 */
1729 msg.lcr |= (p_priv->cflag & PARODD)?
Alan Coxdeb91682008-07-22 11:13:08 +01001730 USA_PARITY_ODD : USA_PARITY_EVEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 }
1732 msg.setLcr = 0xff;
1733
1734 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1735 msg.xonFlowControl = 0;
1736 msg.setFlowControl = 0xff;
1737 msg.forwardingLength = 16;
1738 msg.xonChar = 17;
1739 msg.xoffChar = 19;
1740
1741 /* Opening port */
1742 if (reset_port == 1) {
1743 msg._txOn = 1;
1744 msg._txOff = 0;
1745 msg.txFlush = 0;
1746 msg.txBreak = 0;
1747 msg.rxOn = 1;
1748 msg.rxOff = 0;
1749 msg.rxFlush = 1;
1750 msg.rxForward = 0;
1751 msg.returnStatus = 0;
1752 msg.resetDataToggle = 0xff;
1753 }
1754
1755 /* Closing port */
1756 else if (reset_port == 2) {
1757 msg._txOn = 0;
1758 msg._txOff = 1;
1759 msg.txFlush = 0;
1760 msg.txBreak = 0;
1761 msg.rxOn = 0;
1762 msg.rxOff = 1;
1763 msg.rxFlush = 1;
1764 msg.rxForward = 0;
1765 msg.returnStatus = 0;
1766 msg.resetDataToggle = 0;
1767 }
1768
1769 /* Sending intermediate configs */
1770 else {
Alan Coxdeb91682008-07-22 11:13:08 +01001771 msg._txOn = (!p_priv->break_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 msg._txOff = 0;
1773 msg.txFlush = 0;
1774 msg.txBreak = (p_priv->break_on);
1775 msg.rxOn = 0;
1776 msg.rxOff = 0;
1777 msg.rxFlush = 0;
1778 msg.rxForward = 0;
1779 msg.returnStatus = 0;
1780 msg.resetDataToggle = 0x0;
1781 }
1782
Alan Coxdeb91682008-07-22 11:13:08 +01001783 /* Do handshaking outputs */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 msg.setTxTriState_setRts = 0xff;
1785 msg.txTriState_rts = p_priv->rts_state;
1786
1787 msg.setHskoa_setDtr = 0xff;
1788 msg.hskoa_dtr = p_priv->dtr_state;
Alan Coxdeb91682008-07-22 11:13:08 +01001789
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 p_priv->resend_cont = 0;
Alan Coxdeb91682008-07-22 11:13:08 +01001791 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
1792
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 /* send the data out the device on control endpoint */
1794 this_urb->transfer_buffer_length = sizeof(msg);
1795
Alan Coxdeb91682008-07-22 11:13:08 +01001796 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1797 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08001798 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799#if 0
1800 else {
Harvey Harrison441b62c2008-03-03 16:08:34 -08001801 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 outcont_urb, this_urb->transfer_buffer_length,
1803 usb_pipeendpoint(this_urb->pipe));
1804 }
1805#endif
1806
Alan Coxa5b6f602008-04-08 17:16:06 +01001807 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808}
1809
1810static int keyspan_usa28_send_setup(struct usb_serial *serial,
1811 struct usb_serial_port *port,
1812 int reset_port)
1813{
Alan Coxdeb91682008-07-22 11:13:08 +01001814 struct keyspan_usa28_portControlMessage msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 struct keyspan_serial_private *s_priv;
1816 struct keyspan_port_private *p_priv;
1817 const struct keyspan_device_details *d_details;
1818 struct urb *this_urb;
1819 int device_port, err;
1820
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 s_priv = usb_get_serial_data(serial);
1822 p_priv = usb_get_serial_port_data(port);
1823 d_details = s_priv->device_details;
1824 device_port = port->number - port->serial->minor;
1825
1826 /* only do something if we have a bulk out endpoint */
Alan Coxdeb91682008-07-22 11:13:08 +01001827 this_urb = p_priv->outcont_urb;
1828 if (this_urb == NULL) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08001829 dbg("%s - oops no urb.", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 return -1;
1831 }
1832
1833 /* Save reset port val for resend.
Lucy McCoy0ca12682007-05-18 12:10:41 -07001834 Don't overwrite resend for open/close condition. */
1835 if ((reset_port + 1) > p_priv->resend_cont)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 p_priv->resend_cont = reset_port + 1;
1837 if (this_urb->status == -EINPROGRESS) {
Alan Coxdeb91682008-07-22 11:13:08 +01001838 dbg("%s already writing", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 mdelay(5);
Alan Coxdeb91682008-07-22 11:13:08 +01001840 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 }
1842
Alan Coxdeb91682008-07-22 11:13:08 +01001843 memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
1845 msg.setBaudRate = 1;
1846 if (d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk,
Alan Coxdeb91682008-07-22 11:13:08 +01001847 &msg.baudHi, &msg.baudLo, NULL, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1848 dbg("%s - Invalid baud rate requested %d.",
1849 __func__, p_priv->baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 msg.baudLo = 0xff;
1851 msg.baudHi = 0xb2; /* Values for 9600 baud */
1852 }
1853
1854 /* If parity is enabled, we must calculate it ourselves. */
1855 msg.parity = 0; /* XXX for now */
1856
1857 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
1858 msg.xonFlowControl = 0;
1859
Alan Coxdeb91682008-07-22 11:13:08 +01001860 /* Do handshaking outputs, DTR is inverted relative to RTS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 msg.rts = p_priv->rts_state;
1862 msg.dtr = p_priv->dtr_state;
1863
1864 msg.forwardingLength = 16;
1865 msg.forwardMs = 10;
1866 msg.breakThreshold = 45;
1867 msg.xonChar = 17;
1868 msg.xoffChar = 19;
1869
1870 /*msg.returnStatus = 1;
1871 msg.resetDataToggle = 0xff;*/
1872 /* Opening port */
1873 if (reset_port == 1) {
1874 msg._txOn = 1;
1875 msg._txOff = 0;
1876 msg.txFlush = 0;
1877 msg.txForceXoff = 0;
1878 msg.txBreak = 0;
1879 msg.rxOn = 1;
1880 msg.rxOff = 0;
1881 msg.rxFlush = 1;
1882 msg.rxForward = 0;
1883 msg.returnStatus = 0;
1884 msg.resetDataToggle = 0xff;
1885 }
1886 /* Closing port */
1887 else if (reset_port == 2) {
1888 msg._txOn = 0;
1889 msg._txOff = 1;
1890 msg.txFlush = 0;
1891 msg.txForceXoff = 0;
1892 msg.txBreak = 0;
1893 msg.rxOn = 0;
1894 msg.rxOff = 1;
1895 msg.rxFlush = 1;
1896 msg.rxForward = 0;
1897 msg.returnStatus = 0;
1898 msg.resetDataToggle = 0;
1899 }
1900 /* Sending intermediate configs */
1901 else {
Alan Coxdeb91682008-07-22 11:13:08 +01001902 msg._txOn = (!p_priv->break_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 msg._txOff = 0;
1904 msg.txFlush = 0;
1905 msg.txForceXoff = 0;
1906 msg.txBreak = (p_priv->break_on);
1907 msg.rxOn = 0;
1908 msg.rxOff = 0;
1909 msg.rxFlush = 0;
1910 msg.rxForward = 0;
1911 msg.returnStatus = 0;
1912 msg.resetDataToggle = 0x0;
1913 }
1914
1915 p_priv->resend_cont = 0;
Alan Coxdeb91682008-07-22 11:13:08 +01001916 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
1918 /* send the data out the device on control endpoint */
1919 this_urb->transfer_buffer_length = sizeof(msg);
1920
Alan Coxdeb91682008-07-22 11:13:08 +01001921 err = usb_submit_urb(this_urb, GFP_ATOMIC);
1922 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08001923 dbg("%s - usb_submit_urb(setup) failed", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924#if 0
1925 else {
Harvey Harrison441b62c2008-03-03 16:08:34 -08001926 dbg("%s - usb_submit_urb(setup) OK %d bytes", __func__,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 this_urb->transfer_buffer_length);
1928 }
1929#endif
1930
Alan Coxa5b6f602008-04-08 17:16:06 +01001931 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932}
1933
1934static int keyspan_usa49_send_setup(struct usb_serial *serial,
1935 struct usb_serial_port *port,
1936 int reset_port)
1937{
Lucy McCoy0ca12682007-05-18 12:10:41 -07001938 struct keyspan_usa49_portControlMessage msg;
1939 struct usb_ctrlrequest *dr = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 struct keyspan_serial_private *s_priv;
1941 struct keyspan_port_private *p_priv;
1942 const struct keyspan_device_details *d_details;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 struct urb *this_urb;
1944 int err, device_port;
1945
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 s_priv = usb_get_serial_data(serial);
1947 p_priv = usb_get_serial_port_data(port);
1948 d_details = s_priv->device_details;
1949
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 this_urb = s_priv->glocont_urb;
1951
Lucy McCoy0ca12682007-05-18 12:10:41 -07001952 /* Work out which port within the device is being setup */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 device_port = port->number - port->serial->minor;
1954
Huzaifa Sidhpurwalad8661502011-02-21 12:58:44 +05301955 /* Make sure we have an urb then send the message */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 if (this_urb == NULL) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08001957 dbg("%s - oops no urb for port %d.", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 return -1;
1959 }
1960
Huzaifa Sidhpurwalad8661502011-02-21 12:58:44 +05301961 dbg("%s - endpoint %d port %d (%d)",
1962 __func__, usb_pipeendpoint(this_urb->pipe),
1963 port->number, device_port);
1964
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 /* Save reset port val for resend.
Lucy McCoy0ca12682007-05-18 12:10:41 -07001966 Don't overwrite resend for open/close condition. */
1967 if ((reset_port + 1) > p_priv->resend_cont)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 p_priv->resend_cont = reset_port + 1;
Lucy McCoy0ca12682007-05-18 12:10:41 -07001969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 if (this_urb->status == -EINPROGRESS) {
Alan Coxdeb91682008-07-22 11:13:08 +01001971 /* dbg("%s - already writing", __func__); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 mdelay(5);
Alan Coxdeb91682008-07-22 11:13:08 +01001973 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 }
1975
Alan Coxdeb91682008-07-22 11:13:08 +01001976 memset(&msg, 0, sizeof(struct keyspan_usa49_portControlMessage));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977
1978 /*msg.portNumber = port->number;*/
1979 msg.portNumber = device_port;
Alan Coxdeb91682008-07-22 11:13:08 +01001980
1981 /* Only set baud rate if it's changed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 if (p_priv->old_baud != p_priv->baud) {
1983 p_priv->old_baud = p_priv->baud;
1984 msg.setClocking = 0xff;
1985 if (d_details->calculate_baud_rate
1986 (p_priv->baud, d_details->baudclk, &msg.baudHi,
Alan Coxdeb91682008-07-22 11:13:08 +01001987 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
1988 dbg("%s - Invalid baud rate %d requested, using 9600.",
1989 __func__, p_priv->baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 msg.baudLo = 0;
1991 msg.baudHi = 125; /* Values for 9600 baud */
1992 msg.prescaler = 10;
1993 }
Alan Coxdeb91682008-07-22 11:13:08 +01001994 /* msg.setPrescaler = 0xff; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 }
1996
1997 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
1998 switch (p_priv->cflag & CSIZE) {
1999 case CS5:
2000 msg.lcr |= USA_DATABITS_5;
2001 break;
2002 case CS6:
2003 msg.lcr |= USA_DATABITS_6;
2004 break;
2005 case CS7:
2006 msg.lcr |= USA_DATABITS_7;
2007 break;
2008 case CS8:
2009 msg.lcr |= USA_DATABITS_8;
2010 break;
2011 }
2012 if (p_priv->cflag & PARENB) {
2013 /* note USA_PARITY_NONE == 0 */
2014 msg.lcr |= (p_priv->cflag & PARODD)?
Alan Coxdeb91682008-07-22 11:13:08 +01002015 USA_PARITY_ODD : USA_PARITY_EVEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 }
2017 msg.setLcr = 0xff;
2018
2019 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2020 msg.xonFlowControl = 0;
2021 msg.setFlowControl = 0xff;
Alan Coxdeb91682008-07-22 11:13:08 +01002022
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 msg.forwardingLength = 16;
2024 msg.xonChar = 17;
2025 msg.xoffChar = 19;
2026
Alan Coxdeb91682008-07-22 11:13:08 +01002027 /* Opening port */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028 if (reset_port == 1) {
2029 msg._txOn = 1;
2030 msg._txOff = 0;
2031 msg.txFlush = 0;
2032 msg.txBreak = 0;
2033 msg.rxOn = 1;
2034 msg.rxOff = 0;
2035 msg.rxFlush = 1;
2036 msg.rxForward = 0;
2037 msg.returnStatus = 0;
2038 msg.resetDataToggle = 0xff;
2039 msg.enablePort = 1;
2040 msg.disablePort = 0;
2041 }
2042 /* Closing port */
2043 else if (reset_port == 2) {
2044 msg._txOn = 0;
2045 msg._txOff = 1;
2046 msg.txFlush = 0;
2047 msg.txBreak = 0;
2048 msg.rxOn = 0;
2049 msg.rxOff = 1;
2050 msg.rxFlush = 1;
2051 msg.rxForward = 0;
2052 msg.returnStatus = 0;
2053 msg.resetDataToggle = 0;
2054 msg.enablePort = 0;
2055 msg.disablePort = 1;
2056 }
2057 /* Sending intermediate configs */
2058 else {
Alan Coxdeb91682008-07-22 11:13:08 +01002059 msg._txOn = (!p_priv->break_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 msg._txOff = 0;
2061 msg.txFlush = 0;
2062 msg.txBreak = (p_priv->break_on);
2063 msg.rxOn = 0;
2064 msg.rxOff = 0;
2065 msg.rxFlush = 0;
2066 msg.rxForward = 0;
2067 msg.returnStatus = 0;
2068 msg.resetDataToggle = 0x0;
2069 msg.enablePort = 0;
2070 msg.disablePort = 0;
2071 }
2072
Alan Coxdeb91682008-07-22 11:13:08 +01002073 /* Do handshaking outputs */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 msg.setRts = 0xff;
2075 msg.rts = p_priv->rts_state;
2076
2077 msg.setDtr = 0xff;
2078 msg.dtr = p_priv->dtr_state;
Alan Coxdeb91682008-07-22 11:13:08 +01002079
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 p_priv->resend_cont = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081
Alan Coxdeb91682008-07-22 11:13:08 +01002082 /* if the device is a 49wg, we send control message on usb
2083 control EP 0 */
Lucy McCoy0ca12682007-05-18 12:10:41 -07002084
2085 if (d_details->product_id == keyspan_usa49wg_product_id) {
2086 dr = (void *)(s_priv->ctrl_buf);
2087 dr->bRequestType = USB_TYPE_VENDOR | USB_DIR_OUT;
2088 dr->bRequest = 0xB0; /* 49wg control message */;
2089 dr->wValue = 0;
2090 dr->wIndex = 0;
2091 dr->wLength = cpu_to_le16(sizeof(msg));
2092
Alan Coxdeb91682008-07-22 11:13:08 +01002093 memcpy(s_priv->glocont_buf, &msg, sizeof(msg));
Lucy McCoy0ca12682007-05-18 12:10:41 -07002094
Alan Coxdeb91682008-07-22 11:13:08 +01002095 usb_fill_control_urb(this_urb, serial->dev,
2096 usb_sndctrlpipe(serial->dev, 0),
2097 (unsigned char *)dr, s_priv->glocont_buf,
2098 sizeof(msg), usa49_glocont_callback, serial);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002099
2100 } else {
2101 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
Alan Coxdeb91682008-07-22 11:13:08 +01002102
Lucy McCoy0ca12682007-05-18 12:10:41 -07002103 /* send the data out the device on control endpoint */
2104 this_urb->transfer_buffer_length = sizeof(msg);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002105 }
Alan Coxdeb91682008-07-22 11:13:08 +01002106 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2107 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08002108 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109#if 0
2110 else {
Harvey Harrison441b62c2008-03-03 16:08:34 -08002111 dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__,
Lucy McCoy0ca12682007-05-18 12:10:41 -07002112 outcont_urb, this_urb->transfer_buffer_length,
2113 usb_pipeendpoint(this_urb->pipe));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 }
2115#endif
2116
Alan Coxa5b6f602008-04-08 17:16:06 +01002117 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118}
2119
2120static int keyspan_usa90_send_setup(struct usb_serial *serial,
2121 struct usb_serial_port *port,
2122 int reset_port)
2123{
Alan Coxdeb91682008-07-22 11:13:08 +01002124 struct keyspan_usa90_portControlMessage msg;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 struct keyspan_serial_private *s_priv;
2126 struct keyspan_port_private *p_priv;
2127 const struct keyspan_device_details *d_details;
2128 struct urb *this_urb;
2129 int err;
2130 u8 prescaler;
2131
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 s_priv = usb_get_serial_data(serial);
2133 p_priv = usb_get_serial_port_data(port);
2134 d_details = s_priv->device_details;
2135
2136 /* only do something if we have a bulk out endpoint */
Alan Coxdeb91682008-07-22 11:13:08 +01002137 this_urb = p_priv->outcont_urb;
2138 if (this_urb == NULL) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08002139 dbg("%s - oops no urb.", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 return -1;
2141 }
2142
2143 /* Save reset port val for resend.
2144 Don't overwrite resend for open/close condition. */
2145 if ((reset_port + 1) > p_priv->resend_cont)
2146 p_priv->resend_cont = reset_port + 1;
2147 if (this_urb->status == -EINPROGRESS) {
Alan Coxdeb91682008-07-22 11:13:08 +01002148 dbg("%s already writing", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 mdelay(5);
Alan Coxdeb91682008-07-22 11:13:08 +01002150 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 }
2152
Alan Coxdeb91682008-07-22 11:13:08 +01002153 memset(&msg, 0, sizeof(struct keyspan_usa90_portControlMessage));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154
Alan Coxdeb91682008-07-22 11:13:08 +01002155 /* Only set baud rate if it's changed */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 if (p_priv->old_baud != p_priv->baud) {
2157 p_priv->old_baud = p_priv->baud;
2158 msg.setClocking = 0x01;
2159 if (d_details->calculate_baud_rate
2160 (p_priv->baud, d_details->baudclk, &msg.baudHi,
Alan Coxdeb91682008-07-22 11:13:08 +01002161 &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
2162 dbg("%s - Invalid baud rate %d requested, using 9600.",
2163 __func__, p_priv->baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164 p_priv->baud = 9600;
Alan Coxdeb91682008-07-22 11:13:08 +01002165 d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 &msg.baudHi, &msg.baudLo, &prescaler, 0);
2167 }
2168 msg.setRxMode = 1;
2169 msg.setTxMode = 1;
2170 }
2171
2172 /* modes must always be correctly specified */
Alan Coxdeb91682008-07-22 11:13:08 +01002173 if (p_priv->baud > 57600) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 msg.rxMode = RXMODE_DMA;
2175 msg.txMode = TXMODE_DMA;
Alan Coxdeb91682008-07-22 11:13:08 +01002176 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 msg.rxMode = RXMODE_BYHAND;
2178 msg.txMode = TXMODE_BYHAND;
2179 }
2180
2181 msg.lcr = (p_priv->cflag & CSTOPB)? STOPBITS_678_2: STOPBITS_5678_1;
2182 switch (p_priv->cflag & CSIZE) {
2183 case CS5:
2184 msg.lcr |= USA_DATABITS_5;
2185 break;
2186 case CS6:
2187 msg.lcr |= USA_DATABITS_6;
2188 break;
2189 case CS7:
2190 msg.lcr |= USA_DATABITS_7;
2191 break;
2192 case CS8:
2193 msg.lcr |= USA_DATABITS_8;
2194 break;
2195 }
2196 if (p_priv->cflag & PARENB) {
2197 /* note USA_PARITY_NONE == 0 */
2198 msg.lcr |= (p_priv->cflag & PARODD)?
Alan Coxdeb91682008-07-22 11:13:08 +01002199 USA_PARITY_ODD : USA_PARITY_EVEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 }
2201 if (p_priv->old_cflag != p_priv->cflag) {
2202 p_priv->old_cflag = p_priv->cflag;
2203 msg.setLcr = 0x01;
2204 }
2205
2206 if (p_priv->flow_control == flow_cts)
2207 msg.txFlowControl = TXFLOW_CTS;
2208 msg.setTxFlowControl = 0x01;
2209 msg.setRxFlowControl = 0x01;
Alan Coxdeb91682008-07-22 11:13:08 +01002210
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 msg.rxForwardingLength = 16;
Alan Coxdeb91682008-07-22 11:13:08 +01002212 msg.rxForwardingTimeout = 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213 msg.txAckSetting = 0;
2214 msg.xonChar = 17;
2215 msg.xoffChar = 19;
2216
Alan Coxdeb91682008-07-22 11:13:08 +01002217 /* Opening port */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 if (reset_port == 1) {
2219 msg.portEnabled = 1;
2220 msg.rxFlush = 1;
2221 msg.txBreak = (p_priv->break_on);
2222 }
2223 /* Closing port */
Alan Coxdeb91682008-07-22 11:13:08 +01002224 else if (reset_port == 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 msg.portEnabled = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 /* Sending intermediate configs */
2227 else {
Alan Stern1f871582010-02-17 10:05:47 -05002228 msg.portEnabled = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 msg.txBreak = (p_priv->break_on);
2230 }
2231
Alan Coxdeb91682008-07-22 11:13:08 +01002232 /* Do handshaking outputs */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 msg.setRts = 0x01;
2234 msg.rts = p_priv->rts_state;
2235
2236 msg.setDtr = 0x01;
2237 msg.dtr = p_priv->dtr_state;
Alan Coxdeb91682008-07-22 11:13:08 +01002238
Linus Torvalds1da177e2005-04-16 15:20:36 -07002239 p_priv->resend_cont = 0;
Alan Coxdeb91682008-07-22 11:13:08 +01002240 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2241
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 /* send the data out the device on control endpoint */
2243 this_urb->transfer_buffer_length = sizeof(msg);
2244
Alan Coxdeb91682008-07-22 11:13:08 +01002245 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2246 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08002247 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
Alan Coxa5b6f602008-04-08 17:16:06 +01002248 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249}
2250
Lucy McCoy0ca12682007-05-18 12:10:41 -07002251static int keyspan_usa67_send_setup(struct usb_serial *serial,
2252 struct usb_serial_port *port,
2253 int reset_port)
2254{
2255 struct keyspan_usa67_portControlMessage msg;
2256 struct keyspan_serial_private *s_priv;
2257 struct keyspan_port_private *p_priv;
2258 const struct keyspan_device_details *d_details;
2259 struct urb *this_urb;
2260 int err, device_port;
2261
Lucy McCoy0ca12682007-05-18 12:10:41 -07002262 s_priv = usb_get_serial_data(serial);
2263 p_priv = usb_get_serial_port_data(port);
2264 d_details = s_priv->device_details;
2265
2266 this_urb = s_priv->glocont_urb;
2267
2268 /* Work out which port within the device is being setup */
2269 device_port = port->number - port->serial->minor;
2270
2271 /* Make sure we have an urb then send the message */
2272 if (this_urb == NULL) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08002273 dbg("%s - oops no urb for port %d.", __func__,
Lucy McCoy0ca12682007-05-18 12:10:41 -07002274 port->number);
2275 return -1;
2276 }
2277
2278 /* Save reset port val for resend.
2279 Don't overwrite resend for open/close condition. */
2280 if ((reset_port + 1) > p_priv->resend_cont)
2281 p_priv->resend_cont = reset_port + 1;
2282 if (this_urb->status == -EINPROGRESS) {
Alan Coxdeb91682008-07-22 11:13:08 +01002283 /* dbg("%s - already writing", __func__); */
Lucy McCoy0ca12682007-05-18 12:10:41 -07002284 mdelay(5);
Alan Coxdeb91682008-07-22 11:13:08 +01002285 return -1;
Lucy McCoy0ca12682007-05-18 12:10:41 -07002286 }
2287
2288 memset(&msg, 0, sizeof(struct keyspan_usa67_portControlMessage));
2289
2290 msg.port = device_port;
2291
2292 /* Only set baud rate if it's changed */
2293 if (p_priv->old_baud != p_priv->baud) {
2294 p_priv->old_baud = p_priv->baud;
2295 msg.setClocking = 0xff;
2296 if (d_details->calculate_baud_rate
2297 (p_priv->baud, d_details->baudclk, &msg.baudHi,
Alan Coxdeb91682008-07-22 11:13:08 +01002298 &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
2299 dbg("%s - Invalid baud rate %d requested, using 9600.",
2300 __func__, p_priv->baud);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002301 msg.baudLo = 0;
2302 msg.baudHi = 125; /* Values for 9600 baud */
2303 msg.prescaler = 10;
2304 }
2305 msg.setPrescaler = 0xff;
2306 }
2307
2308 msg.lcr = (p_priv->cflag & CSTOPB) ? STOPBITS_678_2 : STOPBITS_5678_1;
2309 switch (p_priv->cflag & CSIZE) {
2310 case CS5:
2311 msg.lcr |= USA_DATABITS_5;
2312 break;
2313 case CS6:
2314 msg.lcr |= USA_DATABITS_6;
2315 break;
2316 case CS7:
2317 msg.lcr |= USA_DATABITS_7;
2318 break;
2319 case CS8:
2320 msg.lcr |= USA_DATABITS_8;
2321 break;
2322 }
2323 if (p_priv->cflag & PARENB) {
2324 /* note USA_PARITY_NONE == 0 */
2325 msg.lcr |= (p_priv->cflag & PARODD)?
Alan Coxdeb91682008-07-22 11:13:08 +01002326 USA_PARITY_ODD : USA_PARITY_EVEN;
Lucy McCoy0ca12682007-05-18 12:10:41 -07002327 }
2328 msg.setLcr = 0xff;
2329
2330 msg.ctsFlowControl = (p_priv->flow_control == flow_cts);
2331 msg.xonFlowControl = 0;
2332 msg.setFlowControl = 0xff;
2333 msg.forwardingLength = 16;
2334 msg.xonChar = 17;
2335 msg.xoffChar = 19;
2336
2337 if (reset_port == 1) {
2338 /* Opening port */
2339 msg._txOn = 1;
2340 msg._txOff = 0;
2341 msg.txFlush = 0;
2342 msg.txBreak = 0;
2343 msg.rxOn = 1;
2344 msg.rxOff = 0;
2345 msg.rxFlush = 1;
2346 msg.rxForward = 0;
2347 msg.returnStatus = 0;
2348 msg.resetDataToggle = 0xff;
2349 } else if (reset_port == 2) {
2350 /* Closing port */
2351 msg._txOn = 0;
2352 msg._txOff = 1;
2353 msg.txFlush = 0;
2354 msg.txBreak = 0;
2355 msg.rxOn = 0;
2356 msg.rxOff = 1;
2357 msg.rxFlush = 1;
2358 msg.rxForward = 0;
2359 msg.returnStatus = 0;
2360 msg.resetDataToggle = 0;
2361 } else {
2362 /* Sending intermediate configs */
Alan Coxdeb91682008-07-22 11:13:08 +01002363 msg._txOn = (!p_priv->break_on);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002364 msg._txOff = 0;
2365 msg.txFlush = 0;
2366 msg.txBreak = (p_priv->break_on);
2367 msg.rxOn = 0;
2368 msg.rxOff = 0;
2369 msg.rxFlush = 0;
2370 msg.rxForward = 0;
2371 msg.returnStatus = 0;
2372 msg.resetDataToggle = 0x0;
2373 }
2374
2375 /* Do handshaking outputs */
2376 msg.setTxTriState_setRts = 0xff;
2377 msg.txTriState_rts = p_priv->rts_state;
2378
2379 msg.setHskoa_setDtr = 0xff;
2380 msg.hskoa_dtr = p_priv->dtr_state;
2381
2382 p_priv->resend_cont = 0;
2383
2384 memcpy(this_urb->transfer_buffer, &msg, sizeof(msg));
2385
2386 /* send the data out the device on control endpoint */
2387 this_urb->transfer_buffer_length = sizeof(msg);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002388
2389 err = usb_submit_urb(this_urb, GFP_ATOMIC);
2390 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08002391 dbg("%s - usb_submit_urb(setup) failed (%d)", __func__,
Lucy McCoy0ca12682007-05-18 12:10:41 -07002392 err);
Alan Coxa5b6f602008-04-08 17:16:06 +01002393 return 0;
Lucy McCoy0ca12682007-05-18 12:10:41 -07002394}
2395
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396static void keyspan_send_setup(struct usb_serial_port *port, int reset_port)
2397{
2398 struct usb_serial *serial = port->serial;
2399 struct keyspan_serial_private *s_priv;
2400 const struct keyspan_device_details *d_details;
2401
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 s_priv = usb_get_serial_data(serial);
2403 d_details = s_priv->device_details;
2404
2405 switch (d_details->msg_format) {
2406 case msg_usa26:
2407 keyspan_usa26_send_setup(serial, port, reset_port);
2408 break;
2409 case msg_usa28:
2410 keyspan_usa28_send_setup(serial, port, reset_port);
2411 break;
2412 case msg_usa49:
2413 keyspan_usa49_send_setup(serial, port, reset_port);
2414 break;
2415 case msg_usa90:
2416 keyspan_usa90_send_setup(serial, port, reset_port);
2417 break;
Lucy McCoy0ca12682007-05-18 12:10:41 -07002418 case msg_usa67:
2419 keyspan_usa67_send_setup(serial, port, reset_port);
2420 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 }
2422}
2423
2424
2425/* Gets called by the "real" driver (ie once firmware is loaded
2426 and renumeration has taken place. */
Alan Coxdeb91682008-07-22 11:13:08 +01002427static int keyspan_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428{
2429 int i, err;
2430 struct usb_serial_port *port;
2431 struct keyspan_serial_private *s_priv;
2432 struct keyspan_port_private *p_priv;
2433 const struct keyspan_device_details *d_details;
2434
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435 for (i = 0; (d_details = keyspan_devices[i]) != NULL; ++i)
Alan Coxdeb91682008-07-22 11:13:08 +01002436 if (d_details->product_id ==
2437 le16_to_cpu(serial->dev->descriptor.idProduct))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 break;
2439 if (d_details == NULL) {
Alan Coxdeb91682008-07-22 11:13:08 +01002440 dev_err(&serial->dev->dev, "%s - unknown product id %x\n",
2441 __func__, le16_to_cpu(serial->dev->descriptor.idProduct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 return 1;
2443 }
2444
2445 /* Setup private data for serial driver */
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +01002446 s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 if (!s_priv) {
Alan Coxdeb91682008-07-22 11:13:08 +01002448 dbg("%s - kmalloc for keyspan_serial_private failed.",
2449 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 return -ENOMEM;
2451 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452
2453 s_priv->device_details = d_details;
2454 usb_set_serial_data(serial, s_priv);
2455
2456 /* Now setup per port private data */
2457 for (i = 0; i < serial->num_ports; i++) {
2458 port = serial->port[i];
Alan Coxdeb91682008-07-22 11:13:08 +01002459 p_priv = kzalloc(sizeof(struct keyspan_port_private),
2460 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 if (!p_priv) {
Harvey Harrison441b62c2008-03-03 16:08:34 -08002462 dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __func__, i);
Alan Coxdeb91682008-07-22 11:13:08 +01002463 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 p_priv->device_details = d_details;
2466 usb_set_serial_port_data(port, p_priv);
2467 }
2468
2469 keyspan_setup_urbs(serial);
2470
Lucy McCoy0ca12682007-05-18 12:10:41 -07002471 if (s_priv->instat_urb != NULL) {
Lucy McCoy0ca12682007-05-18 12:10:41 -07002472 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
2473 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08002474 dbg("%s - submit instat urb failed %d", __func__,
Lucy McCoy0ca12682007-05-18 12:10:41 -07002475 err);
2476 }
2477 if (s_priv->indat_urb != NULL) {
Lucy McCoy0ca12682007-05-18 12:10:41 -07002478 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
2479 if (err != 0)
Harvey Harrison441b62c2008-03-03 16:08:34 -08002480 dbg("%s - submit indat urb failed %d", __func__,
Lucy McCoy0ca12682007-05-18 12:10:41 -07002481 err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 }
Alan Coxdeb91682008-07-22 11:13:08 +01002483
Alan Coxa5b6f602008-04-08 17:16:06 +01002484 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485}
2486
Alan Sternf9c99bb2009-06-02 11:53:55 -04002487static void keyspan_disconnect(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488{
2489 int i, j;
2490 struct usb_serial_port *port;
2491 struct keyspan_serial_private *s_priv;
2492 struct keyspan_port_private *p_priv;
2493
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 s_priv = usb_get_serial_data(serial);
2495
2496 /* Stop reading/writing urbs */
2497 stop_urb(s_priv->instat_urb);
2498 stop_urb(s_priv->glocont_urb);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002499 stop_urb(s_priv->indat_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002500 for (i = 0; i < serial->num_ports; ++i) {
2501 port = serial->port[i];
2502 p_priv = usb_get_serial_port_data(port);
2503 stop_urb(p_priv->inack_urb);
2504 stop_urb(p_priv->outcont_urb);
2505 for (j = 0; j < 2; j++) {
2506 stop_urb(p_priv->in_urbs[j]);
2507 stop_urb(p_priv->out_urbs[j]);
2508 }
2509 }
2510
2511 /* Now free them */
Mariusz Kozlowski1cadc132006-11-08 15:36:34 +01002512 usb_free_urb(s_priv->instat_urb);
Lucy McCoy0ca12682007-05-18 12:10:41 -07002513 usb_free_urb(s_priv->indat_urb);
Mariusz Kozlowski1cadc132006-11-08 15:36:34 +01002514 usb_free_urb(s_priv->glocont_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 for (i = 0; i < serial->num_ports; ++i) {
2516 port = serial->port[i];
2517 p_priv = usb_get_serial_port_data(port);
Mariusz Kozlowski1cadc132006-11-08 15:36:34 +01002518 usb_free_urb(p_priv->inack_urb);
2519 usb_free_urb(p_priv->outcont_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520 for (j = 0; j < 2; j++) {
Mariusz Kozlowski1cadc132006-11-08 15:36:34 +01002521 usb_free_urb(p_priv->in_urbs[j]);
2522 usb_free_urb(p_priv->out_urbs[j]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 }
2524 }
Alan Sternf9c99bb2009-06-02 11:53:55 -04002525}
2526
2527static void keyspan_release(struct usb_serial *serial)
2528{
2529 int i;
2530 struct usb_serial_port *port;
2531 struct keyspan_serial_private *s_priv;
2532
Alan Sternf9c99bb2009-06-02 11:53:55 -04002533 s_priv = usb_get_serial_data(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534
2535 /* dbg("Freeing serial->private."); */
2536 kfree(s_priv);
2537
2538 /* dbg("Freeing port->private."); */
2539 /* Now free per port private data */
2540 for (i = 0; i < serial->num_ports; i++) {
2541 port = serial->port[i];
2542 kfree(usb_get_serial_port_data(port));
2543 }
2544}
2545
Alan Coxdeb91682008-07-22 11:13:08 +01002546MODULE_AUTHOR(DRIVER_AUTHOR);
2547MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548MODULE_LICENSE("GPL");
2549
David Woodhouse2971c572008-05-30 14:04:03 +03002550MODULE_FIRMWARE("keyspan/usa28.fw");
2551MODULE_FIRMWARE("keyspan/usa28x.fw");
2552MODULE_FIRMWARE("keyspan/usa28xa.fw");
2553MODULE_FIRMWARE("keyspan/usa28xb.fw");
2554MODULE_FIRMWARE("keyspan/usa19.fw");
2555MODULE_FIRMWARE("keyspan/usa19qi.fw");
2556MODULE_FIRMWARE("keyspan/mpr.fw");
2557MODULE_FIRMWARE("keyspan/usa19qw.fw");
2558MODULE_FIRMWARE("keyspan/usa18x.fw");
2559MODULE_FIRMWARE("keyspan/usa19w.fw");
2560MODULE_FIRMWARE("keyspan/usa49w.fw");
2561MODULE_FIRMWARE("keyspan/usa49wlc.fw");
2562
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563module_param(debug, bool, S_IRUGO | S_IWUSR);
2564MODULE_PARM_DESC(debug, "Debug enabled or not");
2565