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