Eric Lee / smarc-ti-linux-kernel

Download as
Browse Code ยป

Commit 2c5d2dde06b89f1a2f3fc5f064cd39685f8e3c47

Authored by Johan Hovold
Committed by Greg Kroah-Hartman
1 parent 14d38f7d80

USB: keyspan: fix null-deref at probe 

commit b5122236bba8d7ef62153da5b55cc65d0944c61e upstream.

Fix null-pointer dereference during probe if the interface-status
completion handler is called before the individual ports have been set
up.

Fixes: f79b2d0fe81e ("USB: keyspan: fix NULL-pointer dereferences and
memory leaks")
Reported-by: Richard <richjunk@pacbell.net>
Tested-by: Richard <richjunk@pacbell.net>
Signed-off-by: Johan Hovold <johan@kernel.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

Showing 1 changed file with 15 additions and 5 deletions Inline Diff

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