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