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