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