agilent_82357a.c

   1// SPDX-License-Identifier: GPL-2.0
   2
   3/***************************************************************************
   4 *	driver for Agilent 82357A/B usb to gpib adapters		   *
   5 *    copyright		   : (C) 2004 by Frank Mori Hess		   *
   6 ***************************************************************************/
   7
   8#define _GNU_SOURCE
   9
  10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11#define dev_fmt pr_fmt
  12#define DRV_NAME KBUILD_MODNAME
  13
  14#include <linux/kernel.h>
  15#include <linux/module.h>
  16#include <linux/slab.h>
  17#include "agilent_82357a.h"
  18#include "gpibP.h"
  19#include "tms9914.h"
  20
  21MODULE_LICENSE("GPL");
  22MODULE_DESCRIPTION("GPIB driver for Agilent 82357A/B usb adapters");
  23
  24#define MAX_NUM_82357A_INTERFACES 128
  25static struct usb_interface *agilent_82357a_driver_interfaces[MAX_NUM_82357A_INTERFACES];
  26static DEFINE_MUTEX(agilent_82357a_hotplug_lock); // protect board insertion and removal
  27
  28static unsigned int agilent_82357a_update_status(struct gpib_board *board,
  29						 unsigned int clear_mask);
  30
  31static int agilent_82357a_take_control_internal(struct gpib_board *board, int synchronous);
  32
  33static void agilent_82357a_bulk_complete(struct urb *urb)
  34{
  35	struct agilent_82357a_urb_ctx *context = urb->context;
  36
  37	complete(&context->complete);
  38}
  39
  40static void agilent_82357a_timeout_handler(struct timer_list *t)
  41{
  42	struct agilent_82357a_priv *a_priv = timer_container_of(a_priv, t,
  43								bulk_timer);
  44	struct agilent_82357a_urb_ctx *context = &a_priv->context;
  45
  46	context->timed_out = 1;
  47	complete(&context->complete);
  48}
  49
  50static int agilent_82357a_send_bulk_msg(struct agilent_82357a_priv *a_priv, void *data,
  51					int data_length, int *actual_data_length,
  52					int timeout_msecs)
  53{
  54	struct usb_device *usb_dev;
  55	int retval;
  56	unsigned int out_pipe;
  57	struct agilent_82357a_urb_ctx *context = &a_priv->context;
  58
  59	*actual_data_length = 0;
  60	retval = mutex_lock_interruptible(&a_priv->bulk_alloc_lock);
  61	if (retval)
  62		return retval;
  63	if (!a_priv->bus_interface) {
  64		mutex_unlock(&a_priv->bulk_alloc_lock);
  65		return -ENODEV;
  66	}
  67	if (a_priv->bulk_urb) {
  68		mutex_unlock(&a_priv->bulk_alloc_lock);
  69		return -EAGAIN;
  70	}
  71	a_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
  72	if (!a_priv->bulk_urb) {
  73		mutex_unlock(&a_priv->bulk_alloc_lock);
  74		return -ENOMEM;
  75	}
  76	usb_dev = interface_to_usbdev(a_priv->bus_interface);
  77	out_pipe = usb_sndbulkpipe(usb_dev, a_priv->bulk_out_endpoint);
  78	init_completion(&context->complete);
  79	context->timed_out = 0;
  80	usb_fill_bulk_urb(a_priv->bulk_urb, usb_dev, out_pipe, data, data_length,
  81			  &agilent_82357a_bulk_complete, context);
  82
  83	if (timeout_msecs)
  84		mod_timer(&a_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs));
  85
  86	retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL);
  87	if (retval) {
  88		dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n", retval);
  89		mutex_unlock(&a_priv->bulk_alloc_lock);
  90		goto cleanup;
  91	}
  92	mutex_unlock(&a_priv->bulk_alloc_lock);
  93	if (wait_for_completion_interruptible(&context->complete)) {
  94		retval = -ERESTARTSYS;
  95		goto cleanup;
  96	}
  97	if (context->timed_out)	{
  98		retval = -ETIMEDOUT;
  99	} else {
 100		retval = a_priv->bulk_urb->status;
 101		*actual_data_length = a_priv->bulk_urb->actual_length;
 102	}
 103cleanup:
 104	if (timeout_msecs) {
 105		if (timer_pending(&a_priv->bulk_timer))
 106			timer_delete_sync(&a_priv->bulk_timer);
 107	}
 108	mutex_lock(&a_priv->bulk_alloc_lock);
 109	if (a_priv->bulk_urb) {
 110		usb_kill_urb(a_priv->bulk_urb);
 111		usb_free_urb(a_priv->bulk_urb);
 112		a_priv->bulk_urb = NULL;
 113	}
 114	mutex_unlock(&a_priv->bulk_alloc_lock);
 115	return retval;
 116}
 117
 118static int agilent_82357a_receive_bulk_msg(struct agilent_82357a_priv *a_priv, void *data,
 119					   int data_length, int *actual_data_length,
 120					   int timeout_msecs)
 121{
 122	struct usb_device *usb_dev;
 123	int retval;
 124	unsigned int in_pipe;
 125	struct agilent_82357a_urb_ctx *context = &a_priv->context;
 126
 127	*actual_data_length = 0;
 128	retval = mutex_lock_interruptible(&a_priv->bulk_alloc_lock);
 129	if (retval)
 130		return retval;
 131	if (!a_priv->bus_interface) {
 132		mutex_unlock(&a_priv->bulk_alloc_lock);
 133		return -ENODEV;
 134	}
 135	if (a_priv->bulk_urb) {
 136		mutex_unlock(&a_priv->bulk_alloc_lock);
 137		return -EAGAIN;
 138	}
 139	a_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
 140	if (!a_priv->bulk_urb) {
 141		mutex_unlock(&a_priv->bulk_alloc_lock);
 142		return -ENOMEM;
 143	}
 144	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 145	in_pipe = usb_rcvbulkpipe(usb_dev, AGILENT_82357_BULK_IN_ENDPOINT);
 146	init_completion(&context->complete);
 147	context->timed_out = 0;
 148	usb_fill_bulk_urb(a_priv->bulk_urb, usb_dev, in_pipe, data, data_length,
 149			  &agilent_82357a_bulk_complete, context);
 150
 151	if (timeout_msecs)
 152		mod_timer(&a_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs));
 153
 154	retval = usb_submit_urb(a_priv->bulk_urb, GFP_KERNEL);
 155	if (retval) {
 156		dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval);
 157		mutex_unlock(&a_priv->bulk_alloc_lock);
 158		goto cleanup;
 159	}
 160	mutex_unlock(&a_priv->bulk_alloc_lock);
 161	if (wait_for_completion_interruptible(&context->complete)) {
 162		retval = -ERESTARTSYS;
 163		goto cleanup;
 164	}
 165	if (context->timed_out)	{
 166		retval = -ETIMEDOUT;
 167		goto cleanup;
 168	}
 169	retval = a_priv->bulk_urb->status;
 170	*actual_data_length = a_priv->bulk_urb->actual_length;
 171cleanup:
 172	if (timeout_msecs)
 173		timer_delete_sync(&a_priv->bulk_timer);
 174
 175	mutex_lock(&a_priv->bulk_alloc_lock);
 176	if (a_priv->bulk_urb) {
 177		usb_kill_urb(a_priv->bulk_urb);
 178		usb_free_urb(a_priv->bulk_urb);
 179		a_priv->bulk_urb = NULL;
 180	}
 181	mutex_unlock(&a_priv->bulk_alloc_lock);
 182	return retval;
 183}
 184
 185static int agilent_82357a_receive_control_msg(struct agilent_82357a_priv *a_priv, __u8 request,
 186					      __u8 requesttype, __u16 value,  __u16 index,
 187					      void *data, __u16 size, int timeout_msecs)
 188{
 189	struct usb_device *usb_dev;
 190	int retval;
 191	unsigned int in_pipe;
 192
 193	retval = mutex_lock_interruptible(&a_priv->control_alloc_lock);
 194	if (retval)
 195		return retval;
 196	if (!a_priv->bus_interface) {
 197		mutex_unlock(&a_priv->control_alloc_lock);
 198		return -ENODEV;
 199	}
 200	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 201	in_pipe = usb_rcvctrlpipe(usb_dev, AGILENT_82357_CONTROL_ENDPOINT);
 202	retval = usb_control_msg(usb_dev, in_pipe, request, requesttype, value, index, data,
 203				 size, timeout_msecs);
 204	mutex_unlock(&a_priv->control_alloc_lock);
 205	return retval;
 206}
 207
 208static void agilent_82357a_dump_raw_block(const u8 *raw_data, int length)
 209{
 210	print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true);
 211}
 212
 213static int agilent_82357a_write_registers(struct agilent_82357a_priv *a_priv,
 214					  const struct agilent_82357a_register_pairlet *writes,
 215					  int num_writes)
 216{
 217	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
 218	int retval;
 219	u8 *out_data, *in_data;
 220	int out_data_length, in_data_length;
 221	int bytes_written, bytes_read;
 222	int i = 0;
 223	int j;
 224	static const int bytes_per_write = 2;
 225	static const int header_length = 2;
 226	static const int max_writes = 31;
 227
 228	if (num_writes > max_writes) {
 229		dev_err(&usb_dev->dev, "bug! num_writes=%i too large\n", num_writes);
 230		return -EIO;
 231	}
 232	out_data_length = num_writes * bytes_per_write + header_length;
 233	out_data = kmalloc(out_data_length, GFP_KERNEL);
 234	if (!out_data)
 235		return -ENOMEM;
 236
 237	out_data[i++] = DATA_PIPE_CMD_WR_REGS;
 238	out_data[i++] = num_writes;
 239	for (j = 0; j < num_writes; j++)	{
 240		out_data[i++] = writes[j].address;
 241		out_data[i++] = writes[j].value;
 242	}
 243
 244	retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
 245	if (retval) {
 246		kfree(out_data);
 247		return retval;
 248	}
 249	retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000);
 250	kfree(out_data);
 251	if (retval) {
 252		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
 253			retval, bytes_written, i);
 254		mutex_unlock(&a_priv->bulk_transfer_lock);
 255		return retval;
 256	}
 257	in_data_length = 0x20;
 258	in_data = kmalloc(in_data_length, GFP_KERNEL);
 259	if (!in_data) {
 260		mutex_unlock(&a_priv->bulk_transfer_lock);
 261		return -ENOMEM;
 262	}
 263	retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length,
 264						 &bytes_read, 1000);
 265	mutex_unlock(&a_priv->bulk_transfer_lock);
 266
 267	if (retval) {
 268		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
 269			retval, bytes_read);
 270		agilent_82357a_dump_raw_block(in_data, bytes_read);
 271		kfree(in_data);
 272		return -EIO;
 273	}
 274	if (in_data[0] != (0xff & ~DATA_PIPE_CMD_WR_REGS)) {
 275		dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_WR_REGS\n", in_data[0]);
 276		return -EIO;
 277	}
 278	if (in_data[1])	{
 279		dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_WR_REGS response\n",
 280			in_data[1]);
 281		return -EIO;
 282	}
 283	kfree(in_data);
 284	return 0;
 285}
 286
 287static int agilent_82357a_read_registers(struct agilent_82357a_priv *a_priv,
 288					 struct agilent_82357a_register_pairlet *reads,
 289					 int num_reads, int blocking)
 290{
 291	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
 292	int retval;
 293	u8 *out_data, *in_data;
 294	int out_data_length, in_data_length;
 295	int bytes_written, bytes_read;
 296	int i = 0;
 297	int j;
 298	static const int header_length = 2;
 299	static const int max_reads = 62;
 300
 301	if (num_reads > max_reads) {
 302		dev_err(&usb_dev->dev, "bug! num_reads=%i too large\n", num_reads);
 303		return -EIO;
 304	}
 305	out_data_length = num_reads + header_length;
 306	out_data = kmalloc(out_data_length, GFP_KERNEL);
 307	if (!out_data)
 308		return -ENOMEM;
 309
 310	out_data[i++] = DATA_PIPE_CMD_RD_REGS;
 311	out_data[i++] = num_reads;
 312	for (j = 0; j < num_reads; j++)
 313		out_data[i++] = reads[j].address;
 314
 315	if (blocking) {
 316		retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
 317		if (retval) {
 318			kfree(out_data);
 319			return retval;
 320		}
 321	} else {
 322		retval = mutex_trylock(&a_priv->bulk_transfer_lock);
 323		if (retval == 0) {
 324			kfree(out_data);
 325			return -EAGAIN;
 326		}
 327	}
 328	retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, 1000);
 329	kfree(out_data);
 330	if (retval) {
 331		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
 332			retval, bytes_written, i);
 333		mutex_unlock(&a_priv->bulk_transfer_lock);
 334		return retval;
 335	}
 336	in_data_length = 0x20;
 337	in_data = kmalloc(in_data_length, GFP_KERNEL);
 338	if (!in_data) {
 339		mutex_unlock(&a_priv->bulk_transfer_lock);
 340		return -ENOMEM;
 341	}
 342	retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length,
 343						 &bytes_read, 10000);
 344	mutex_unlock(&a_priv->bulk_transfer_lock);
 345
 346	if (retval) {
 347		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
 348			retval, bytes_read);
 349		agilent_82357a_dump_raw_block(in_data, bytes_read);
 350		kfree(in_data);
 351		return -EIO;
 352	}
 353	i = 0;
 354	if (in_data[i++] != (0xff & ~DATA_PIPE_CMD_RD_REGS)) {
 355		dev_err(&usb_dev->dev, "bulk command=0x%x != ~DATA_PIPE_CMD_RD_REGS\n",	in_data[0]);
 356		return -EIO;
 357	}
 358	if (in_data[i++]) {
 359		dev_err(&usb_dev->dev, "nonzero error code 0x%x in DATA_PIPE_CMD_RD_REGS response\n",
 360			in_data[1]);
 361		return -EIO;
 362	}
 363	for (j = 0; j < num_reads; j++)
 364		reads[j].value = in_data[i++];
 365	kfree(in_data);
 366	return 0;
 367}
 368
 369static int agilent_82357a_abort(struct agilent_82357a_priv *a_priv, int flush)
 370{
 371	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
 372	int retval = 0;
 373	int receive_control_retval;
 374	u16 wIndex = 0;
 375	u8 *status_data;
 376	static const unsigned int status_data_len = 2;
 377
 378	status_data = kmalloc(status_data_len, GFP_KERNEL);
 379	if (!status_data)
 380		return -ENOMEM;
 381
 382	if (flush)
 383		wIndex |= XA_FLUSH;
 384	receive_control_retval = agilent_82357a_receive_control_msg(a_priv,
 385								    agilent_82357a_control_request,
 386								    USB_DIR_IN | USB_TYPE_VENDOR |
 387								    USB_RECIP_DEVICE, XFER_ABORT,
 388								    wIndex, status_data,
 389								    status_data_len, 100);
 390	if (receive_control_retval < 0)	{
 391		dev_err(&usb_dev->dev, "82357a_receive_control_msg() returned %i\n",
 392			receive_control_retval);
 393		retval = -EIO;
 394		goto cleanup;
 395	}
 396	if (status_data[0] != (~XFER_ABORT & 0xff)) {
 397		dev_err(&usb_dev->dev, "major code=0x%x != ~XFER_ABORT\n", status_data[0]);
 398		retval = -EIO;
 399		goto cleanup;
 400	}
 401	switch (status_data[1])	{
 402	case UGP_SUCCESS:
 403		retval = 0;
 404		break;
 405	case UGP_ERR_FLUSHING:
 406		if (flush) {
 407			retval = 0;
 408			break;
 409		}
 410		fallthrough;
 411	case UGP_ERR_FLUSHING_ALREADY:
 412	default:
 413		dev_err(&usb_dev->dev, "abort returned error code=0x%x\n", status_data[1]);
 414		retval = -EIO;
 415		break;
 416	}
 417
 418cleanup:
 419	kfree(status_data);
 420	return retval;
 421}
 422
 423// interface functions
 424int agilent_82357a_command(struct gpib_board *board, u8 *buffer, size_t length,
 425			   size_t *bytes_written);
 426
 427static int agilent_82357a_read(struct gpib_board *board, u8 *buffer, size_t length, int *end,
 428			       size_t *nbytes)
 429{
 430	int retval;
 431	struct agilent_82357a_priv *a_priv = board->private_data;
 432	struct usb_device *usb_dev;
 433	u8 *out_data, *in_data;
 434	int out_data_length, in_data_length;
 435	int bytes_written, bytes_read;
 436	int i = 0;
 437	u8 trailing_flags;
 438	unsigned long start_jiffies = jiffies;
 439	int msec_timeout;
 440
 441	*nbytes = 0;
 442	*end = 0;
 443
 444	if (!a_priv->bus_interface)
 445		return -ENODEV;
 446	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 447	out_data_length = 0x9;
 448	out_data = kmalloc(out_data_length, GFP_KERNEL);
 449	if (!out_data)
 450		return -ENOMEM;
 451	out_data[i++] = DATA_PIPE_CMD_READ;
 452	out_data[i++] = 0;	// primary address when ARF_NO_ADDR is not set
 453	out_data[i++] = 0;	// secondary address when ARF_NO_ADDR is not set
 454	out_data[i] = ARF_NO_ADDRESS | ARF_END_ON_EOI;
 455	if (a_priv->eos_mode & REOS)
 456		out_data[i] |= ARF_END_ON_EOS_CHAR;
 457	++i;
 458	out_data[i++] = length & 0xff;
 459	out_data[i++] = (length >> 8) & 0xff;
 460	out_data[i++] = (length >> 16) & 0xff;
 461	out_data[i++] = (length >> 24) & 0xff;
 462	out_data[i++] = a_priv->eos_char;
 463	msec_timeout = (board->usec_timeout + 999) / 1000;
 464	retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
 465	if (retval) {
 466		kfree(out_data);
 467		return retval;
 468	}
 469	retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &bytes_written, msec_timeout);
 470	kfree(out_data);
 471	if (retval || bytes_written != i) {
 472		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
 473			retval, bytes_written, i);
 474		mutex_unlock(&a_priv->bulk_transfer_lock);
 475		if (retval < 0)
 476			return retval;
 477		return -EIO;
 478	}
 479	in_data_length = length + 1;
 480	in_data = kmalloc(in_data_length, GFP_KERNEL);
 481	if (!in_data) {
 482		mutex_unlock(&a_priv->bulk_transfer_lock);
 483		return -ENOMEM;
 484	}
 485	if (board->usec_timeout != 0)
 486		msec_timeout -= jiffies_to_msecs(jiffies - start_jiffies) - 1;
 487	if (msec_timeout >= 0) {
 488		retval = agilent_82357a_receive_bulk_msg(a_priv, in_data, in_data_length,
 489							 &bytes_read, msec_timeout);
 490	} else {
 491		retval = -ETIMEDOUT;
 492		bytes_read = 0;
 493	}
 494	if (retval == -ETIMEDOUT) {
 495		int extra_bytes_read;
 496		int extra_bytes_retval;
 497
 498		agilent_82357a_abort(a_priv, 1);
 499		extra_bytes_retval = agilent_82357a_receive_bulk_msg(a_priv, in_data + bytes_read,
 500								     in_data_length - bytes_read,
 501								     &extra_bytes_read, 100);
 502		bytes_read += extra_bytes_read;
 503		if (extra_bytes_retval)	{
 504			dev_err(&usb_dev->dev, "extra_bytes_retval=%i, bytes_read=%i\n",
 505				extra_bytes_retval, bytes_read);
 506			agilent_82357a_abort(a_priv, 0);
 507		}
 508	} else if (retval) {
 509		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
 510			retval, bytes_read);
 511		agilent_82357a_abort(a_priv, 0);
 512	}
 513	mutex_unlock(&a_priv->bulk_transfer_lock);
 514	if (bytes_read > length + 1) {
 515		bytes_read = length + 1;
 516		dev_warn(&usb_dev->dev, "bytes_read > length? truncating");
 517	}
 518
 519	if (bytes_read >= 1) {
 520		memcpy(buffer, in_data, bytes_read - 1);
 521		trailing_flags = in_data[bytes_read - 1];
 522		*nbytes = bytes_read - 1;
 523		if (trailing_flags & (ATRF_EOI | ATRF_EOS))
 524			*end = 1;
 525	}
 526	kfree(in_data);
 527
 528	/*
 529	 * Fix for a bug in 9914A that does not return the contents of ADSR
 530	 * when the board is in listener active state and ATN is not asserted.
 531	 * Set ATN here to obtain a valid board level ibsta
 532	 */
 533	agilent_82357a_take_control_internal(board, 0);
 534
 535	// FIXME check trailing flags for error
 536	return retval;
 537}
 538
 539static ssize_t agilent_82357a_generic_write(struct gpib_board *board,
 540					    u8 *buffer, size_t length,
 541					    int send_commands, int send_eoi,
 542					    size_t *bytes_written)
 543{
 544	int retval;
 545	struct agilent_82357a_priv *a_priv = board->private_data;
 546	struct usb_device *usb_dev;
 547	u8 *out_data = NULL;
 548	u8 *status_data = NULL;
 549	int out_data_length;
 550	int raw_bytes_written;
 551	int i = 0, j;
 552	int msec_timeout;
 553	unsigned short bsr, adsr;
 554	struct agilent_82357a_register_pairlet read_reg;
 555
 556	*bytes_written = 0;
 557	if (!a_priv->bus_interface)
 558		return -ENODEV;
 559
 560	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 561	out_data_length = length + 0x8;
 562	out_data = kmalloc(out_data_length, GFP_KERNEL);
 563	if (!out_data)
 564		return -ENOMEM;
 565	out_data[i++] = DATA_PIPE_CMD_WRITE;
 566	out_data[i++] = 0; // primary address when AWF_NO_ADDRESS is not set
 567	out_data[i++] = 0; // secondary address when AWF_NO_ADDRESS is not set
 568	out_data[i] = AWF_NO_ADDRESS | AWF_NO_FAST_TALKER_FIRST_BYTE;
 569	if (send_commands)
 570		out_data[i] |= AWF_ATN | AWF_NO_FAST_TALKER;
 571	if (send_eoi)
 572		out_data[i] |= AWF_SEND_EOI;
 573	++i;
 574	out_data[i++] = length & 0xff;
 575	out_data[i++] = (length >> 8) & 0xff;
 576	out_data[i++] = (length >> 16) & 0xff;
 577	out_data[i++] = (length >> 24) & 0xff;
 578	for (j = 0; j < length; j++)
 579		out_data[i++] = buffer[j];
 580
 581	clear_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags);
 582
 583	msec_timeout = (board->usec_timeout + 999) / 1000;
 584	retval = mutex_lock_interruptible(&a_priv->bulk_transfer_lock);
 585	if (retval) {
 586		kfree(out_data);
 587		return retval;
 588	}
 589	retval = agilent_82357a_send_bulk_msg(a_priv, out_data, i, &raw_bytes_written,
 590					      msec_timeout);
 591	kfree(out_data);
 592	if (retval || raw_bytes_written != i) {
 593		agilent_82357a_abort(a_priv, 0);
 594		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, raw_bytes_written=%i, i=%i\n",
 595			retval, raw_bytes_written, i);
 596		mutex_unlock(&a_priv->bulk_transfer_lock);
 597		if (retval < 0)
 598			return retval;
 599		return -EIO;
 600	}
 601
 602	retval = wait_event_interruptible(board->wait,
 603					  test_bit(AIF_WRITE_COMPLETE_BN,
 604						   &a_priv->interrupt_flags) ||
 605					  test_bit(TIMO_NUM, &board->status));
 606	if (retval) {
 607		dev_dbg(&usb_dev->dev, "wait write complete interrupted\n");
 608		agilent_82357a_abort(a_priv, 0);
 609		mutex_unlock(&a_priv->bulk_transfer_lock);
 610		return -ERESTARTSYS;
 611	}
 612
 613	if (test_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags) == 0) {
 614		dev_dbg(&usb_dev->dev, "write timed out ibs %i, tmo %i\n",
 615			test_bit(TIMO_NUM, &board->status), msec_timeout);
 616
 617		agilent_82357a_abort(a_priv, 0);
 618
 619		mutex_unlock(&a_priv->bulk_transfer_lock);
 620
 621		read_reg.address = BSR;
 622		retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1);
 623		if (retval) {
 624			dev_err(&usb_dev->dev, "read_registers() returned error\n");
 625			return -ETIMEDOUT;
 626		}
 627
 628		bsr = read_reg.value;
 629		dev_dbg(&usb_dev->dev, "write aborted bsr 0x%x\n", bsr);
 630
 631		if (send_commands) {/* check for no listeners */
 632			if ((bsr & BSR_ATN_BIT) && !(bsr & (BSR_NDAC_BIT | BSR_NRFD_BIT))) {
 633				dev_dbg(&usb_dev->dev, "No listener on command\n");
 634				clear_bit(TIMO_NUM, &board->status);
 635				return -ENOTCONN; // no listener on bus
 636			}
 637		} else {
 638			read_reg.address = ADSR;
 639			retval = agilent_82357a_read_registers(a_priv, &read_reg, 1, 1);
 640			if (retval) {
 641				dev_err(&usb_dev->dev, "read_registers() returned error\n");
 642				return -ETIMEDOUT;
 643			}
 644			adsr = read_reg.value;
 645			if ((adsr & HR_TA) && !(bsr & (BSR_NDAC_BIT | BSR_NRFD_BIT))) {
 646				dev_dbg(&usb_dev->dev, "No listener on write\n");
 647				clear_bit(TIMO_NUM, &board->status);
 648				return -ECOMM;
 649			}
 650		}
 651
 652		return -ETIMEDOUT;
 653	}
 654
 655	status_data = kmalloc(STATUS_DATA_LEN, GFP_KERNEL);
 656	if (!status_data) {
 657		mutex_unlock(&a_priv->bulk_transfer_lock);
 658		return -ENOMEM;
 659	}
 660
 661	retval = agilent_82357a_receive_control_msg(a_priv, agilent_82357a_control_request,
 662						    USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 663						    XFER_STATUS, 0, status_data, STATUS_DATA_LEN,
 664						    100);
 665	mutex_unlock(&a_priv->bulk_transfer_lock);
 666	if (retval < 0)	{
 667		dev_err(&usb_dev->dev, "receive_control_msg() returned %i\n", retval);
 668		kfree(status_data);
 669		return -EIO;
 670	}
 671	*bytes_written	= (u32)status_data[2];
 672	*bytes_written |= (u32)status_data[3] << 8;
 673	*bytes_written |= (u32)status_data[4] << 16;
 674	*bytes_written |= (u32)status_data[5] << 24;
 675
 676	kfree(status_data);
 677	return 0;
 678}
 679
 680static int agilent_82357a_write(struct gpib_board *board, u8 *buffer,
 681				size_t length, int send_eoi, size_t *bytes_written)
 682{
 683	return agilent_82357a_generic_write(board, buffer, length, 0, send_eoi, bytes_written);
 684}
 685
 686int agilent_82357a_command(struct gpib_board *board, u8 *buffer, size_t length,
 687			   size_t *bytes_written)
 688{
 689	return agilent_82357a_generic_write(board, buffer, length, 1, 0, bytes_written);
 690}
 691
 692int agilent_82357a_take_control_internal(struct gpib_board *board, int synchronous)
 693{
 694	struct agilent_82357a_priv *a_priv = board->private_data;
 695	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
 696	struct agilent_82357a_register_pairlet write;
 697	int retval;
 698
 699	write.address = AUXCR;
 700	if (synchronous)
 701		write.value = AUX_TCS;
 702	else
 703		write.value = AUX_TCA;
 704	retval = agilent_82357a_write_registers(a_priv, &write, 1);
 705	if (retval)
 706		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 707
 708	return retval;
 709}
 710
 711static int agilent_82357a_take_control(struct gpib_board *board, int synchronous)
 712{
 713	struct agilent_82357a_priv *a_priv = board->private_data;
 714	const int timeout = 10;
 715	int i;
 716
 717	if (!a_priv->bus_interface)
 718		return -ENODEV;
 719
 720/*
 721 * It looks like the 9914 does not handle tcs properly.
 722 * See comment above tms9914_take_control_workaround() in
 723 * drivers/gpib/tms9914/tms9914_aux.c
 724 */
 725	if (synchronous)
 726		return -ETIMEDOUT;
 727
 728	agilent_82357a_take_control_internal(board, synchronous);
 729	// busy wait until ATN is asserted
 730	for (i = 0; i < timeout; ++i) {
 731		agilent_82357a_update_status(board, 0);
 732		if (test_bit(ATN_NUM, &board->status))
 733			break;
 734		udelay(1);
 735	}
 736	if (i == timeout)
 737		return -ETIMEDOUT;
 738	return 0;
 739}
 740
 741static int agilent_82357a_go_to_standby(struct gpib_board *board)
 742{
 743	struct agilent_82357a_priv *a_priv = board->private_data;
 744	struct usb_device *usb_dev;
 745	struct agilent_82357a_register_pairlet write;
 746	int retval;
 747
 748	if (!a_priv->bus_interface)
 749		return -ENODEV;
 750
 751	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 752	write.address = AUXCR;
 753	write.value = AUX_GTS;
 754	retval = agilent_82357a_write_registers(a_priv, &write, 1);
 755	if (retval)
 756		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 757	return 0;
 758}
 759
 760static int agilent_82357a_request_system_control(struct gpib_board *board, int request_control)
 761{
 762	struct agilent_82357a_priv *a_priv = board->private_data;
 763	struct usb_device *usb_dev;
 764	struct agilent_82357a_register_pairlet writes[2];
 765	int retval;
 766	int i = 0;
 767
 768	if (!a_priv->bus_interface)
 769		return -ENODEV;
 770
 771	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 772	/* 82357B needs bit to be set in 9914 AUXCR register */
 773	writes[i].address = AUXCR;
 774	if (request_control) {
 775		writes[i].value = AUX_RQC;
 776		a_priv->hw_control_bits |= SYSTEM_CONTROLLER;
 777	} else {
 778		return -EINVAL;
 779	}
 780	++i;
 781	writes[i].address = HW_CONTROL;
 782	writes[i].value = a_priv->hw_control_bits;
 783	++i;
 784	retval = agilent_82357a_write_registers(a_priv, writes, i);
 785	if (retval)
 786		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 787	return retval;
 788}
 789
 790static void agilent_82357a_interface_clear(struct gpib_board *board, int assert)
 791{
 792	struct agilent_82357a_priv *a_priv = board->private_data;
 793	struct usb_device *usb_dev;
 794	struct agilent_82357a_register_pairlet write;
 795	int retval;
 796
 797	if (!a_priv->bus_interface)
 798		return; // -ENODEV;
 799
 800	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 801	write.address = AUXCR;
 802	write.value = AUX_SIC;
 803	if (assert) {
 804		write.value |= AUX_CS;
 805		a_priv->is_cic = 1;
 806	}
 807	retval = agilent_82357a_write_registers(a_priv, &write, 1);
 808	if (retval)
 809		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 810}
 811
 812static void agilent_82357a_remote_enable(struct gpib_board *board, int enable)
 813{
 814	struct agilent_82357a_priv *a_priv = board->private_data;
 815	struct usb_device *usb_dev;
 816	struct agilent_82357a_register_pairlet write;
 817	int retval;
 818
 819	if (!a_priv->bus_interface)
 820		return; //-ENODEV;
 821
 822	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 823	write.address = AUXCR;
 824	write.value = AUX_SRE;
 825	if (enable)
 826		write.value |= AUX_CS;
 827	retval = agilent_82357a_write_registers(a_priv, &write, 1);
 828	if (retval)
 829		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 830	a_priv->ren_state = enable;
 831	return;// 0;
 832}
 833
 834static int agilent_82357a_enable_eos(struct gpib_board *board, u8 eos_byte,
 835				     int compare_8_bits)
 836{
 837	struct agilent_82357a_priv *a_priv = board->private_data;
 838
 839	if (!a_priv->bus_interface)
 840		return -ENODEV;
 841	if (compare_8_bits == 0)
 842		return -EOPNOTSUPP;
 843
 844	a_priv->eos_char = eos_byte;
 845	a_priv->eos_mode = REOS | BIN;
 846	return 0;
 847}
 848
 849static void agilent_82357a_disable_eos(struct gpib_board *board)
 850{
 851	struct agilent_82357a_priv *a_priv = board->private_data;
 852
 853	a_priv->eos_mode &= ~REOS;
 854}
 855
 856static unsigned int agilent_82357a_update_status(struct gpib_board *board,
 857						 unsigned int clear_mask)
 858{
 859	struct agilent_82357a_priv *a_priv = board->private_data;
 860	struct usb_device *usb_dev;
 861	struct agilent_82357a_register_pairlet address_status, bus_status;
 862	int retval;
 863
 864	if (!a_priv->bus_interface)
 865		return -ENODEV;
 866	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 867	board->status &= ~clear_mask;
 868	if (a_priv->is_cic)
 869		set_bit(CIC_NUM, &board->status);
 870	else
 871		clear_bit(CIC_NUM, &board->status);
 872	address_status.address = ADSR;
 873	retval = agilent_82357a_read_registers(a_priv, &address_status, 1, 0);
 874	if (retval) {
 875		if (retval != -EAGAIN)
 876			dev_err(&usb_dev->dev, "read_registers() returned error\n");
 877		return board->status;
 878	}
 879	// check for remote/local
 880	if (address_status.value & HR_REM)
 881		set_bit(REM_NUM, &board->status);
 882	else
 883		clear_bit(REM_NUM, &board->status);
 884	// check for lockout
 885	if (address_status.value & HR_LLO)
 886		set_bit(LOK_NUM, &board->status);
 887	else
 888		clear_bit(LOK_NUM, &board->status);
 889	// check for ATN
 890	if (address_status.value & HR_ATN)
 891		set_bit(ATN_NUM, &board->status);
 892	else
 893		clear_bit(ATN_NUM, &board->status);
 894	// check for talker/listener addressed
 895	if (address_status.value & HR_TA)
 896		set_bit(TACS_NUM, &board->status);
 897	else
 898		clear_bit(TACS_NUM, &board->status);
 899	if (address_status.value & HR_LA)
 900		set_bit(LACS_NUM, &board->status);
 901	else
 902		clear_bit(LACS_NUM, &board->status);
 903
 904	bus_status.address = BSR;
 905	retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0);
 906	if (retval) {
 907		if (retval != -EAGAIN)
 908			dev_err(&usb_dev->dev, "read_registers() returned error\n");
 909		return board->status;
 910	}
 911	if (bus_status.value & BSR_SRQ_BIT)
 912		set_bit(SRQI_NUM, &board->status);
 913	else
 914		clear_bit(SRQI_NUM, &board->status);
 915
 916	return board->status;
 917}
 918
 919static int agilent_82357a_primary_address(struct gpib_board *board, unsigned int address)
 920{
 921	struct agilent_82357a_priv *a_priv = board->private_data;
 922	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
 923	struct agilent_82357a_register_pairlet write;
 924	int retval;
 925
 926	if (!a_priv->bus_interface)
 927		return -ENODEV;
 928	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 929	// put primary address in address0
 930	write.address = ADR;
 931	write.value = address & ADDRESS_MASK;
 932	retval = agilent_82357a_write_registers(a_priv, &write, 1);
 933	if (retval) {
 934		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 935		return retval;
 936	}
 937	return retval;
 938}
 939
 940static int agilent_82357a_secondary_address(struct gpib_board *board,
 941					    unsigned int address, int enable)
 942{
 943	if (enable)
 944		return	-EOPNOTSUPP;
 945	return 0;
 946}
 947
 948static int agilent_82357a_parallel_poll(struct gpib_board *board, u8 *result)
 949{
 950	struct agilent_82357a_priv *a_priv = board->private_data;
 951	struct usb_device *usb_dev;
 952	struct agilent_82357a_register_pairlet writes[2];
 953	struct agilent_82357a_register_pairlet read;
 954	int retval;
 955
 956	if (!a_priv->bus_interface)
 957		return -ENODEV;
 958	usb_dev = interface_to_usbdev(a_priv->bus_interface);
 959	// execute parallel poll
 960	writes[0].address = AUXCR;
 961	writes[0].value = AUX_CS | AUX_RPP;
 962	writes[1].address = HW_CONTROL;
 963	writes[1].value = a_priv->hw_control_bits & ~NOT_PARALLEL_POLL;
 964	retval = agilent_82357a_write_registers(a_priv, writes, 2);
 965	if (retval) {
 966		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 967		return retval;
 968	}
 969	udelay(2);	// silly, since usb write will take way longer
 970	read.address = CPTR;
 971	retval = agilent_82357a_read_registers(a_priv, &read, 1, 1);
 972	if (retval) {
 973		dev_err(&usb_dev->dev, "read_registers() returned error\n");
 974		return retval;
 975	}
 976	*result = read.value;
 977	// clear parallel poll state
 978	writes[0].address = HW_CONTROL;
 979	writes[0].value = a_priv->hw_control_bits | NOT_PARALLEL_POLL;
 980	writes[1].address = AUXCR;
 981	writes[1].value = AUX_RPP;
 982	retval = agilent_82357a_write_registers(a_priv, writes, 2);
 983	if (retval) {
 984		dev_err(&usb_dev->dev, "write_registers() returned error\n");
 985		return retval;
 986	}
 987	return 0;
 988}
 989
 990static void agilent_82357a_parallel_poll_configure(struct gpib_board *board, u8 config)
 991{
 992	// board can only be system controller
 993	return;// 0;
 994}
 995
 996static void agilent_82357a_parallel_poll_response(struct gpib_board *board, int ist)
 997{
 998	// board can only be system controller
 999	return;// 0;
1000}
1001
1002static void agilent_82357a_serial_poll_response(struct gpib_board *board, u8 status)
1003{
1004	// board can only be system controller
1005	return;// 0;
1006}
1007
1008static u8 agilent_82357a_serial_poll_status(struct gpib_board *board)
1009{
1010	// board can only be system controller
1011	return 0;
1012}
1013
1014static void agilent_82357a_return_to_local(struct gpib_board *board)
1015{
1016	// board can only be system controller
1017	return;// 0;
1018}
1019
1020static int agilent_82357a_line_status(const struct gpib_board *board)
1021{
1022	struct agilent_82357a_priv *a_priv = board->private_data;
1023	struct usb_device *usb_dev;
1024	struct agilent_82357a_register_pairlet bus_status;
1025	int retval;
1026	int status = VALID_ALL;
1027
1028	if (!a_priv->bus_interface)
1029		return -ENODEV;
1030	usb_dev = interface_to_usbdev(a_priv->bus_interface);
1031	bus_status.address = BSR;
1032	retval = agilent_82357a_read_registers(a_priv, &bus_status, 1, 0);
1033	if (retval) {
1034		if (retval != -EAGAIN)
1035			dev_err(&usb_dev->dev, "read_registers() returned error\n");
1036		return retval;
1037	}
1038	if (bus_status.value & BSR_REN_BIT)
1039		status |= BUS_REN;
1040	if (bus_status.value & BSR_IFC_BIT)
1041		status |= BUS_IFC;
1042	if (bus_status.value & BSR_SRQ_BIT)
1043		status |= BUS_SRQ;
1044	if (bus_status.value & BSR_EOI_BIT)
1045		status |= BUS_EOI;
1046	if (bus_status.value & BSR_NRFD_BIT)
1047		status |= BUS_NRFD;
1048	if (bus_status.value & BSR_NDAC_BIT)
1049		status |= BUS_NDAC;
1050	if (bus_status.value & BSR_DAV_BIT)
1051		status |= BUS_DAV;
1052	if (bus_status.value & BSR_ATN_BIT)
1053		status |= BUS_ATN;
1054	return status;
1055}
1056
1057static unsigned short nanosec_to_fast_talker_bits(unsigned int *nanosec)
1058{
1059	static const int nanosec_per_bit = 21;
1060	static const int max_value = 0x72;
1061	static const int min_value = 0x11;
1062	unsigned short bits;
1063
1064	bits = (*nanosec + nanosec_per_bit / 2) / nanosec_per_bit;
1065	if (bits < min_value)
1066		bits = min_value;
1067	if (bits > max_value)
1068		bits = max_value;
1069	*nanosec = bits * nanosec_per_bit;
1070	return bits;
1071}
1072
1073static int agilent_82357a_t1_delay(struct gpib_board *board, unsigned int nanosec)
1074{
1075	struct agilent_82357a_priv *a_priv = board->private_data;
1076	struct usb_device *usb_dev;
1077	struct agilent_82357a_register_pairlet write;
1078	int retval;
1079
1080	if (!a_priv->bus_interface)
1081		return -ENODEV;
1082	usb_dev = interface_to_usbdev(a_priv->bus_interface);
1083	write.address = FAST_TALKER_T1;
1084	write.value = nanosec_to_fast_talker_bits(&nanosec);
1085	retval = agilent_82357a_write_registers(a_priv, &write, 1);
1086	if (retval)
1087		dev_err(&usb_dev->dev, "write_registers() returned error\n");
1088	return nanosec;
1089}
1090
1091static void agilent_82357a_interrupt_complete(struct urb *urb)
1092{
1093	struct gpib_board *board = urb->context;
1094	struct agilent_82357a_priv *a_priv = board->private_data;
1095	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
1096	int retval;
1097	u8 *transfer_buffer = urb->transfer_buffer;
1098	unsigned long interrupt_flags;
1099
1100	switch (urb->status) {
1101		/* success */
1102	case 0:
1103		break;
1104		/* unlinked, don't resubmit */
1105	case -ECONNRESET:
1106	case -ENOENT:
1107	case -ESHUTDOWN:
1108		return;
1109	default: /* other error, resubmit */
1110		retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC);
1111		if (retval)
1112			dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n");
1113		return;
1114	}
1115
1116	interrupt_flags = transfer_buffer[0];
1117	if (test_bit(AIF_READ_COMPLETE_BN, &interrupt_flags))
1118		set_bit(AIF_READ_COMPLETE_BN, &a_priv->interrupt_flags);
1119	if (test_bit(AIF_WRITE_COMPLETE_BN, &interrupt_flags))
1120		set_bit(AIF_WRITE_COMPLETE_BN, &a_priv->interrupt_flags);
1121	if (test_bit(AIF_SRQ_BN, &interrupt_flags))
1122		set_bit(SRQI_NUM, &board->status);
1123
1124	wake_up_interruptible(&board->wait);
1125
1126	retval = usb_submit_urb(a_priv->interrupt_urb, GFP_ATOMIC);
1127	if (retval)
1128		dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n");
1129}
1130
1131static int agilent_82357a_setup_urbs(struct gpib_board *board)
1132{
1133	struct agilent_82357a_priv *a_priv = board->private_data;
1134	struct usb_device *usb_dev;
1135	int int_pipe;
1136	int retval;
1137
1138	retval = mutex_lock_interruptible(&a_priv->interrupt_alloc_lock);
1139	if (retval)
1140		return retval;
1141	if (!a_priv->bus_interface) {
1142		retval = -ENODEV;
1143		goto setup_exit;
1144	}
1145
1146	a_priv->interrupt_buffer = kmalloc(INTERRUPT_BUF_LEN, GFP_KERNEL);
1147	if (!a_priv->interrupt_buffer) {
1148		retval = -ENOMEM;
1149		goto setup_exit;
1150	}
1151	a_priv->interrupt_urb = usb_alloc_urb(0, GFP_KERNEL);
1152	if (!a_priv->interrupt_urb) {
1153		retval = -ENOMEM;
1154		goto setup_exit;
1155	}
1156	usb_dev = interface_to_usbdev(a_priv->bus_interface);
1157	int_pipe = usb_rcvintpipe(usb_dev, a_priv->interrupt_in_endpoint);
1158	usb_fill_int_urb(a_priv->interrupt_urb, usb_dev, int_pipe, a_priv->interrupt_buffer,
1159			 INTERRUPT_BUF_LEN, &agilent_82357a_interrupt_complete, board, 1);
1160	retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL);
1161	if (retval) {
1162		usb_free_urb(a_priv->interrupt_urb);
1163		a_priv->interrupt_urb = NULL;
1164		dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval);
1165		goto setup_exit;
1166	}
1167	mutex_unlock(&a_priv->interrupt_alloc_lock);
1168	return 0;
1169
1170setup_exit:
1171	kfree(a_priv->interrupt_buffer);
1172	mutex_unlock(&a_priv->interrupt_alloc_lock);
1173	return retval;
1174}
1175
1176static void agilent_82357a_cleanup_urbs(struct agilent_82357a_priv *a_priv)
1177{
1178	if (a_priv && a_priv->bus_interface) {
1179		if (a_priv->interrupt_urb)
1180			usb_kill_urb(a_priv->interrupt_urb);
1181		if (a_priv->bulk_urb)
1182			usb_kill_urb(a_priv->bulk_urb);
1183	}
1184};
1185
1186static void agilent_82357a_release_urbs(struct agilent_82357a_priv *a_priv)
1187{
1188	if (a_priv) {
1189		usb_free_urb(a_priv->interrupt_urb);
1190		a_priv->interrupt_urb = NULL;
1191		kfree(a_priv->interrupt_buffer);
1192	}
1193}
1194
1195static int agilent_82357a_allocate_private(struct gpib_board *board)
1196{
1197	struct agilent_82357a_priv *a_priv;
1198
1199	board->private_data = kzalloc(sizeof(struct agilent_82357a_priv), GFP_KERNEL);
1200	if (!board->private_data)
1201		return -ENOMEM;
1202	a_priv = board->private_data;
1203	mutex_init(&a_priv->bulk_transfer_lock);
1204	mutex_init(&a_priv->bulk_alloc_lock);
1205	mutex_init(&a_priv->control_alloc_lock);
1206	mutex_init(&a_priv->interrupt_alloc_lock);
1207	return 0;
1208}
1209
1210static void agilent_82357a_free_private(struct gpib_board *board)
1211{
1212	kfree(board->private_data);
1213	board->private_data = NULL;
1214}
1215
1216#define INIT_NUM_REG_WRITES 18
1217static int agilent_82357a_init(struct gpib_board *board)
1218{
1219	struct agilent_82357a_priv *a_priv = board->private_data;
1220	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
1221	struct agilent_82357a_register_pairlet hw_control;
1222	struct agilent_82357a_register_pairlet writes[INIT_NUM_REG_WRITES];
1223	int retval;
1224	unsigned int nanosec;
1225
1226	writes[0].address = LED_CONTROL;
1227	writes[0].value = FAIL_LED_ON;
1228	writes[1].address = RESET_TO_POWERUP;
1229	writes[1].value = RESET_SPACEBALL;
1230	retval = agilent_82357a_write_registers(a_priv, writes, 2);
1231	if (retval) {
1232		dev_err(&usb_dev->dev, "write_registers() returned error\n");
1233		return -EIO;
1234	}
1235	set_current_state(TASK_INTERRUPTIBLE);
1236	if (schedule_timeout(usec_to_jiffies(2000)))
1237		return -ERESTARTSYS;
1238	writes[0].address = AUXCR;
1239	writes[0].value = AUX_NBAF;
1240	writes[1].address = AUXCR;
1241	writes[1].value = AUX_HLDE;
1242	writes[2].address = AUXCR;
1243	writes[2].value = AUX_TON;
1244	writes[3].address = AUXCR;
1245	writes[3].value = AUX_LON;
1246	writes[4].address = AUXCR;
1247	writes[4].value = AUX_RSV2;
1248	writes[5].address = AUXCR;
1249	writes[5].value = AUX_INVAL;
1250	writes[6].address = AUXCR;
1251	writes[6].value = AUX_RPP;
1252	writes[7].address = AUXCR;
1253	writes[7].value = AUX_STDL;
1254	writes[8].address = AUXCR;
1255	writes[8].value = AUX_VSTDL;
1256	writes[9].address = FAST_TALKER_T1;
1257	nanosec = board->t1_nano_sec;
1258	writes[9].value = nanosec_to_fast_talker_bits(&nanosec);
1259	board->t1_nano_sec = nanosec;
1260	writes[10].address = ADR;
1261	writes[10].value = board->pad & ADDRESS_MASK;
1262	writes[11].address = PPR;
1263	writes[11].value = 0;
1264	writes[12].address = SPMR;
1265	writes[12].value = 0;
1266	writes[13].address = PROTOCOL_CONTROL;
1267	writes[13].value = WRITE_COMPLETE_INTERRUPT_EN;
1268	writes[14].address = IMR0;
1269	writes[14].value = HR_BOIE | HR_BIIE;
1270	writes[15].address = IMR1;
1271	writes[15].value = HR_SRQIE;
1272	// turn off reset state
1273	writes[16].address = AUXCR;
1274	writes[16].value = AUX_CHIP_RESET;
1275	writes[17].address = LED_CONTROL;
1276	writes[17].value = FIRMWARE_LED_CONTROL;
1277	retval = agilent_82357a_write_registers(a_priv, writes, INIT_NUM_REG_WRITES);
1278	if (retval) {
1279		dev_err(&usb_dev->dev, "write_registers() returned error\n");
1280		return -EIO;
1281	}
1282	hw_control.address = HW_CONTROL;
1283	retval = agilent_82357a_read_registers(a_priv, &hw_control, 1, 1);
1284	if (retval) {
1285		dev_err(&usb_dev->dev, "read_registers() returned error\n");
1286		return -EIO;
1287	}
1288	a_priv->hw_control_bits = (hw_control.value & ~0x7) | NOT_TI_RESET | NOT_PARALLEL_POLL;
1289
1290	return 0;
1291}
1292
1293static inline int agilent_82357a_device_match(struct usb_interface *interface,
1294					      const struct gpib_board_config *config)
1295{
1296	struct usb_device * const usbdev = interface_to_usbdev(interface);
1297
1298	if (gpib_match_device_path(&interface->dev, config->device_path) == 0)
1299		return 0;
1300	if (config->serial_number &&
1301	    strcmp(usbdev->serial, config->serial_number) != 0)
1302		return 0;
1303
1304	return 1;
1305}
1306
1307static int agilent_82357a_attach(struct gpib_board *board, const struct gpib_board_config *config)
1308{
1309	int retval;
1310	int i;
1311	unsigned int product_id;
1312	struct agilent_82357a_priv *a_priv;
1313	struct usb_device *usb_dev;
1314
1315	if (mutex_lock_interruptible(&agilent_82357a_hotplug_lock))
1316		return -ERESTARTSYS;
1317
1318	retval = agilent_82357a_allocate_private(board);
1319	if (retval < 0) {
1320		mutex_unlock(&agilent_82357a_hotplug_lock);
1321		return retval;
1322	}
1323	a_priv = board->private_data;
1324	for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1325		if (agilent_82357a_driver_interfaces[i] &&
1326		    !usb_get_intfdata(agilent_82357a_driver_interfaces[i]) &&
1327		    agilent_82357a_device_match(agilent_82357a_driver_interfaces[i], config)) {
1328			a_priv->bus_interface = agilent_82357a_driver_interfaces[i];
1329			usb_set_intfdata(agilent_82357a_driver_interfaces[i], board);
1330			usb_dev = interface_to_usbdev(a_priv->bus_interface);
1331			break;
1332		}
1333	}
1334	if (i == MAX_NUM_82357A_INTERFACES) {
1335		dev_err(board->gpib_dev,
1336			"No supported adapters found, have you loaded its firmware?\n");
1337		retval = -ENODEV;
1338		goto attach_fail;
1339	}
1340	product_id = le16_to_cpu(interface_to_usbdev(a_priv->bus_interface)->descriptor.idProduct);
1341	switch (product_id) {
1342	case USB_DEVICE_ID_AGILENT_82357A:
1343		a_priv->bulk_out_endpoint = AGILENT_82357A_BULK_OUT_ENDPOINT;
1344		a_priv->interrupt_in_endpoint = AGILENT_82357A_INTERRUPT_IN_ENDPOINT;
1345		break;
1346	case USB_DEVICE_ID_AGILENT_82357B:
1347		a_priv->bulk_out_endpoint = AGILENT_82357B_BULK_OUT_ENDPOINT;
1348		a_priv->interrupt_in_endpoint = AGILENT_82357B_INTERRUPT_IN_ENDPOINT;
1349		break;
1350	default:
1351		dev_err(&usb_dev->dev, "bug, unhandled product_id in switch?\n");
1352		retval = -EIO;
1353		goto attach_fail;
1354	}
1355
1356	retval = agilent_82357a_setup_urbs(board);
1357	if (retval < 0)
1358		goto attach_fail;
1359
1360	timer_setup(&a_priv->bulk_timer, agilent_82357a_timeout_handler, 0);
1361
1362	board->t1_nano_sec = 800;
1363
1364	retval = agilent_82357a_init(board);
1365
1366	if (retval < 0)	{
1367		agilent_82357a_cleanup_urbs(a_priv);
1368		agilent_82357a_release_urbs(a_priv);
1369		goto attach_fail;
1370	}
1371
1372	dev_info(&usb_dev->dev, "bus %d dev num %d attached to gpib%d, interface %i\n",
1373		 usb_dev->bus->busnum, usb_dev->devnum, board->minor, i);
1374	mutex_unlock(&agilent_82357a_hotplug_lock);
1375	return retval;
1376
1377attach_fail:
1378	agilent_82357a_free_private(board);
1379	mutex_unlock(&agilent_82357a_hotplug_lock);
1380	return retval;
1381}
1382
1383static int agilent_82357a_go_idle(struct gpib_board *board)
1384{
1385	struct agilent_82357a_priv *a_priv = board->private_data;
1386	struct usb_device *usb_dev = interface_to_usbdev(a_priv->bus_interface);
1387	struct agilent_82357a_register_pairlet writes[0x20];
1388	int retval;
1389
1390	// turn on tms9914 reset state
1391	writes[0].address = AUXCR;
1392	writes[0].value = AUX_CS | AUX_CHIP_RESET;
1393	a_priv->hw_control_bits &= ~NOT_TI_RESET;
1394	writes[1].address = HW_CONTROL;
1395	writes[1].value = a_priv->hw_control_bits;
1396	writes[2].address = PROTOCOL_CONTROL;
1397	writes[2].value = 0;
1398	writes[3].address = IMR0;
1399	writes[3].value = 0;
1400	writes[4].address = IMR1;
1401	writes[4].value = 0;
1402	writes[5].address = LED_CONTROL;
1403	writes[5].value = 0;
1404	retval = agilent_82357a_write_registers(a_priv, writes, 6);
1405	if (retval) {
1406		dev_err(&usb_dev->dev, "write_registers() returned error\n");
1407		return -EIO;
1408	}
1409	return 0;
1410}
1411
1412static void agilent_82357a_detach(struct gpib_board *board)
1413{
1414	struct agilent_82357a_priv *a_priv;
1415
1416	mutex_lock(&agilent_82357a_hotplug_lock);
1417
1418	a_priv = board->private_data;
1419	if (a_priv) {
1420		if (a_priv->bus_interface) {
1421			agilent_82357a_go_idle(board);
1422			usb_set_intfdata(a_priv->bus_interface, NULL);
1423		}
1424		mutex_lock(&a_priv->control_alloc_lock);
1425		mutex_lock(&a_priv->bulk_alloc_lock);
1426		mutex_lock(&a_priv->interrupt_alloc_lock);
1427		agilent_82357a_cleanup_urbs(a_priv);
1428		agilent_82357a_release_urbs(a_priv);
1429		agilent_82357a_free_private(board);
1430	}
1431	mutex_unlock(&agilent_82357a_hotplug_lock);
1432}
1433
1434static struct gpib_interface agilent_82357a_gpib_interface = {
1435	.name = "agilent_82357a",
1436	.attach = agilent_82357a_attach,
1437	.detach = agilent_82357a_detach,
1438	.read = agilent_82357a_read,
1439	.write = agilent_82357a_write,
1440	.command = agilent_82357a_command,
1441	.take_control = agilent_82357a_take_control,
1442	.go_to_standby = agilent_82357a_go_to_standby,
1443	.request_system_control = agilent_82357a_request_system_control,
1444	.interface_clear = agilent_82357a_interface_clear,
1445	.remote_enable = agilent_82357a_remote_enable,
1446	.enable_eos = agilent_82357a_enable_eos,
1447	.disable_eos = agilent_82357a_disable_eos,
1448	.parallel_poll = agilent_82357a_parallel_poll,
1449	.parallel_poll_configure = agilent_82357a_parallel_poll_configure,
1450	.parallel_poll_response = agilent_82357a_parallel_poll_response,
1451	.local_parallel_poll_mode = NULL, // XXX
1452	.line_status = agilent_82357a_line_status,
1453	.update_status = agilent_82357a_update_status,
1454	.primary_address = agilent_82357a_primary_address,
1455	.secondary_address = agilent_82357a_secondary_address,
1456	.serial_poll_response = agilent_82357a_serial_poll_response,
1457	.serial_poll_status = agilent_82357a_serial_poll_status,
1458	.t1_delay = agilent_82357a_t1_delay,
1459	.return_to_local = agilent_82357a_return_to_local,
1460	.no_7_bit_eos = 1,
1461	.skip_check_for_command_acceptors = 1
1462};
1463
1464// Table with the USB-devices: just now only testing IDs
1465static struct usb_device_id agilent_82357a_driver_device_table[] = {
1466	{USB_DEVICE(USB_VENDOR_ID_AGILENT, USB_DEVICE_ID_AGILENT_82357A)},
1467	{USB_DEVICE(USB_VENDOR_ID_AGILENT, USB_DEVICE_ID_AGILENT_82357B)},
1468	{} /* Terminating entry */
1469};
1470MODULE_DEVICE_TABLE(usb, agilent_82357a_driver_device_table);
1471
1472static int agilent_82357a_driver_probe(struct usb_interface *interface,
1473				       const struct usb_device_id *id)
1474{
1475	int i;
1476	char *path;
1477	static const int path_length = 1024;
1478	struct usb_device *usb_dev;
1479
1480	if (mutex_lock_interruptible(&agilent_82357a_hotplug_lock))
1481		return -ERESTARTSYS;
1482	usb_dev = usb_get_dev(interface_to_usbdev(interface));
1483	for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1484		if (!agilent_82357a_driver_interfaces[i]) {
1485			agilent_82357a_driver_interfaces[i] = interface;
1486			usb_set_intfdata(interface, NULL);
1487			dev_dbg(&usb_dev->dev, "set bus interface %i to address 0x%p\n",
1488				i, interface);
1489			break;
1490		}
1491	}
1492	if (i == MAX_NUM_82357A_INTERFACES) {
1493		usb_put_dev(usb_dev);
1494		mutex_unlock(&agilent_82357a_hotplug_lock);
1495		dev_err(&usb_dev->dev, "out of space in agilent_82357a_driver_interfaces[]\n");
1496		return -1;
1497	}
1498	path = kmalloc(path_length, GFP_KERNEL);
1499	if (!path) {
1500		usb_put_dev(usb_dev);
1501		mutex_unlock(&agilent_82357a_hotplug_lock);
1502		return -ENOMEM;
1503	}
1504	usb_make_path(usb_dev, path, path_length);
1505	dev_info(&usb_dev->dev, "probe succeeded for path: %s\n", path);
1506	kfree(path);
1507	mutex_unlock(&agilent_82357a_hotplug_lock);
1508	return 0;
1509}
1510
1511static void agilent_82357a_driver_disconnect(struct usb_interface *interface)
1512{
1513	int i;
1514	struct usb_device *usb_dev = interface_to_usbdev(interface);
1515
1516	mutex_lock(&agilent_82357a_hotplug_lock);
1517
1518	for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1519		if (agilent_82357a_driver_interfaces[i] == interface) {
1520			struct gpib_board *board = usb_get_intfdata(interface);
1521
1522			if (board) {
1523				struct agilent_82357a_priv *a_priv = board->private_data;
1524
1525				if (a_priv) {
1526					mutex_lock(&a_priv->control_alloc_lock);
1527					mutex_lock(&a_priv->bulk_alloc_lock);
1528					mutex_lock(&a_priv->interrupt_alloc_lock);
1529					agilent_82357a_cleanup_urbs(a_priv);
1530					a_priv->bus_interface = NULL;
1531					mutex_unlock(&a_priv->interrupt_alloc_lock);
1532					mutex_unlock(&a_priv->bulk_alloc_lock);
1533					mutex_unlock(&a_priv->control_alloc_lock);
1534				}
1535			}
1536			agilent_82357a_driver_interfaces[i] = NULL;
1537			break;
1538		}
1539	}
1540	if (i == MAX_NUM_82357A_INTERFACES)
1541		dev_err(&usb_dev->dev, "unable to find interface - bug?\n");
1542	usb_put_dev(usb_dev);
1543
1544	mutex_unlock(&agilent_82357a_hotplug_lock);
1545}
1546
1547static int agilent_82357a_driver_suspend(struct usb_interface *interface, pm_message_t message)
1548{
1549	int i, retval;
1550	struct usb_device *usb_dev = interface_to_usbdev(interface);
1551
1552	mutex_lock(&agilent_82357a_hotplug_lock);
1553
1554	for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i) {
1555		if (agilent_82357a_driver_interfaces[i] == interface)	{
1556			struct gpib_board *board = usb_get_intfdata(interface);
1557
1558			if (board) {
1559				struct agilent_82357a_priv *a_priv = board->private_data;
1560
1561				if (a_priv) {
1562					agilent_82357a_abort(a_priv, 0);
1563					agilent_82357a_abort(a_priv, 0);
1564					retval = agilent_82357a_go_idle(board);
1565					if (retval) {
1566						dev_err(&usb_dev->dev, "failed to go idle, retval=%i\n",
1567							retval);
1568						mutex_unlock(&agilent_82357a_hotplug_lock);
1569						return retval;
1570					}
1571					mutex_lock(&a_priv->interrupt_alloc_lock);
1572					agilent_82357a_cleanup_urbs(a_priv);
1573					mutex_unlock(&a_priv->interrupt_alloc_lock);
1574					dev_dbg(&usb_dev->dev,
1575						"bus %d dev num %d gpib %d, interface %i suspended\n",
1576						usb_dev->bus->busnum, usb_dev->devnum,
1577						board->minor, i);
1578				}
1579			}
1580			break;
1581		}
1582	}
1583
1584	mutex_unlock(&agilent_82357a_hotplug_lock);
1585
1586	return 0;
1587}
1588
1589static int agilent_82357a_driver_resume(struct usb_interface *interface)
1590{
1591	struct usb_device *usb_dev = interface_to_usbdev(interface);
1592	struct gpib_board *board;
1593	int i, retval = 0;
1594
1595	mutex_lock(&agilent_82357a_hotplug_lock);
1596
1597	for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i)	{
1598		if (agilent_82357a_driver_interfaces[i] == interface) {
1599			board = usb_get_intfdata(interface);
1600			if (board)
1601				break;
1602		}
1603	}
1604	if (i == MAX_NUM_82357A_INTERFACES) {
1605		retval = -ENOENT;
1606		goto resume_exit;
1607	}
1608
1609	struct agilent_82357a_priv *a_priv = board->private_data;
1610
1611	if (a_priv) {
1612		if (a_priv->interrupt_urb) {
1613			mutex_lock(&a_priv->interrupt_alloc_lock);
1614			retval = usb_submit_urb(a_priv->interrupt_urb, GFP_KERNEL);
1615			if (retval) {
1616				dev_err(&usb_dev->dev, "failed to resubmit interrupt urb in resume, retval=%i\n",
1617					retval);
1618				mutex_unlock(&a_priv->interrupt_alloc_lock);
1619				mutex_unlock(&agilent_82357a_hotplug_lock);
1620				return retval;
1621			}
1622			mutex_unlock(&a_priv->interrupt_alloc_lock);
1623		}
1624		retval = agilent_82357a_init(board);
1625		if (retval < 0) {
1626			mutex_unlock(&agilent_82357a_hotplug_lock);
1627			return retval;
1628		}
1629		// set/unset system controller
1630		retval = agilent_82357a_request_system_control(board, board->master);
1631		// toggle ifc if master
1632		if (board->master) {
1633			agilent_82357a_interface_clear(board, 1);
1634			usleep_range(200, 250);
1635			agilent_82357a_interface_clear(board, 0);
1636		}
1637		// assert/unassert REN
1638		agilent_82357a_remote_enable(board, a_priv->ren_state);
1639
1640		dev_dbg(&usb_dev->dev,
1641			"bus %d dev num %d gpib%d, interface %i resumed\n",
1642			usb_dev->bus->busnum, usb_dev->devnum, board->minor, i);
1643	}
1644
1645resume_exit:
1646	mutex_unlock(&agilent_82357a_hotplug_lock);
1647
1648	return retval;
1649}
1650
1651static struct usb_driver agilent_82357a_bus_driver = {
1652	.name = DRV_NAME,
1653	.probe = agilent_82357a_driver_probe,
1654	.disconnect = agilent_82357a_driver_disconnect,
1655	.suspend = agilent_82357a_driver_suspend,
1656	.resume = agilent_82357a_driver_resume,
1657	.id_table = agilent_82357a_driver_device_table,
1658};
1659
1660static int __init agilent_82357a_init_module(void)
1661{
1662	int i;
1663	int ret;
1664
1665	for (i = 0; i < MAX_NUM_82357A_INTERFACES; ++i)
1666		agilent_82357a_driver_interfaces[i] = NULL;
1667
1668	ret = usb_register(&agilent_82357a_bus_driver);
1669	if (ret) {
1670		pr_err("usb_register failed: error = %d\n", ret);
1671		return ret;
1672	}
1673
1674	ret = gpib_register_driver(&agilent_82357a_gpib_interface, THIS_MODULE);
1675	if (ret) {
1676		pr_err("gpib_register_driver failed: error = %d\n", ret);
1677		usb_deregister(&agilent_82357a_bus_driver);
1678		return ret;
1679	}
1680
1681	return 0;
1682}
1683
1684static void __exit agilent_82357a_exit_module(void)
1685{
1686	gpib_unregister_driver(&agilent_82357a_gpib_interface);
1687	usb_deregister(&agilent_82357a_bus_driver);
1688}
1689
1690module_init(agilent_82357a_init_module);
1691module_exit(agilent_82357a_exit_module);