ni_usb_gpib.c

   1// SPDX-License-Identifier: GPL-2.0
   2
   3/***************************************************************************
   4 * driver for National Instruments usb to gpib adapters
   5 *    copyright		   : (C) 2004 by Frank Mori Hess
   6 ***************************************************************************/
   7
   8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9#define dev_fmt pr_fmt
  10#define DRV_NAME KBUILD_MODNAME
  11
  12#include <linux/kernel.h>
  13#include <linux/module.h>
  14#include <linux/slab.h>
  15#include "ni_usb_gpib.h"
  16#include "gpibP.h"
  17#include "nec7210.h"
  18#include "tnt4882_registers.h"
  19
  20MODULE_LICENSE("GPL");
  21MODULE_DESCRIPTION("GPIB driver for National Instruments USB devices");
  22
  23#define MAX_NUM_NI_USB_INTERFACES 128
  24static struct usb_interface *ni_usb_driver_interfaces[MAX_NUM_NI_USB_INTERFACES];
  25
  26static int ni_usb_parse_status_block(const u8 *buffer, struct ni_usb_status_block *status);
  27static int ni_usb_set_interrupt_monitor(struct gpib_board *board, unsigned int monitored_bits);
  28static void ni_usb_stop(struct ni_usb_priv *ni_priv);
  29
  30static DEFINE_MUTEX(ni_usb_hotplug_lock);
  31
  32// calculates a reasonable timeout in that can be passed to usb functions
  33static inline unsigned long ni_usb_timeout_msecs(unsigned int usec)
  34{
  35	if (usec == 0)
  36		return 0;
  37	return 2000 + usec / 500;
  38};
  39
  40// returns timeout code byte for use in ni-usb-b instructions
  41static unsigned short ni_usb_timeout_code(unsigned int usec)
  42{
  43	if (usec == 0)
  44		return 0xf0;
  45	else if (usec <= 10)
  46		return 0xf1;
  47	else if (usec <= 30)
  48		return 0xf2;
  49	else if (usec <= 100)
  50		return 0xf3;
  51	else if (usec <= 300)
  52		return 0xf4;
  53	else if (usec <= 1000)
  54		return 0xf5;
  55	else if (usec <= 3000)
  56		return 0xf6;
  57	else if (usec <= 10000)
  58		return 0xf7;
  59	else if (usec <= 30000)
  60		return 0xf8;
  61	else if (usec <= 100000)
  62		return 0xf9;
  63	else if (usec <= 300000)
  64		return 0xfa;
  65	else if (usec <= 1000000)
  66		return 0xfb;
  67	else if (usec <= 3000000)
  68		return 0xfc;
  69	else if (usec <= 10000000)
  70		return 0xfd;
  71	else if (usec <= 30000000)
  72		return 0xfe;
  73	else if (usec <= 100000000)
  74		return 0xff;
  75	else if	 (usec <= 300000000)
  76		return 0x01;
  77	/*
  78	 * NI driver actually uses 0xff for timeout T1000s, which is a bug in their code.
  79	 * I've verified on a usb-b that a code of 0x2 is correct for a 1000 sec timeout
  80	 */
  81	else if (usec <= 1000000000)
  82		return 0x02;
  83	pr_err("bug? usec is greater than 1e9\n");
  84	return 0xf0;
  85}
  86
  87static void ni_usb_bulk_complete(struct urb *urb)
  88{
  89	struct ni_usb_urb_ctx *context = urb->context;
  90
  91	complete(&context->complete);
  92}
  93
  94static void ni_usb_timeout_handler(struct timer_list *t)
  95{
  96	struct ni_usb_priv *ni_priv = timer_container_of(ni_priv, t,
  97							 bulk_timer);
  98	struct ni_usb_urb_ctx *context = &ni_priv->context;
  99
 100	context->timed_out = 1;
 101	complete(&context->complete);
 102};
 103
 104// I'm using nonblocking loosely here, it only means -EAGAIN can be returned in certain cases
 105static int ni_usb_nonblocking_send_bulk_msg(struct ni_usb_priv *ni_priv, void *data,
 106					    int data_length, int *actual_data_length,
 107					    int timeout_msecs)
 108{
 109	struct usb_device *usb_dev;
 110	int retval;
 111	unsigned int out_pipe;
 112	struct ni_usb_urb_ctx *context = &ni_priv->context;
 113
 114	*actual_data_length = 0;
 115	mutex_lock(&ni_priv->bulk_transfer_lock);
 116	if (!ni_priv->bus_interface) {
 117		mutex_unlock(&ni_priv->bulk_transfer_lock);
 118		return -ENODEV;
 119	}
 120	if (ni_priv->bulk_urb) {
 121		mutex_unlock(&ni_priv->bulk_transfer_lock);
 122		return -EAGAIN;
 123	}
 124	ni_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
 125	if (!ni_priv->bulk_urb) {
 126		mutex_unlock(&ni_priv->bulk_transfer_lock);
 127		return -ENOMEM;
 128	}
 129	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 130	out_pipe = usb_sndbulkpipe(usb_dev, ni_priv->bulk_out_endpoint);
 131	init_completion(&context->complete);
 132	context->timed_out = 0;
 133	usb_fill_bulk_urb(ni_priv->bulk_urb, usb_dev, out_pipe, data, data_length,
 134			  &ni_usb_bulk_complete, context);
 135
 136	if (timeout_msecs)
 137		mod_timer(&ni_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs));
 138
 139	retval = usb_submit_urb(ni_priv->bulk_urb, GFP_KERNEL);
 140	if (retval) {
 141		timer_delete_sync(&ni_priv->bulk_timer);
 142		usb_free_urb(ni_priv->bulk_urb);
 143		ni_priv->bulk_urb = NULL;
 144		dev_err(&usb_dev->dev, "failed to submit bulk out urb, retval=%i\n",
 145			retval);
 146		mutex_unlock(&ni_priv->bulk_transfer_lock);
 147		return retval;
 148	}
 149	mutex_unlock(&ni_priv->bulk_transfer_lock);
 150	wait_for_completion(&context->complete);    // wait for ni_usb_bulk_complete
 151	if (context->timed_out) {
 152		usb_kill_urb(ni_priv->bulk_urb);
 153		dev_err(&usb_dev->dev, "killed urb due to timeout\n");
 154		retval = -ETIMEDOUT;
 155	} else {
 156		retval = ni_priv->bulk_urb->status;
 157	}
 158
 159	timer_delete_sync(&ni_priv->bulk_timer);
 160	*actual_data_length = ni_priv->bulk_urb->actual_length;
 161	mutex_lock(&ni_priv->bulk_transfer_lock);
 162	usb_free_urb(ni_priv->bulk_urb);
 163	ni_priv->bulk_urb = NULL;
 164	mutex_unlock(&ni_priv->bulk_transfer_lock);
 165	return retval;
 166}
 167
 168static int ni_usb_send_bulk_msg(struct ni_usb_priv *ni_priv, void *data, int data_length,
 169				int *actual_data_length, int timeout_msecs)
 170{
 171	int retval;
 172	int timeout_msecs_remaining = timeout_msecs;
 173
 174	retval = ni_usb_nonblocking_send_bulk_msg(ni_priv, data, data_length, actual_data_length,
 175						  timeout_msecs_remaining);
 176	while (retval == -EAGAIN && (timeout_msecs == 0 || timeout_msecs_remaining > 0)) {
 177		usleep_range(1000, 1500);
 178		retval = ni_usb_nonblocking_send_bulk_msg(ni_priv, data, data_length,
 179							  actual_data_length,
 180							  timeout_msecs_remaining);
 181		if (timeout_msecs != 0)
 182			--timeout_msecs_remaining;
 183	}
 184	if (timeout_msecs != 0 && timeout_msecs_remaining <= 0)
 185		return -ETIMEDOUT;
 186	return retval;
 187}
 188
 189// I'm using nonblocking loosely here, it only means -EAGAIN can be returned in certain cases
 190static int ni_usb_nonblocking_receive_bulk_msg(struct ni_usb_priv *ni_priv,
 191					       void *data, int data_length,
 192					       int *actual_data_length, int timeout_msecs,
 193					       int interruptible)
 194{
 195	struct usb_device *usb_dev;
 196	int retval;
 197	unsigned int in_pipe;
 198	struct ni_usb_urb_ctx *context = &ni_priv->context;
 199
 200	*actual_data_length = 0;
 201	mutex_lock(&ni_priv->bulk_transfer_lock);
 202	if (!ni_priv->bus_interface) {
 203		mutex_unlock(&ni_priv->bulk_transfer_lock);
 204		return -ENODEV;
 205	}
 206	if (ni_priv->bulk_urb) {
 207		mutex_unlock(&ni_priv->bulk_transfer_lock);
 208		return -EAGAIN;
 209	}
 210	ni_priv->bulk_urb = usb_alloc_urb(0, GFP_KERNEL);
 211	if (!ni_priv->bulk_urb) {
 212		mutex_unlock(&ni_priv->bulk_transfer_lock);
 213		return -ENOMEM;
 214	}
 215	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 216	in_pipe = usb_rcvbulkpipe(usb_dev, ni_priv->bulk_in_endpoint);
 217	init_completion(&context->complete);
 218	context->timed_out = 0;
 219	usb_fill_bulk_urb(ni_priv->bulk_urb, usb_dev, in_pipe, data, data_length,
 220			  &ni_usb_bulk_complete, context);
 221
 222	if (timeout_msecs)
 223		mod_timer(&ni_priv->bulk_timer, jiffies + msecs_to_jiffies(timeout_msecs));
 224
 225	retval = usb_submit_urb(ni_priv->bulk_urb, GFP_KERNEL);
 226	if (retval) {
 227		timer_delete_sync(&ni_priv->bulk_timer);
 228		usb_free_urb(ni_priv->bulk_urb);
 229		ni_priv->bulk_urb = NULL;
 230		dev_err(&usb_dev->dev, "failed to submit bulk in urb, retval=%i\n", retval);
 231		mutex_unlock(&ni_priv->bulk_transfer_lock);
 232		return retval;
 233	}
 234	mutex_unlock(&ni_priv->bulk_transfer_lock);
 235	if (interruptible) {
 236		if (wait_for_completion_interruptible(&context->complete)) {
 237			/*
 238			 * If we got interrupted by a signal while
 239			 * waiting for the usb gpib to respond, we
 240			 * should send a stop command so it will
 241			 * finish up with whatever it was doing and
 242			 * send its response now.
 243			 */
 244			ni_usb_stop(ni_priv);
 245			retval = -ERESTARTSYS;
 246			/*
 247			 * now do an uninterruptible wait, it shouldn't take long
 248			 * for the board to respond now.
 249			 */
 250			wait_for_completion(&context->complete);
 251		}
 252	} else {
 253		wait_for_completion(&context->complete);
 254	}
 255	if (context->timed_out) {
 256		usb_kill_urb(ni_priv->bulk_urb);
 257		dev_err(&usb_dev->dev, "killed urb due to timeout\n");
 258		retval = -ETIMEDOUT;
 259	} else {
 260		if (ni_priv->bulk_urb->status)
 261			retval = ni_priv->bulk_urb->status;
 262	}
 263	timer_delete_sync(&ni_priv->bulk_timer);
 264	*actual_data_length = ni_priv->bulk_urb->actual_length;
 265	mutex_lock(&ni_priv->bulk_transfer_lock);
 266	usb_free_urb(ni_priv->bulk_urb);
 267	ni_priv->bulk_urb = NULL;
 268	mutex_unlock(&ni_priv->bulk_transfer_lock);
 269	return retval;
 270}
 271
 272static int ni_usb_receive_bulk_msg(struct ni_usb_priv *ni_priv, void *data,
 273				   int data_length, int *actual_data_length, int timeout_msecs,
 274				   int interruptible)
 275{
 276	int retval;
 277	int timeout_msecs_remaining = timeout_msecs;
 278
 279	retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, data, data_length,
 280						     actual_data_length, timeout_msecs_remaining,
 281						     interruptible);
 282	while (retval == -EAGAIN && (timeout_msecs == 0 || timeout_msecs_remaining > 0)) {
 283		usleep_range(1000, 1500);
 284		retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, data, data_length,
 285							     actual_data_length,
 286							     timeout_msecs_remaining,
 287							     interruptible);
 288		if (timeout_msecs != 0)
 289			--timeout_msecs_remaining;
 290	}
 291	if (timeout_msecs && timeout_msecs_remaining <= 0)
 292		return -ETIMEDOUT;
 293	return retval;
 294}
 295
 296static int ni_usb_receive_control_msg(struct ni_usb_priv *ni_priv, __u8 request,
 297				      __u8 requesttype, __u16 value, __u16 index,
 298				      void *data, __u16 size, int timeout_msecs)
 299{
 300	struct usb_device *usb_dev;
 301	int retval;
 302	unsigned int in_pipe;
 303
 304	mutex_lock(&ni_priv->control_transfer_lock);
 305	if (!ni_priv->bus_interface) {
 306		mutex_unlock(&ni_priv->control_transfer_lock);
 307		return -ENODEV;
 308	}
 309	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 310	in_pipe = usb_rcvctrlpipe(usb_dev, 0);
 311	retval = usb_control_msg(usb_dev, in_pipe, request, requesttype, value, index, data,
 312				 size, timeout_msecs);
 313	mutex_unlock(&ni_priv->control_transfer_lock);
 314	return retval;
 315}
 316
 317static void ni_usb_soft_update_status(struct gpib_board *board, unsigned int ni_usb_ibsta,
 318				      unsigned int clear_mask)
 319{
 320	static const unsigned int ni_usb_ibsta_mask = SRQI | ATN | CIC | REM | LACS | TACS | LOK;
 321
 322	struct ni_usb_priv *ni_priv = board->private_data;
 323	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 324	unsigned int need_monitoring_bits = ni_usb_ibsta_monitor_mask;
 325	unsigned long flags;
 326
 327	board->status &= ~clear_mask;
 328	board->status &= ~ni_usb_ibsta_mask;
 329	board->status |= ni_usb_ibsta & ni_usb_ibsta_mask;
 330	if (ni_usb_ibsta & DCAS)
 331		push_gpib_event(board, EVENT_DEV_CLR);
 332	if (ni_usb_ibsta & DTAS)
 333		push_gpib_event(board, EVENT_DEV_TRG);
 334
 335	spin_lock_irqsave(&board->spinlock, flags);
 336/* remove set status bits from monitored set why ?***/
 337	ni_priv->monitored_ibsta_bits &= ~ni_usb_ibsta;
 338	need_monitoring_bits &= ~ni_priv->monitored_ibsta_bits; /* mm - monitored set */
 339	spin_unlock_irqrestore(&board->spinlock, flags);
 340	dev_dbg(&usb_dev->dev, "need_monitoring_bits=0x%x\n", need_monitoring_bits);
 341
 342	if (need_monitoring_bits & ~ni_usb_ibsta)
 343		ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask);
 344	else if (need_monitoring_bits & ni_usb_ibsta)
 345		wake_up_interruptible(&board->wait);
 346
 347	dev_dbg(&usb_dev->dev, "ibsta=0x%x\n", ni_usb_ibsta);
 348}
 349
 350static int ni_usb_parse_status_block(const u8 *buffer, struct ni_usb_status_block *status)
 351{
 352	u16 count;
 353
 354	status->id = buffer[0];
 355	status->ibsta = (buffer[1] << 8) | buffer[2];
 356	status->error_code = buffer[3];
 357	count = buffer[4] | (buffer[5] << 8);
 358	count = ~count;
 359	count++;
 360	status->count = count;
 361	return 8;
 362};
 363
 364static void ni_usb_dump_raw_block(const u8 *raw_data, int length)
 365{
 366	print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 8, 1, raw_data, length, true);
 367}
 368
 369static int ni_usb_parse_register_read_block(const u8 *raw_data, unsigned int *results,
 370					    int num_results)
 371{
 372	int i = 0;
 373	int j;
 374	int unexpected = 0;
 375	static const int results_per_chunk = 3;
 376
 377	for (j = 0; j < num_results;) {
 378		int k;
 379
 380		if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_START_ID) {
 381			pr_err("parse error: wrong start id\n");
 382			unexpected = 1;
 383		}
 384		for (k = 0; k < results_per_chunk && j < num_results; ++k)
 385			results[j++] = raw_data[i++];
 386	}
 387	while (i % 4)
 388		i++;
 389	if (raw_data[i++] != NIUSB_REGISTER_READ_DATA_END_ID) {
 390		pr_err("parse error: wrong end id\n");
 391		unexpected = 1;
 392	}
 393	if (raw_data[i++] % results_per_chunk != num_results % results_per_chunk) {
 394		pr_err("parse error: wrong count=%i for NIUSB_REGISTER_READ_DATA_END\n",
 395		       (int)raw_data[i - 1]);
 396		unexpected = 1;
 397	}
 398	while (i % 4) {
 399		if (raw_data[i++] != 0) {
 400			pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n",
 401			       i - 1, (int)raw_data[i - 1]);
 402			unexpected = 1;
 403		}
 404	}
 405	if (unexpected)
 406		ni_usb_dump_raw_block(raw_data, i);
 407	return i;
 408}
 409
 410static int ni_usb_parse_termination_block(const u8 *buffer)
 411{
 412	int i = 0;
 413
 414	if (buffer[i++] != NIUSB_TERM_ID ||
 415	    buffer[i++] != 0x0 ||
 416	    buffer[i++] != 0x0 ||
 417	    buffer[i++] != 0x0) {
 418		pr_err("received unexpected termination block\n");
 419		pr_err(" expected: 0x%x 0x%x 0x%x 0x%x\n", NIUSB_TERM_ID, 0x0, 0x0, 0x0);
 420		pr_err(" received: 0x%x 0x%x 0x%x 0x%x\n",
 421		       buffer[i - 4], buffer[i - 3], buffer[i - 2], buffer[i - 1]);
 422	}
 423	return i;
 424};
 425
 426static int parse_board_ibrd_readback(const u8 *raw_data, struct ni_usb_status_block *status,
 427				     u8 *parsed_data, int parsed_data_length,
 428				     int *actual_bytes_read)
 429{
 430	static const int ibrd_data_block_length = 0xf;
 431	static const int ibrd_extended_data_block_length = 0x1e;
 432	int data_block_length = 0;
 433	int i = 0;
 434	int j = 0;
 435	int k;
 436	int num_data_blocks = 0;
 437	struct ni_usb_status_block register_write_status;
 438	int unexpected = 0;
 439
 440	while (raw_data[i] == NIUSB_IBRD_DATA_ID || raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) {
 441		if (raw_data[i] == NIUSB_IBRD_DATA_ID) {
 442			data_block_length = ibrd_data_block_length;
 443		} else if (raw_data[i] == NIUSB_IBRD_EXTENDED_DATA_ID) {
 444			data_block_length = ibrd_extended_data_block_length;
 445			if (raw_data[++i] !=  0)	{
 446				pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n",
 447				       i, (int)raw_data[i]);
 448				unexpected = 1;
 449			}
 450		} else {
 451			pr_err("Unexpected NIUSB_IBRD ID\n");
 452			return -EINVAL;
 453		}
 454		++i;
 455		for (k = 0; k < data_block_length; k++) {
 456			if (j < parsed_data_length)
 457				parsed_data[j++] = raw_data[i++];
 458			else
 459				++i;
 460		}
 461		++num_data_blocks;
 462	}
 463	i += ni_usb_parse_status_block(&raw_data[i], status);
 464	if (status->id != NIUSB_IBRD_STATUS_ID) {
 465		pr_err("bug: status->id=%i, != ibrd_status_id\n", status->id);
 466		return -EIO;
 467	}
 468	i++;
 469	if (num_data_blocks) {
 470		*actual_bytes_read = (num_data_blocks - 1) * data_block_length + raw_data[i++];
 471	} else {
 472		++i;
 473		*actual_bytes_read = 0;
 474	}
 475	if (*actual_bytes_read > j)
 476		pr_err("bug: discarded data. actual_bytes_read=%i, j=%i\n", *actual_bytes_read, j);
 477	for (k = 0; k < 2; k++)
 478		if (raw_data[i++] != 0) {
 479			pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n",
 480			       i - 1, (int)raw_data[i - 1]);
 481			unexpected = 1;
 482		}
 483	i += ni_usb_parse_status_block(&raw_data[i], &register_write_status);
 484	if (register_write_status.id != NIUSB_REG_WRITE_ID) {
 485		pr_err("unexpected data: register write status id=0x%x, expected 0x%x\n",
 486		       register_write_status.id, NIUSB_REG_WRITE_ID);
 487		unexpected = 1;
 488	}
 489	if (raw_data[i++] != 2) {
 490		pr_err("unexpected data: register write count=%i, expected 2\n",
 491		       (int)raw_data[i - 1]);
 492		unexpected = 1;
 493	}
 494	for (k = 0; k < 3; k++)
 495		if (raw_data[i++] != 0) {
 496			pr_err("unexpected data: raw_data[%i]=0x%x, expected 0\n",
 497			       i - 1, (int)raw_data[i - 1]);
 498			unexpected = 1;
 499		}
 500	i += ni_usb_parse_termination_block(&raw_data[i]);
 501	if (unexpected)
 502		ni_usb_dump_raw_block(raw_data, i);
 503	return i;
 504}
 505
 506static	int ni_usb_parse_reg_write_status_block(const u8 *raw_data,
 507						struct ni_usb_status_block *status,
 508						int *writes_completed)
 509{
 510	int i = 0;
 511
 512	i += ni_usb_parse_status_block(raw_data, status);
 513	*writes_completed = raw_data[i++];
 514	while (i % 4)
 515		i++;
 516	return i;
 517}
 518
 519static int ni_usb_write_registers(struct ni_usb_priv *ni_priv,
 520				  const struct ni_usb_register *writes, int num_writes,
 521				  unsigned int *ibsta)
 522{
 523	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 524	int retval;
 525	u8 *out_data, *in_data;
 526	int out_data_length;
 527	static const int in_data_length = 0x20;
 528	int bytes_written = 0, bytes_read = 0;
 529	int i = 0;
 530	int j;
 531	struct ni_usb_status_block status;
 532	static const int bytes_per_write = 3;
 533	int reg_writes_completed;
 534
 535	out_data_length = num_writes * bytes_per_write + 0x10;
 536	out_data = kmalloc(out_data_length, GFP_KERNEL);
 537	if (!out_data)
 538		return -ENOMEM;
 539	i += ni_usb_bulk_register_write_header(&out_data[i], num_writes);
 540	for (j = 0; j < num_writes; j++)
 541		i += ni_usb_bulk_register_write(&out_data[i], writes[j]);
 542	while (i % 4)
 543		out_data[i++] = 0x00;
 544	i += ni_usb_bulk_termination(&out_data[i]);
 545
 546	mutex_lock(&ni_priv->addressed_transfer_lock);
 547
 548	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000);
 549	kfree(out_data);
 550	if (retval) {
 551		mutex_unlock(&ni_priv->addressed_transfer_lock);
 552		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
 553			retval, bytes_written, i);
 554		return retval;
 555	}
 556
 557	in_data = kmalloc(in_data_length, GFP_KERNEL);
 558	if (!in_data) {
 559		mutex_unlock(&ni_priv->addressed_transfer_lock);
 560		return -ENOMEM;
 561	}
 562	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0);
 563	if (retval || bytes_read != 16) {
 564		mutex_unlock(&ni_priv->addressed_transfer_lock);
 565		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
 566			retval, bytes_read);
 567		ni_usb_dump_raw_block(in_data, bytes_read);
 568		kfree(in_data);
 569		return retval ?: -EINVAL;
 570	}
 571
 572	mutex_unlock(&ni_priv->addressed_transfer_lock);
 573
 574	ni_usb_parse_reg_write_status_block(in_data, &status, &reg_writes_completed);
 575	// FIXME parse extra 09 status bits and termination
 576	kfree(in_data);
 577	if (status.id != NIUSB_REG_WRITE_ID) {
 578		dev_err(&usb_dev->dev, "parse error, id=0x%x != NIUSB_REG_WRITE_ID\n", status.id);
 579		return -EIO;
 580	}
 581	if (status.error_code) {
 582		dev_err(&usb_dev->dev, "nonzero error code 0x%x\n", status.error_code);
 583		return -EIO;
 584	}
 585	if (reg_writes_completed != num_writes) {
 586		dev_err(&usb_dev->dev, "reg_writes_completed=%i, num_writes=%i\n",
 587			reg_writes_completed, num_writes);
 588		return -EIO;
 589	}
 590	if (ibsta)
 591		*ibsta = status.ibsta;
 592	return 0;
 593}
 594
 595// interface functions
 596static int ni_usb_read(struct gpib_board *board, u8 *buffer, size_t length,
 597		       int *end, size_t *bytes_read)
 598{
 599	int retval, parse_retval;
 600	struct ni_usb_priv *ni_priv = board->private_data;
 601	struct usb_device *usb_dev;
 602	u8 *out_data, *in_data;
 603	static const int out_data_length = 0x20;
 604	int in_data_length;
 605	int usb_bytes_written = 0, usb_bytes_read = 0;
 606	int i = 0;
 607	int complement_count;
 608	int actual_length;
 609	struct ni_usb_status_block status;
 610	static const int max_read_length = 0xffff;
 611	struct ni_usb_register reg;
 612
 613	*bytes_read = 0;
 614	if (!ni_priv->bus_interface)
 615		return -ENODEV;
 616	if (length > max_read_length)
 617		return -EINVAL;
 618	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 619	out_data = kmalloc(out_data_length, GFP_KERNEL);
 620	if (!out_data)
 621		return -ENOMEM;
 622	out_data[i++] = 0x0a;
 623	out_data[i++] = ni_priv->eos_mode >> 8;
 624	out_data[i++] = ni_priv->eos_char;
 625	out_data[i++] = ni_usb_timeout_code(board->usec_timeout);
 626	complement_count = length - 1;
 627	complement_count = ~complement_count;
 628	out_data[i++] = complement_count & 0xff;
 629	out_data[i++] = (complement_count >> 8) & 0xff;
 630	out_data[i++] = 0x0;
 631	out_data[i++] = 0x0;
 632	i += ni_usb_bulk_register_write_header(&out_data[i], 2);
 633	reg.device = NIUSB_SUBDEV_TNT4882;
 634	reg.address = nec7210_to_tnt4882_offset(AUXMR);
 635	reg.value = AUX_HLDI;
 636	i += ni_usb_bulk_register_write(&out_data[i], reg);
 637	reg.value = AUX_CLEAR_END;
 638	i += ni_usb_bulk_register_write(&out_data[i], reg);
 639	while (i % 4)	// pad with zeros to 4-byte boundary
 640		out_data[i++] = 0x0;
 641	i += ni_usb_bulk_termination(&out_data[i]);
 642
 643	mutex_lock(&ni_priv->addressed_transfer_lock);
 644
 645	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &usb_bytes_written, 1000);
 646	kfree(out_data);
 647	if (retval || usb_bytes_written != i) {
 648		if (retval == 0)
 649			retval = -EIO;
 650		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n",
 651			retval, usb_bytes_written, i);
 652		mutex_unlock(&ni_priv->addressed_transfer_lock);
 653		return retval;
 654	}
 655
 656	in_data_length = (length / 30 + 1) * 0x20 + 0x20;
 657	in_data = kmalloc(in_data_length, GFP_KERNEL);
 658	if (!in_data) {
 659		mutex_unlock(&ni_priv->addressed_transfer_lock);
 660		return -ENOMEM;
 661	}
 662	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &usb_bytes_read,
 663					 ni_usb_timeout_msecs(board->usec_timeout), 1);
 664
 665	mutex_unlock(&ni_priv->addressed_transfer_lock);
 666
 667	if (retval == -ERESTARTSYS) {
 668	} else if (retval) {
 669		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, usb_bytes_read=%i\n",
 670			retval, usb_bytes_read);
 671		kfree(in_data);
 672		return retval;
 673	}
 674	parse_retval = parse_board_ibrd_readback(in_data, &status, buffer, length, &actual_length);
 675	if (parse_retval != usb_bytes_read) {
 676		if (parse_retval >= 0)
 677			parse_retval = -EIO;
 678		dev_err(&usb_dev->dev, "retval=%i usb_bytes_read=%i\n",
 679			parse_retval, usb_bytes_read);
 680		kfree(in_data);
 681		return parse_retval;
 682	}
 683	if (actual_length != length - status.count) {
 684		dev_err(&usb_dev->dev, "actual_length=%i expected=%li\n",
 685			actual_length, (long)(length - status.count));
 686		ni_usb_dump_raw_block(in_data, usb_bytes_read);
 687	}
 688	kfree(in_data);
 689	switch (status.error_code) {
 690	case NIUSB_NO_ERROR:
 691		retval = 0;
 692		break;
 693	case NIUSB_ABORTED_ERROR:
 694		/*
 695		 * this is expected if ni_usb_receive_bulk_msg got
 696		 * interrupted by a signal and returned -ERESTARTSYS
 697		 */
 698		break;
 699	case NIUSB_ATN_STATE_ERROR:
 700		if (status.ibsta & DCAS) {
 701			retval = -EINTR;
 702		} else {
 703			retval = -EIO;
 704			dev_dbg(&usb_dev->dev, "read when ATN set stat: 0x%06x\n", status.ibsta);
 705		}
 706		break;
 707	case NIUSB_ADDRESSING_ERROR:
 708		retval = -EIO;
 709		break;
 710	case NIUSB_TIMEOUT_ERROR:
 711		retval = -ETIMEDOUT;
 712		break;
 713	case NIUSB_EOSMODE_ERROR:
 714		dev_err(&usb_dev->dev, "driver bug, we should have been able to avoid NIUSB_EOSMODE_ERROR.\n");
 715		retval = -EINVAL;
 716		break;
 717	default:
 718		dev_err(&usb_dev->dev, "unknown error code=%i\n",  status.error_code);
 719		retval = -EIO;
 720		break;
 721	}
 722	ni_usb_soft_update_status(board, status.ibsta, 0);
 723	if (status.ibsta & END)
 724		*end = 1;
 725	else
 726		*end = 0;
 727	*bytes_read = actual_length;
 728	return retval;
 729}
 730
 731static int ni_usb_write(struct gpib_board *board, u8 *buffer, size_t length,
 732			int send_eoi, size_t *bytes_written)
 733{
 734	int retval;
 735	struct ni_usb_priv *ni_priv = board->private_data;
 736	struct usb_device *usb_dev;
 737	u8 *out_data, *in_data;
 738	int out_data_length;
 739	static const int in_data_length = 0x10;
 740	int usb_bytes_written = 0, usb_bytes_read = 0;
 741	int i = 0, j;
 742	int complement_count;
 743	struct ni_usb_status_block status;
 744	static const int max_write_length = 0xffff;
 745
 746	if (!ni_priv->bus_interface)
 747		return -ENODEV;
 748	if (length > max_write_length)
 749		return -EINVAL;
 750	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 751	out_data_length = length + 0x10;
 752	out_data = kmalloc(out_data_length, GFP_KERNEL);
 753	if (!out_data)
 754		return -ENOMEM;
 755	out_data[i++] = 0x0d;
 756	complement_count = length - 1;
 757	complement_count = ~complement_count;
 758	out_data[i++] = complement_count & 0xff;
 759	out_data[i++] = (complement_count >> 8) & 0xff;
 760	out_data[i++] = ni_usb_timeout_code(board->usec_timeout);
 761	out_data[i++] = 0x0;
 762	out_data[i++] = 0x0;
 763	if (send_eoi)
 764		out_data[i++] = 0x8;
 765	else
 766		out_data[i++] = 0x0;
 767	out_data[i++] = 0x0;
 768	for (j = 0; j < length; j++)
 769		out_data[i++] = buffer[j];
 770	while (i % 4)	// pad with zeros to 4-byte boundary
 771		out_data[i++] = 0x0;
 772	i += ni_usb_bulk_termination(&out_data[i]);
 773
 774	mutex_lock(&ni_priv->addressed_transfer_lock);
 775
 776	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &usb_bytes_written,
 777				      ni_usb_timeout_msecs(board->usec_timeout));
 778	kfree(out_data);
 779	if (retval || usb_bytes_written != i)	{
 780		mutex_unlock(&ni_priv->addressed_transfer_lock);
 781		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, usb_bytes_written=%i, i=%i\n",
 782			retval, usb_bytes_written, i);
 783		return retval;
 784	}
 785
 786	in_data = kmalloc(in_data_length, GFP_KERNEL);
 787	if (!in_data) {
 788		mutex_unlock(&ni_priv->addressed_transfer_lock);
 789		return -ENOMEM;
 790	}
 791	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &usb_bytes_read,
 792					 ni_usb_timeout_msecs(board->usec_timeout), 1);
 793
 794	mutex_unlock(&ni_priv->addressed_transfer_lock);
 795
 796	if ((retval && retval != -ERESTARTSYS) || usb_bytes_read != 12) {
 797		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, usb_bytes_read=%i\n",
 798			retval, usb_bytes_read);
 799		kfree(in_data);
 800		return retval;
 801	}
 802	ni_usb_parse_status_block(in_data, &status);
 803	kfree(in_data);
 804	switch	(status.error_code) {
 805	case NIUSB_NO_ERROR:
 806		retval = 0;
 807		break;
 808	case NIUSB_ABORTED_ERROR:
 809		/*
 810		 * this is expected if ni_usb_receive_bulk_msg got
 811		 * interrupted by a signal and returned -ERESTARTSYS
 812		 */
 813		break;
 814	case NIUSB_ADDRESSING_ERROR:
 815		dev_err(&usb_dev->dev, "Addressing error retval %d error code=%i\n",
 816			retval, status.error_code);
 817		retval = -ENXIO;
 818		break;
 819	case NIUSB_NO_LISTENER_ERROR:
 820		retval = -ECOMM;
 821		break;
 822	case NIUSB_TIMEOUT_ERROR:
 823		retval = -ETIMEDOUT;
 824		break;
 825	default:
 826		dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code);
 827		retval = -EPIPE;
 828		break;
 829	}
 830	ni_usb_soft_update_status(board, status.ibsta, 0);
 831	*bytes_written = length - status.count;
 832	return retval;
 833}
 834
 835static int ni_usb_command_chunk(struct gpib_board *board, u8 *buffer, size_t length,
 836				size_t *command_bytes_written)
 837{
 838	int retval;
 839	struct ni_usb_priv *ni_priv = board->private_data;
 840	struct usb_device *usb_dev;
 841	u8 *out_data, *in_data;
 842	int out_data_length;
 843	static const int in_data_length = 0x10;
 844	int bytes_written = 0, bytes_read = 0;
 845	int i = 0, j;
 846	unsigned int complement_count;
 847	struct ni_usb_status_block status;
 848	// usb-b gives error 4 if you try to send more than 16 command bytes at once
 849	static const int max_command_length = 0x10;
 850
 851	*command_bytes_written = 0;
 852	if (!ni_priv->bus_interface)
 853		return -ENODEV;
 854	if (length > max_command_length)
 855		length = max_command_length;
 856	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 857	out_data_length = length + 0x10;
 858	out_data = kmalloc(out_data_length, GFP_KERNEL);
 859	if (!out_data)
 860		return -ENOMEM;
 861	out_data[i++] = 0x0c;
 862	complement_count = length - 1;
 863	complement_count = ~complement_count;
 864	out_data[i++] = complement_count;
 865	out_data[i++] = 0x0;
 866	out_data[i++] = ni_usb_timeout_code(board->usec_timeout);
 867	for (j = 0; j < length; j++)
 868		out_data[i++] = buffer[j];
 869	while (i % 4)	// pad with zeros to 4-byte boundary
 870		out_data[i++] = 0x0;
 871	i += ni_usb_bulk_termination(&out_data[i]);
 872
 873	mutex_lock(&ni_priv->addressed_transfer_lock);
 874
 875	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written,
 876				      ni_usb_timeout_msecs(board->usec_timeout));
 877	kfree(out_data);
 878	if (retval || bytes_written != i) {
 879		mutex_unlock(&ni_priv->addressed_transfer_lock);
 880		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
 881			retval, bytes_written, i);
 882		return retval;
 883	}
 884
 885	in_data = kmalloc(in_data_length, GFP_KERNEL);
 886	if (!in_data) {
 887		mutex_unlock(&ni_priv->addressed_transfer_lock);
 888		return -ENOMEM;
 889	}
 890
 891	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read,
 892					 ni_usb_timeout_msecs(board->usec_timeout), 1);
 893
 894	mutex_unlock(&ni_priv->addressed_transfer_lock);
 895
 896	if ((retval && retval != -ERESTARTSYS) || bytes_read != 12) {
 897		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
 898			retval, bytes_read);
 899		kfree(in_data);
 900		return retval;
 901	}
 902	ni_usb_parse_status_block(in_data, &status);
 903	kfree(in_data);
 904	*command_bytes_written = length - status.count;
 905	switch (status.error_code) {
 906	case NIUSB_NO_ERROR:
 907		break;
 908	case NIUSB_ABORTED_ERROR:
 909		/*
 910		 * this is expected if ni_usb_receive_bulk_msg got
 911		 * interrupted by a signal and returned -ERESTARTSYS
 912		 */
 913		break;
 914	case NIUSB_NO_BUS_ERROR:
 915		return -ENOTCONN;
 916	case NIUSB_EOSMODE_ERROR:
 917		dev_err(&usb_dev->dev, "got eosmode error. Driver bug?\n");
 918		return -EIO;
 919	case NIUSB_TIMEOUT_ERROR:
 920		return -ETIMEDOUT;
 921	default:
 922		dev_err(&usb_dev->dev, "unknown error code=%i\n", status.error_code);
 923		return -EIO;
 924	}
 925	ni_usb_soft_update_status(board, status.ibsta, 0);
 926	return 0;
 927}
 928
 929static int ni_usb_command(struct gpib_board *board, u8 *buffer, size_t length,
 930			  size_t *bytes_written)
 931{
 932	size_t count;
 933	int retval;
 934
 935	*bytes_written = 0;
 936	while (*bytes_written < length) {
 937		retval = ni_usb_command_chunk(board, buffer + *bytes_written,
 938					      length - *bytes_written, &count);
 939		*bytes_written += count;
 940		if (retval < 0)
 941			return retval;
 942	}
 943	return 0;
 944}
 945
 946static int ni_usb_take_control(struct gpib_board *board, int synchronous)
 947{
 948	int retval;
 949	struct ni_usb_priv *ni_priv = board->private_data;
 950	struct usb_device *usb_dev;
 951	u8 *out_data, *in_data;
 952	static const int out_data_length = 0x10;
 953	static const int  in_data_length = 0x10;
 954	int bytes_written = 0, bytes_read = 0;
 955	int i = 0;
 956	struct ni_usb_status_block status;
 957
 958	if (!ni_priv->bus_interface)
 959		return -ENODEV;
 960	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
 961	out_data = kmalloc(out_data_length, GFP_KERNEL);
 962	if (!out_data)
 963		return -ENOMEM;
 964	out_data[i++] = NIUSB_IBCAC_ID;
 965	if (synchronous)
 966		out_data[i++] = 0x1;
 967	else
 968		out_data[i++] = 0x0;
 969	out_data[i++] = 0x0;
 970	out_data[i++] = 0x0;
 971	i += ni_usb_bulk_termination(&out_data[i]);
 972
 973	mutex_lock(&ni_priv->addressed_transfer_lock);
 974
 975	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000);
 976	kfree(out_data);
 977	if (retval || bytes_written != i) {
 978		mutex_unlock(&ni_priv->addressed_transfer_lock);
 979		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
 980			retval, bytes_written, i);
 981		return retval;
 982	}
 983
 984	in_data = kmalloc(in_data_length, GFP_KERNEL);
 985	if (!in_data) {
 986		mutex_unlock(&ni_priv->addressed_transfer_lock);
 987		return -ENOMEM;
 988	}
 989	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 1);
 990
 991	mutex_unlock(&ni_priv->addressed_transfer_lock);
 992
 993	if ((retval && retval != -ERESTARTSYS) || bytes_read != 12) {
 994		if (retval == 0)
 995			retval = -EIO;
 996		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
 997			retval, bytes_read);
 998		kfree(in_data);
 999		return retval;
1000	}
1001	ni_usb_parse_status_block(in_data, &status);
1002	kfree(in_data);
1003	ni_usb_soft_update_status(board, status.ibsta, 0);
1004	return retval;
1005}
1006
1007static int ni_usb_go_to_standby(struct gpib_board *board)
1008{
1009	int retval;
1010	struct ni_usb_priv *ni_priv = board->private_data;
1011	struct usb_device *usb_dev;
1012	u8 *out_data, *in_data;
1013	static const int out_data_length = 0x10;
1014	static const int  in_data_length = 0x20;
1015	int bytes_written = 0, bytes_read = 0;
1016	int i = 0;
1017	struct ni_usb_status_block status;
1018
1019	if (!ni_priv->bus_interface)
1020		return -ENODEV;
1021	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1022	out_data = kmalloc(out_data_length, GFP_KERNEL);
1023	if (!out_data)
1024		return -ENOMEM;
1025
1026	out_data[i++] = NIUSB_IBGTS_ID;
1027	out_data[i++] = 0x0;
1028	out_data[i++] = 0x0;
1029	out_data[i++] = 0x0;
1030	i += ni_usb_bulk_termination(&out_data[i]);
1031
1032	mutex_lock(&ni_priv->addressed_transfer_lock);
1033
1034	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000);
1035	kfree(out_data);
1036	if (retval || bytes_written != i) {
1037		mutex_unlock(&ni_priv->addressed_transfer_lock);
1038		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
1039			retval, bytes_written, i);
1040		return retval;
1041	}
1042
1043	in_data = kmalloc(in_data_length, GFP_KERNEL);
1044	if (!in_data) {
1045		mutex_unlock(&ni_priv->addressed_transfer_lock);
1046		return -ENOMEM;
1047	}
1048	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0);
1049
1050	mutex_unlock(&ni_priv->addressed_transfer_lock);
1051
1052	if (retval || bytes_read != 12) {
1053		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
1054			retval, bytes_read);
1055		kfree(in_data);
1056		return retval;
1057	}
1058	ni_usb_parse_status_block(in_data, &status);
1059	kfree(in_data);
1060	if (status.id != NIUSB_IBGTS_ID)
1061		dev_err(&usb_dev->dev, "bug: status.id 0x%x != INUSB_IBGTS_ID\n", status.id);
1062	ni_usb_soft_update_status(board, status.ibsta, 0);
1063	return 0;
1064}
1065
1066static int ni_usb_request_system_control(struct gpib_board *board, int request_control)
1067{
1068	int retval;
1069	struct ni_usb_priv *ni_priv = board->private_data;
1070	struct usb_device *usb_dev;
1071	int i = 0;
1072	struct ni_usb_register writes[4];
1073	unsigned int ibsta;
1074
1075	if (!ni_priv->bus_interface)
1076		return -ENODEV;
1077	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1078	if (request_control) {
1079		writes[i].device = NIUSB_SUBDEV_TNT4882;
1080		writes[i].address = CMDR;
1081		writes[i].value = SETSC;
1082		i++;
1083		writes[i].device = NIUSB_SUBDEV_TNT4882;
1084		writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1085		writes[i].value = AUX_CIFC;
1086		i++;
1087	} else {
1088		writes[i].device = NIUSB_SUBDEV_TNT4882;
1089		writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1090		writes[i].value = AUX_CREN;
1091		i++;
1092		writes[i].device = NIUSB_SUBDEV_TNT4882;
1093		writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1094		writes[i].value = AUX_CIFC;
1095		i++;
1096		writes[i].device = NIUSB_SUBDEV_TNT4882;
1097		writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1098		writes[i].value = AUX_DSC;
1099		i++;
1100		writes[i].device = NIUSB_SUBDEV_TNT4882;
1101		writes[i].address = CMDR;
1102		writes[i].value = CLRSC;
1103		i++;
1104	}
1105	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1106	if (retval < 0) {
1107		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1108		return retval;
1109	}
1110	if (!request_control)
1111		ni_priv->ren_state = 0;
1112	ni_usb_soft_update_status(board, ibsta, 0);
1113	return 0;
1114}
1115
1116// FIXME maybe the interface should have a "pulse interface clear" function that can return an error?
1117static void ni_usb_interface_clear(struct gpib_board *board, int assert)
1118{
1119	int retval;
1120	struct ni_usb_priv *ni_priv = board->private_data;
1121	struct usb_device *usb_dev;
1122	u8 *out_data, *in_data;
1123	static const int out_data_length = 0x10;
1124	static const int  in_data_length = 0x10;
1125	int bytes_written = 0, bytes_read = 0;
1126	int i = 0;
1127	struct ni_usb_status_block status;
1128
1129	if (!ni_priv->bus_interface)
1130		return; // -ENODEV;
1131	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1132// FIXME: we are going to pulse when assert is true, and ignore otherwise
1133	if (assert == 0)
1134		return;
1135	out_data = kmalloc(out_data_length, GFP_KERNEL);
1136	if (!out_data)
1137		return;
1138	out_data[i++] = NIUSB_IBSIC_ID;
1139	out_data[i++] = 0x0;
1140	out_data[i++] = 0x0;
1141	out_data[i++] = 0x0;
1142	i += ni_usb_bulk_termination(&out_data[i]);
1143	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000);
1144	kfree(out_data);
1145	if (retval || bytes_written != i) {
1146		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
1147			retval, bytes_written, i);
1148		return;
1149	}
1150	in_data = kmalloc(in_data_length, GFP_KERNEL);
1151	if (!in_data)
1152		return;
1153
1154	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0);
1155	if (retval || bytes_read != 12) {
1156		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
1157			retval, bytes_read);
1158		kfree(in_data);
1159		return;
1160	}
1161	ni_usb_parse_status_block(in_data, &status);
1162	kfree(in_data);
1163	ni_usb_soft_update_status(board, status.ibsta, 0);
1164}
1165
1166static void ni_usb_remote_enable(struct gpib_board *board, int enable)
1167{
1168	int retval;
1169	struct ni_usb_priv *ni_priv = board->private_data;
1170	struct usb_device *usb_dev;
1171	struct ni_usb_register reg;
1172	unsigned int ibsta;
1173
1174	if (!ni_priv->bus_interface)
1175		return; // -ENODEV;
1176	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1177	reg.device = NIUSB_SUBDEV_TNT4882;
1178	reg.address = nec7210_to_tnt4882_offset(AUXMR);
1179	if (enable)
1180		reg.value = AUX_SREN;
1181	else
1182		reg.value = AUX_CREN;
1183	retval = ni_usb_write_registers(ni_priv, &reg, 1, &ibsta);
1184	if (retval < 0) {
1185		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1186		return; //retval;
1187	}
1188	ni_priv->ren_state = enable;
1189	ni_usb_soft_update_status(board, ibsta, 0);
1190	return;// 0;
1191}
1192
1193static int ni_usb_enable_eos(struct gpib_board *board, u8 eos_byte, int compare_8_bits)
1194{
1195	struct ni_usb_priv *ni_priv = board->private_data;
1196
1197	ni_priv->eos_char = eos_byte;
1198	ni_priv->eos_mode |= REOS;
1199	if (compare_8_bits)
1200		ni_priv->eos_mode |= BIN;
1201	else
1202		ni_priv->eos_mode &= ~BIN;
1203	return 0;
1204}
1205
1206static void ni_usb_disable_eos(struct gpib_board *board)
1207{
1208	struct ni_usb_priv *ni_priv = board->private_data;
1209	/*
1210	 * adapter gets unhappy if you don't zero all the bits
1211	 * for the eos mode and eos char (returns error 4 on reads).
1212	 */
1213	ni_priv->eos_mode = 0;
1214	ni_priv->eos_char = 0;
1215}
1216
1217static unsigned int ni_usb_update_status(struct gpib_board *board, unsigned int clear_mask)
1218{
1219	int retval;
1220	struct ni_usb_priv *ni_priv = board->private_data;
1221	struct usb_device *usb_dev;
1222	static const int buffer_length = 8;
1223	u8 *buffer;
1224	struct ni_usb_status_block status;
1225
1226	if (!ni_priv->bus_interface)
1227		return -ENODEV;
1228	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1229	buffer = kmalloc(buffer_length, GFP_KERNEL);
1230	if (!buffer)
1231		return board->status;
1232
1233	retval = ni_usb_receive_control_msg(ni_priv, NI_USB_WAIT_REQUEST, USB_DIR_IN |
1234					    USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1235					    0x200, 0x0, buffer, buffer_length, 1000);
1236	if (retval != buffer_length) {
1237		dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval);
1238		kfree(buffer);
1239		return board->status;
1240	}
1241	ni_usb_parse_status_block(buffer, &status);
1242	kfree(buffer);
1243	ni_usb_soft_update_status(board, status.ibsta, clear_mask);
1244	return board->status;
1245}
1246
1247// tells ni-usb to immediately stop an ongoing i/o operation
1248static void ni_usb_stop(struct ni_usb_priv *ni_priv)
1249{
1250	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1251	int retval;
1252	static const int buffer_length = 8;
1253	u8 *buffer;
1254	struct ni_usb_status_block status;
1255
1256	buffer = kmalloc(buffer_length, GFP_KERNEL);
1257	if (!buffer)
1258		return;
1259
1260	retval = ni_usb_receive_control_msg(ni_priv, NI_USB_STOP_REQUEST, USB_DIR_IN |
1261					    USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1262					    0x0, 0x0, buffer, buffer_length, 1000);
1263	if (retval != buffer_length) {
1264		dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval);
1265		kfree(buffer);
1266		return;
1267	}
1268	ni_usb_parse_status_block(buffer, &status);
1269	kfree(buffer);
1270}
1271
1272static int ni_usb_primary_address(struct gpib_board *board, unsigned int address)
1273{
1274	int retval;
1275	struct ni_usb_priv *ni_priv = board->private_data;
1276	struct usb_device *usb_dev;
1277	int i = 0;
1278	struct ni_usb_register writes[2];
1279	unsigned int ibsta;
1280
1281	if (!ni_priv->bus_interface)
1282		return -ENODEV;
1283	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1284	writes[i].device = NIUSB_SUBDEV_TNT4882;
1285	writes[i].address = nec7210_to_tnt4882_offset(ADR);
1286	writes[i].value = address;
1287	i++;
1288	writes[i].device = NIUSB_SUBDEV_UNKNOWN2;
1289	writes[i].address = 0x0;
1290	writes[i].value = address;
1291	i++;
1292	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1293	if (retval < 0) {
1294		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1295		return retval;
1296	}
1297	ni_usb_soft_update_status(board, ibsta, 0);
1298	return 0;
1299}
1300
1301static int ni_usb_write_sad(struct ni_usb_register *writes, int address, int enable)
1302{
1303	unsigned int adr_bits, admr_bits;
1304	int i = 0;
1305
1306	adr_bits = HR_ARS;
1307	admr_bits = HR_TRM0 | HR_TRM1;
1308	if (enable) {
1309		adr_bits |= address;
1310		admr_bits |= HR_ADM1;
1311	} else {
1312		adr_bits |= HR_DT | HR_DL;
1313		admr_bits |= HR_ADM0;
1314	}
1315	writes[i].device = NIUSB_SUBDEV_TNT4882;
1316	writes[i].address = nec7210_to_tnt4882_offset(ADR);
1317	writes[i].value = adr_bits;
1318	i++;
1319	writes[i].device = NIUSB_SUBDEV_TNT4882;
1320	writes[i].address = nec7210_to_tnt4882_offset(ADMR);
1321	writes[i].value = admr_bits;
1322	i++;
1323	writes[i].device = NIUSB_SUBDEV_UNKNOWN2;
1324	writes[i].address = 0x1;
1325	writes[i].value = enable ? MSA(address) : 0x0;
1326	i++;
1327	return i;
1328}
1329
1330static int ni_usb_secondary_address(struct gpib_board *board, unsigned int address, int enable)
1331{
1332	int retval;
1333	struct ni_usb_priv *ni_priv = board->private_data;
1334	struct usb_device *usb_dev;
1335	int i = 0;
1336	struct ni_usb_register writes[3];
1337	unsigned int ibsta;
1338
1339	if (!ni_priv->bus_interface)
1340		return -ENODEV;
1341	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1342	i += ni_usb_write_sad(writes, address, enable);
1343	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1344	if (retval < 0) {
1345		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1346		return retval;
1347	}
1348	ni_usb_soft_update_status(board, ibsta, 0);
1349	return 0;
1350}
1351
1352static int ni_usb_parallel_poll(struct gpib_board *board, u8 *result)
1353{
1354	int retval;
1355	struct ni_usb_priv *ni_priv = board->private_data;
1356	struct usb_device *usb_dev;
1357	u8 *out_data, *in_data;
1358	static const int out_data_length = 0x10;
1359	static const int  in_data_length = 0x20;
1360	int bytes_written = 0, bytes_read = 0;
1361	int i = 0;
1362	int j = 0;
1363	struct ni_usb_status_block status;
1364
1365	if (!ni_priv->bus_interface)
1366		return -ENODEV;
1367	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1368	out_data = kmalloc(out_data_length, GFP_KERNEL);
1369	if (!out_data)
1370		return -ENOMEM;
1371
1372	out_data[i++] = NIUSB_IBRPP_ID;
1373	out_data[i++] = 0xf0;	// FIXME: this should be the parallel poll timeout code
1374	out_data[i++] = 0x0;
1375	out_data[i++] = 0x0;
1376	i += ni_usb_bulk_termination(&out_data[i]);
1377	/*FIXME: 1000 should use parallel poll timeout (not supported yet)*/
1378	retval = ni_usb_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000);
1379
1380	kfree(out_data);
1381	if (retval || bytes_written != i) {
1382		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
1383			retval, bytes_written, i);
1384		return retval;
1385	}
1386	in_data = kmalloc(in_data_length, GFP_KERNEL);
1387	if (!in_data)
1388		return -ENOMEM;
1389
1390	/*FIXME: should use parallel poll timeout (not supported yet)*/
1391	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length,
1392					 &bytes_read, 1000, 1);
1393
1394	if (retval && retval != -ERESTARTSYS)	{
1395		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
1396			retval, bytes_read);
1397		kfree(in_data);
1398		return retval;
1399	}
1400	j += ni_usb_parse_status_block(in_data, &status);
1401	*result = in_data[j++];
1402	kfree(in_data);
1403	ni_usb_soft_update_status(board, status.ibsta, 0);
1404	return retval;
1405}
1406
1407static void ni_usb_parallel_poll_configure(struct gpib_board *board, u8 config)
1408{
1409	int retval;
1410	struct ni_usb_priv *ni_priv = board->private_data;
1411	struct usb_device *usb_dev;
1412	int i = 0;
1413	struct ni_usb_register writes[1];
1414	unsigned int ibsta;
1415
1416	if (!ni_priv->bus_interface)
1417		return; // -ENODEV;
1418	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1419	writes[i].device = NIUSB_SUBDEV_TNT4882;
1420	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1421	writes[i].value = PPR | config;
1422	i++;
1423	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1424	if (retval < 0) {
1425		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1426		return;// retval;
1427	}
1428	ni_usb_soft_update_status(board, ibsta, 0);
1429	return;// 0;
1430}
1431
1432static void ni_usb_parallel_poll_response(struct gpib_board *board, int ist)
1433{
1434	int retval;
1435	struct ni_usb_priv *ni_priv = board->private_data;
1436	struct usb_device *usb_dev;
1437	int i = 0;
1438	struct ni_usb_register writes[1];
1439	unsigned int ibsta;
1440
1441	if (!ni_priv->bus_interface)
1442		return; // -ENODEV;
1443	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1444	writes[i].device = NIUSB_SUBDEV_TNT4882;
1445	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1446	if (ist)
1447		writes[i].value = AUX_SPPF;
1448	else
1449		writes[i].value = AUX_CPPF;
1450	i++;
1451	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1452	if (retval < 0) {
1453		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1454		return;// retval;
1455	}
1456	ni_usb_soft_update_status(board, ibsta, 0);
1457	return;// 0;
1458}
1459
1460static void ni_usb_serial_poll_response(struct gpib_board *board, u8 status)
1461{
1462	int retval;
1463	struct ni_usb_priv *ni_priv = board->private_data;
1464	struct usb_device *usb_dev;
1465	int i = 0;
1466	struct ni_usb_register writes[1];
1467	unsigned int ibsta;
1468
1469	if (!ni_priv->bus_interface)
1470		return; // -ENODEV;
1471	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1472	writes[i].device = NIUSB_SUBDEV_TNT4882;
1473	writes[i].address = nec7210_to_tnt4882_offset(SPMR);
1474	writes[i].value = status;
1475	i++;
1476	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1477	if (retval < 0) {
1478		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1479		return;// retval;
1480	}
1481	ni_usb_soft_update_status(board, ibsta, 0);
1482	return;// 0;
1483}
1484
1485static u8 ni_usb_serial_poll_status(struct gpib_board *board)
1486{
1487	return 0;
1488}
1489
1490static void ni_usb_return_to_local(struct gpib_board *board)
1491{
1492	int retval;
1493	struct ni_usb_priv *ni_priv = board->private_data;
1494	struct usb_device *usb_dev;
1495	int i = 0;
1496	struct ni_usb_register writes[1];
1497	unsigned int ibsta;
1498
1499	if (!ni_priv->bus_interface)
1500		return; // -ENODEV;
1501	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1502	writes[i].device = NIUSB_SUBDEV_TNT4882;
1503	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1504	writes[i].value = AUX_RTL;
1505	i++;
1506	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1507	if (retval < 0) {
1508		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1509		return;// retval;
1510	}
1511	ni_usb_soft_update_status(board, ibsta, 0);
1512	return;// 0;
1513}
1514
1515static int ni_usb_line_status(const struct gpib_board *board)
1516{
1517	int retval;
1518	struct ni_usb_priv *ni_priv = board->private_data;
1519	struct usb_device *usb_dev;
1520	u8 *out_data, *in_data;
1521	static const int out_data_length = 0x20;
1522	static const int  in_data_length = 0x20;
1523	int bytes_written = 0, bytes_read = 0;
1524	int i = 0;
1525	unsigned int bsr_bits;
1526	int line_status = VALID_ALL;
1527	// NI windows driver reads 0xd(HSSEL), 0xc (ARD0), 0x1f (BSR)
1528
1529	if (!ni_priv->bus_interface)
1530		return -ENODEV;
1531	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1532	out_data = kmalloc(out_data_length, GFP_KERNEL);
1533	if (!out_data)
1534		return -ENOMEM;
1535
1536	/* line status gets called during ibwait */
1537	retval = mutex_trylock(&ni_priv->addressed_transfer_lock);
1538
1539	if (retval == 0) {
1540		kfree(out_data);
1541		return -EBUSY;
1542	}
1543	i += ni_usb_bulk_register_read_header(&out_data[i], 1);
1544	i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_TNT4882, BSR);
1545	while (i % 4)
1546		out_data[i++] = 0x0;
1547	i += ni_usb_bulk_termination(&out_data[i]);
1548	retval = ni_usb_nonblocking_send_bulk_msg(ni_priv, out_data, i, &bytes_written, 1000);
1549	kfree(out_data);
1550	if (retval || bytes_written != i) {
1551		mutex_unlock(&ni_priv->addressed_transfer_lock);
1552		if (retval != -EAGAIN)
1553			dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%i\n",
1554				retval, bytes_written, i);
1555		return retval;
1556	}
1557
1558	in_data = kmalloc(in_data_length, GFP_KERNEL);
1559	if (!in_data) {
1560		mutex_unlock(&ni_priv->addressed_transfer_lock);
1561		return -ENOMEM;
1562	}
1563	retval = ni_usb_nonblocking_receive_bulk_msg(ni_priv, in_data, in_data_length,
1564						     &bytes_read, 1000, 0);
1565
1566	mutex_unlock(&ni_priv->addressed_transfer_lock);
1567
1568	if (retval) {
1569		if (retval != -EAGAIN)
1570			dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
1571				retval, bytes_read);
1572		kfree(in_data);
1573		return retval;
1574	}
1575
1576	ni_usb_parse_register_read_block(in_data, &bsr_bits, 1);
1577	kfree(in_data);
1578	if (bsr_bits & BCSR_REN_BIT)
1579		line_status |= BUS_REN;
1580	if (bsr_bits & BCSR_IFC_BIT)
1581		line_status |= BUS_IFC;
1582	if (bsr_bits & BCSR_SRQ_BIT)
1583		line_status |= BUS_SRQ;
1584	if (bsr_bits & BCSR_EOI_BIT)
1585		line_status |= BUS_EOI;
1586	if (bsr_bits & BCSR_NRFD_BIT)
1587		line_status |= BUS_NRFD;
1588	if (bsr_bits & BCSR_NDAC_BIT)
1589		line_status |= BUS_NDAC;
1590	if (bsr_bits & BCSR_DAV_BIT)
1591		line_status |= BUS_DAV;
1592	if (bsr_bits & BCSR_ATN_BIT)
1593		line_status |= BUS_ATN;
1594	return line_status;
1595}
1596
1597static int ni_usb_setup_t1_delay(struct ni_usb_register *reg, unsigned int nano_sec,
1598				 unsigned int *actual_ns)
1599{
1600	int i = 0;
1601
1602	*actual_ns = 2000;
1603
1604	reg[i].device = NIUSB_SUBDEV_TNT4882;
1605	reg[i].address = nec7210_to_tnt4882_offset(AUXMR);
1606	if (nano_sec <= 1100)	{
1607		reg[i].value = AUXRI | USTD | SISB;
1608		*actual_ns = 1100;
1609	} else {
1610		reg[i].value = AUXRI | SISB;
1611	}
1612	i++;
1613	reg[i].device = NIUSB_SUBDEV_TNT4882;
1614	reg[i].address = nec7210_to_tnt4882_offset(AUXMR);
1615	if (nano_sec <= 500)	{
1616		reg[i].value = AUXRB | HR_TRI;
1617		*actual_ns = 500;
1618	} else {
1619		reg[i].value = AUXRB;
1620	}
1621	i++;
1622	reg[i].device = NIUSB_SUBDEV_TNT4882;
1623	reg[i].address = KEYREG;
1624	if (nano_sec <= 350) {
1625		reg[i].value = MSTD;
1626		*actual_ns = 350;
1627	} else {
1628		reg[i].value = 0x0;
1629	}
1630	i++;
1631	return i;
1632}
1633
1634static int ni_usb_t1_delay(struct gpib_board *board, unsigned int nano_sec)
1635{
1636	int retval;
1637	struct ni_usb_priv *ni_priv = board->private_data;
1638	struct usb_device *usb_dev;
1639	struct ni_usb_register writes[3];
1640	unsigned int ibsta;
1641	unsigned int actual_ns;
1642	int i;
1643
1644	if (!ni_priv->bus_interface)
1645		return -ENODEV;
1646	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1647	i = ni_usb_setup_t1_delay(writes, nano_sec, &actual_ns);
1648	retval = ni_usb_write_registers(ni_priv, writes, i, &ibsta);
1649	if (retval < 0) {
1650		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1651		return retval;
1652	}
1653	board->t1_nano_sec = actual_ns;
1654	ni_usb_soft_update_status(board, ibsta, 0);
1655	return actual_ns;
1656}
1657
1658static int ni_usb_allocate_private(struct gpib_board *board)
1659{
1660	struct ni_usb_priv *ni_priv;
1661
1662	board->private_data = kmalloc(sizeof(struct ni_usb_priv), GFP_KERNEL);
1663	if (!board->private_data)
1664		return -ENOMEM;
1665	ni_priv = board->private_data;
1666	memset(ni_priv, 0, sizeof(struct ni_usb_priv));
1667	mutex_init(&ni_priv->bulk_transfer_lock);
1668	mutex_init(&ni_priv->control_transfer_lock);
1669	mutex_init(&ni_priv->interrupt_transfer_lock);
1670	mutex_init(&ni_priv->addressed_transfer_lock);
1671	return 0;
1672}
1673
1674static void ni_usb_free_private(struct ni_usb_priv *ni_priv)
1675{
1676	usb_free_urb(ni_priv->interrupt_urb);
1677	kfree(ni_priv);
1678}
1679
1680#define NUM_INIT_WRITES 26
1681static int ni_usb_setup_init(struct gpib_board *board, struct ni_usb_register *writes)
1682{
1683	struct ni_usb_priv *ni_priv = board->private_data;
1684	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1685	unsigned int mask, actual_ns;
1686	int i = 0;
1687
1688	writes[i].device = NIUSB_SUBDEV_UNKNOWN3;
1689	writes[i].address = 0x10;
1690	writes[i].value = 0x0;
1691	i++;
1692	writes[i].device = NIUSB_SUBDEV_TNT4882;
1693	writes[i].address = CMDR;
1694	writes[i].value = SOFT_RESET;
1695	i++;
1696	writes[i].device =  NIUSB_SUBDEV_TNT4882;
1697	writes[i].address =  nec7210_to_tnt4882_offset(AUXMR);
1698	mask = AUXRA | HR_HLDA;
1699	if (ni_priv->eos_mode & BIN)
1700		mask |= HR_BIN;
1701	writes[i].value = mask;
1702	i++;
1703	writes[i].device = NIUSB_SUBDEV_TNT4882;
1704	writes[i].address = AUXCR;
1705	writes[i].value = mask;
1706	i++;
1707	writes[i].device = NIUSB_SUBDEV_TNT4882;
1708	writes[i].address = HSSEL;
1709	writes[i].value = TNT_ONE_CHIP_BIT;
1710	i++;
1711	writes[i].device = NIUSB_SUBDEV_TNT4882;
1712	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1713	writes[i].value = AUX_CR;
1714	i++;
1715	writes[i].device = NIUSB_SUBDEV_TNT4882;
1716	writes[i].address = IMR0;
1717	writes[i].value = TNT_IMR0_ALWAYS_BITS;
1718	i++;
1719	writes[i].device = NIUSB_SUBDEV_TNT4882;
1720	writes[i].address = nec7210_to_tnt4882_offset(IMR1);
1721	writes[i].value = 0x0;
1722	i++;
1723	writes[i].device = NIUSB_SUBDEV_TNT4882;
1724	writes[i].address =  nec7210_to_tnt4882_offset(IMR2);
1725	writes[i].value = 0x0;
1726	i++;
1727	writes[i].device = NIUSB_SUBDEV_TNT4882;
1728	writes[i].address = IMR3;
1729	writes[i].value = 0x0;
1730	i++;
1731	writes[i].device = NIUSB_SUBDEV_TNT4882;
1732	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1733	writes[i].value = AUX_HLDI;
1734	i++;
1735
1736	i += ni_usb_setup_t1_delay(&writes[i], board->t1_nano_sec, &actual_ns);
1737
1738	writes[i].device = NIUSB_SUBDEV_TNT4882;
1739	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1740	writes[i].value = AUXRG | NTNL_BIT;
1741	i++;
1742	writes[i].device = NIUSB_SUBDEV_TNT4882;
1743	writes[i].address = CMDR;
1744	if (board->master)
1745		mask = SETSC; // set system controller
1746	else
1747		mask = CLRSC; // clear system controller
1748	writes[i].value = mask;
1749	i++;
1750	writes[i].device = NIUSB_SUBDEV_TNT4882;
1751	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1752	writes[i].value = AUX_CIFC;
1753	i++;
1754	writes[i].device = NIUSB_SUBDEV_TNT4882;
1755	writes[i].address = nec7210_to_tnt4882_offset(ADR);
1756	writes[i].value = board->pad;
1757	i++;
1758	writes[i].device = NIUSB_SUBDEV_UNKNOWN2;
1759	writes[i].address = 0x0;
1760	writes[i].value = board->pad;
1761	i++;
1762
1763	i += ni_usb_write_sad(&writes[i], board->sad, board->sad >= 0);
1764
1765	writes[i].device = NIUSB_SUBDEV_UNKNOWN2;
1766	writes[i].address = 0x2; // could this be a timeout ?
1767	writes[i].value = 0xfd;
1768	i++;
1769	writes[i].device = NIUSB_SUBDEV_TNT4882;
1770	writes[i].address = 0xf; // undocumented address
1771	writes[i].value = 0x11;
1772	i++;
1773	writes[i].device = NIUSB_SUBDEV_TNT4882;
1774	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1775	writes[i].value = AUX_PON;
1776	i++;
1777	writes[i].device = NIUSB_SUBDEV_TNT4882;
1778	writes[i].address = nec7210_to_tnt4882_offset(AUXMR);
1779	writes[i].value = AUX_CPPF;
1780	i++;
1781	if (i > NUM_INIT_WRITES) {
1782		dev_err(&usb_dev->dev, "bug!, buffer overrun, i=%i\n", i);
1783		return -EINVAL;
1784	}
1785	return i;
1786}
1787
1788static int ni_usb_init(struct gpib_board *board)
1789{
1790	int retval;
1791	struct ni_usb_priv *ni_priv = board->private_data;
1792	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1793	struct ni_usb_register *writes;
1794	unsigned int ibsta;
1795	int writes_len;
1796
1797	writes = kmalloc_array(NUM_INIT_WRITES, sizeof(*writes), GFP_KERNEL);
1798	if (!writes)
1799		return -ENOMEM;
1800
1801	writes_len = ni_usb_setup_init(board, writes);
1802	if (writes_len < 0) {
1803		kfree(writes);
1804		return writes_len;
1805	}
1806
1807	retval = ni_usb_write_registers(ni_priv, writes, writes_len, &ibsta);
1808	kfree(writes);
1809	if (retval) {
1810		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
1811		return retval;
1812	}
1813	ni_usb_soft_update_status(board, ibsta, 0);
1814	return 0;
1815}
1816
1817static void ni_usb_interrupt_complete(struct urb *urb)
1818{
1819	struct gpib_board *board = urb->context;
1820	struct ni_usb_priv *ni_priv = board->private_data;
1821	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1822	int retval;
1823	struct ni_usb_status_block status;
1824	unsigned long flags;
1825
1826	switch (urb->status) {
1827		/* success */
1828	case 0:
1829		break;
1830		/* unlinked, don't resubmit */
1831	case -ECONNRESET:
1832	case -ENOENT:
1833	case -ESHUTDOWN:
1834		return;
1835	default: /* other error, resubmit */
1836		retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_ATOMIC);
1837		if (retval)
1838			dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n");
1839		return;
1840	}
1841
1842	ni_usb_parse_status_block(urb->transfer_buffer, &status);
1843
1844	spin_lock_irqsave(&board->spinlock, flags);
1845	ni_priv->monitored_ibsta_bits &= ~status.ibsta;
1846	spin_unlock_irqrestore(&board->spinlock, flags);
1847
1848	wake_up_interruptible(&board->wait);
1849
1850	retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_ATOMIC);
1851	if (retval)
1852		dev_err(&usb_dev->dev, "failed to resubmit interrupt urb\n");
1853}
1854
1855static int ni_usb_set_interrupt_monitor(struct gpib_board *board, unsigned int monitored_bits)
1856{
1857	int retval;
1858	struct ni_usb_priv *ni_priv = board->private_data;
1859	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1860	static const int buffer_length = 8;
1861	u8 *buffer;
1862	struct ni_usb_status_block status;
1863	unsigned long flags;
1864
1865	buffer = kmalloc(buffer_length, GFP_KERNEL);
1866	if (!buffer)
1867		return -ENOMEM;
1868
1869	spin_lock_irqsave(&board->spinlock, flags);
1870	ni_priv->monitored_ibsta_bits = ni_usb_ibsta_monitor_mask & monitored_bits;
1871	spin_unlock_irqrestore(&board->spinlock, flags);
1872	retval = ni_usb_receive_control_msg(ni_priv, NI_USB_WAIT_REQUEST, USB_DIR_IN |
1873					    USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1874					    0x300, ni_usb_ibsta_monitor_mask & monitored_bits,
1875					    buffer, buffer_length, 1000);
1876	if (retval != buffer_length) {
1877		dev_err(&usb_dev->dev, "usb_control_msg returned %i\n", retval);
1878		kfree(buffer);
1879		return -1;
1880	}
1881	ni_usb_parse_status_block(buffer, &status);
1882	kfree(buffer);
1883	return 0;
1884}
1885
1886static int ni_usb_setup_urbs(struct gpib_board *board)
1887{
1888	struct ni_usb_priv *ni_priv = board->private_data;
1889	struct usb_device *usb_dev;
1890	int int_pipe;
1891	int retval;
1892
1893	if (ni_priv->interrupt_in_endpoint < 0)
1894		return 0;
1895
1896	mutex_lock(&ni_priv->interrupt_transfer_lock);
1897	if (!ni_priv->bus_interface) {
1898		mutex_unlock(&ni_priv->interrupt_transfer_lock);
1899		return -ENODEV;
1900	}
1901	ni_priv->interrupt_urb = usb_alloc_urb(0, GFP_KERNEL);
1902	if (!ni_priv->interrupt_urb) {
1903		mutex_unlock(&ni_priv->interrupt_transfer_lock);
1904		return -ENOMEM;
1905	}
1906	usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1907	int_pipe = usb_rcvintpipe(usb_dev, ni_priv->interrupt_in_endpoint);
1908	usb_fill_int_urb(ni_priv->interrupt_urb, usb_dev, int_pipe, ni_priv->interrupt_buffer,
1909			 sizeof(ni_priv->interrupt_buffer), &ni_usb_interrupt_complete, board, 1);
1910	retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_KERNEL);
1911	mutex_unlock(&ni_priv->interrupt_transfer_lock);
1912	if (retval) {
1913		dev_err(&usb_dev->dev, "failed to submit first interrupt urb, retval=%i\n", retval);
1914		return retval;
1915	}
1916	return 0;
1917}
1918
1919static void ni_usb_cleanup_urbs(struct ni_usb_priv *ni_priv)
1920{
1921	if (ni_priv && ni_priv->bus_interface) {
1922		if (ni_priv->interrupt_urb)
1923			usb_kill_urb(ni_priv->interrupt_urb);
1924		if (ni_priv->bulk_urb)
1925			usb_kill_urb(ni_priv->bulk_urb);
1926	}
1927}
1928
1929static int ni_usb_b_read_serial_number(struct ni_usb_priv *ni_priv)
1930{
1931	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1932	int retval;
1933	u8 *out_data;
1934	u8 *in_data;
1935	static const int out_data_length = 0x20;
1936	static const int  in_data_length = 0x20;
1937	int bytes_written = 0, bytes_read = 0;
1938	int i = 0;
1939	static const int num_reads = 4;
1940	unsigned int results[4];
1941	int j;
1942	unsigned int serial_number;
1943
1944	in_data = kmalloc(in_data_length, GFP_KERNEL);
1945	if (!in_data)
1946		return -ENOMEM;
1947
1948	out_data = kmalloc(out_data_length, GFP_KERNEL);
1949	if (!out_data) {
1950		kfree(in_data);
1951		return -ENOMEM;
1952	}
1953	i += ni_usb_bulk_register_read_header(&out_data[i], num_reads);
1954	i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_1_REG);
1955	i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_2_REG);
1956	i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_3_REG);
1957	i += ni_usb_bulk_register_read(&out_data[i], NIUSB_SUBDEV_UNKNOWN3, SERIAL_NUMBER_4_REG);
1958	while (i % 4)
1959		out_data[i++] = 0x0;
1960	i += ni_usb_bulk_termination(&out_data[i]);
1961	retval = ni_usb_send_bulk_msg(ni_priv, out_data, out_data_length, &bytes_written, 1000);
1962	if (retval) {
1963		dev_err(&usb_dev->dev, "send_bulk_msg returned %i, bytes_written=%i, i=%li\n",
1964			retval, bytes_written, (long)out_data_length);
1965		goto serial_out;
1966	}
1967	retval = ni_usb_receive_bulk_msg(ni_priv, in_data, in_data_length, &bytes_read, 1000, 0);
1968	if (retval) {
1969		dev_err(&usb_dev->dev, "receive_bulk_msg returned %i, bytes_read=%i\n",
1970			retval, bytes_read);
1971		ni_usb_dump_raw_block(in_data, bytes_read);
1972		goto serial_out;
1973	}
1974	if (ARRAY_SIZE(results) < num_reads) {
1975		dev_err(&usb_dev->dev, "serial number eetup bug\n");
1976		retval = -EINVAL;
1977		goto serial_out;
1978	}
1979	ni_usb_parse_register_read_block(in_data, results, num_reads);
1980	serial_number = 0;
1981	for (j = 0; j < num_reads; ++j)
1982		serial_number |= (results[j] & 0xff) << (8 * j);
1983	dev_dbg(&usb_dev->dev, "board serial number is 0x%x\n", serial_number);
1984	retval = 0;
1985serial_out:
1986	kfree(in_data);
1987	kfree(out_data);
1988	return retval;
1989}
1990
1991static int ni_usb_hs_wait_for_ready(struct ni_usb_priv *ni_priv)
1992{
1993	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
1994	static const int buffer_size = 0x10;
1995	static const int timeout = 50;
1996	static const int msec_sleep_duration = 100;
1997	int i;	int retval;
1998	int j;
1999	int unexpected = 0;
2000	unsigned int serial_number;
2001	u8 *buffer;
2002
2003	buffer = kmalloc(buffer_size, GFP_KERNEL);
2004	if (!buffer)
2005		return -ENOMEM;
2006
2007	retval = ni_usb_receive_control_msg(ni_priv, NI_USB_SERIAL_NUMBER_REQUEST,
2008					    USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2009					    0x0, 0x0, buffer, buffer_size, 1000);
2010	if (retval < 0) {
2011		dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n",
2012			NI_USB_SERIAL_NUMBER_REQUEST, retval);
2013		goto ready_out;
2014	}
2015	j = 0;
2016	if (buffer[j] != NI_USB_SERIAL_NUMBER_REQUEST) {
2017		dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n",
2018			j, (int)buffer[j], NI_USB_SERIAL_NUMBER_REQUEST);
2019		unexpected = 1;
2020	}
2021	if (unexpected)
2022		ni_usb_dump_raw_block(buffer, retval);
2023	// NI-USB-HS+ pads the serial with 0x0 to make 16 bytes
2024	if (retval != 5 && retval != 16) {
2025		dev_err(&usb_dev->dev, "received unexpected number of bytes = %i, expected 5 or 16\n",
2026			retval);
2027		ni_usb_dump_raw_block(buffer, retval);
2028	}
2029	serial_number = 0;
2030	serial_number |= buffer[++j];
2031	serial_number |= (buffer[++j] << 8);
2032	serial_number |= (buffer[++j] << 16);
2033	serial_number |= (buffer[++j] << 24);
2034	dev_dbg(&usb_dev->dev, "board serial number is 0x%x\n", serial_number);
2035	for (i = 0; i < timeout; ++i) {
2036		int ready = 0;
2037
2038		retval = ni_usb_receive_control_msg(ni_priv, NI_USB_POLL_READY_REQUEST,
2039						    USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2040						    0x0, 0x0, buffer, buffer_size, 100);
2041		if (retval < 0) {
2042			dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n",
2043				NI_USB_POLL_READY_REQUEST, retval);
2044			goto ready_out;
2045		}
2046		j = 0;
2047		unexpected = 0;
2048		if (buffer[j] != NI_USB_POLL_READY_REQUEST) { // [0]
2049			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n",
2050				j, (int)buffer[j], NI_USB_POLL_READY_REQUEST);
2051			unexpected = 1;
2052		}
2053		++j;
2054		if (buffer[j] != 0x1 && buffer[j] != 0x0) { // [1] HS+ sends 0x0
2055			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n",
2056				j, (int)buffer[j]);
2057			unexpected = 1;
2058		}
2059		if (buffer[++j] != 0x0) { // [2]
2060			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x%x\n",
2061				j, (int)buffer[j], 0x0);
2062			unexpected = 1;
2063		}
2064		++j;
2065		/*
2066		 * MC usb-488 (and sometimes NI-USB-HS?) sends 0x8 here; MC usb-488A sends 0x7 here
2067		 * NI-USB-HS+ sends 0x0
2068		 */
2069		if (buffer[j] != 0x1 && buffer[j] != 0x8 && buffer[j] != 0x7 && buffer[j] != 0x0) {
2070			// [3]
2071			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0, 0x1, 0x7 or 0x8\n",
2072				j, (int)buffer[j]);
2073			unexpected = 1;
2074		}
2075		++j;
2076		// NI-USB-HS+ sends 0 here
2077		if (buffer[j] != 0x30 && buffer[j] != 0x0) { // [4]
2078			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x30\n",
2079				j, (int)buffer[j]);
2080			unexpected = 1;
2081		}
2082		++j;
2083		// MC usb-488 (and sometimes NI-USB-HS?) and NI-USB-HS+ sends 0x0 here
2084		if (buffer[j] != 0x1 && buffer[j] != 0x0) { // [5]
2085			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x1 or 0x0\n",
2086				j, (int)buffer[j]);
2087			unexpected = 1;
2088		}
2089		if (buffer[++j] != 0x0) { // [6]
2090			ready = 1;
2091			// NI-USB-HS+ sends 0xf or 0x19 here
2092			if (buffer[j] != 0x2 && buffer[j] != 0xe && buffer[j] != 0xf &&
2093			    buffer[j] != 0x16 && buffer[j] != 0x19) {
2094				dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x2, 0xe, 0xf, 0x16 or 0x19\n",
2095					j, (int)buffer[j]);
2096				unexpected = 1;
2097			}
2098		}
2099		if (buffer[++j] != 0x0) { // [7]
2100			ready = 1;
2101			// MC usb-488 sends 0x5 here; MC usb-488A sends 0x6 here
2102			if (buffer[j] != 0x3 && buffer[j] != 0x5 && buffer[j] != 0x6 &&
2103			    buffer[j] != 0x8)	{
2104				dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x3 or 0x5, 0x6 or 0x08\n",
2105					j, (int)buffer[j]);
2106				unexpected = 1;
2107			}
2108		}
2109		++j;
2110		if (buffer[j] != 0x0 && buffer[j] != 0x2) { // [8] MC usb-488 sends 0x2 here
2111			dev_err(&usb_dev->dev, " unexpected data: buffer[%i]=0x%x, expected 0x0 or 0x2\n",
2112				j, (int)buffer[j]);
2113			unexpected = 1;
2114		}
2115		++j;
2116		// MC usb-488A and NI-USB-HS sends 0x3 here; NI-USB-HS+ sends 0x30 here
2117		if (buffer[j] != 0x0 && buffer[j] != 0x3 && buffer[j] != 0x30) { // [9]
2118			dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x0, 0x3 or 0x30\n",
2119				j, (int)buffer[j]);
2120			unexpected = 1;
2121		}
2122		if (buffer[++j] != 0x0) { // [10] MC usb-488 sends 0x7 here, new HS+ sends 0x59
2123			ready = 1;
2124			if (buffer[j] != 0x96 && buffer[j] != 0x7 && buffer[j] != 0x6e &&
2125			    buffer[j] != 0x59) {
2126				dev_err(&usb_dev->dev, "unexpected data: buffer[%i]=0x%x, expected 0x96, 0x07, 0x6e or 0x59\n",
2127					j, (int)buffer[j]);
2128				unexpected = 1;
2129			}
2130		}
2131		if (unexpected)
2132			ni_usb_dump_raw_block(buffer, retval);
2133		if (ready)
2134			break;
2135		retval = msleep_interruptible(msec_sleep_duration);
2136		if (retval) {
2137			retval = -ERESTARTSYS;
2138			goto ready_out;
2139		}
2140	}
2141	retval = 0;
2142
2143ready_out:
2144	kfree(buffer);
2145	dev_dbg(&usb_dev->dev, "exit retval=%d\n", retval);
2146	return retval;
2147}
2148
2149/*
2150 * This does some extra init for HS+ models, as observed on Windows.  One of the
2151 * control requests causes the LED to stop blinking.
2152 * I'm not sure what the other 2 requests do.  None of these requests are actually required
2153 * for the adapter to work, maybe they do some init for the analyzer interface
2154 * (which we don't use).
2155 */
2156static int ni_usb_hs_plus_extra_init(struct ni_usb_priv *ni_priv)
2157{
2158	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
2159	int retval;
2160	u8 *buffer;
2161	static const int buffer_size = 16;
2162	int transfer_size;
2163
2164	buffer = kmalloc(buffer_size, GFP_KERNEL);
2165	if (!buffer)
2166		return -ENOMEM;
2167	do {
2168		transfer_size = 16;
2169
2170		retval = ni_usb_receive_control_msg(ni_priv, NI_USB_HS_PLUS_0x48_REQUEST,
2171						    USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2172						    0x0, 0x0, buffer, transfer_size, 1000);
2173		if (retval < 0) {
2174			dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n",
2175				NI_USB_HS_PLUS_0x48_REQUEST, retval);
2176			break;
2177		}
2178		// expected response data: 48 f3 30 00 00 00 00 00 00 00 00 00 00 00 00 00
2179		if (buffer[0] != NI_USB_HS_PLUS_0x48_REQUEST)
2180			dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n",
2181				(int)buffer[0], NI_USB_HS_PLUS_0x48_REQUEST);
2182
2183		transfer_size = 2;
2184
2185		retval = ni_usb_receive_control_msg(ni_priv, NI_USB_HS_PLUS_LED_REQUEST,
2186						    USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2187						    0x1, 0x0, buffer, transfer_size, 1000);
2188		if (retval < 0) {
2189			dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n",
2190				NI_USB_HS_PLUS_LED_REQUEST, retval);
2191			break;
2192		}
2193		// expected response data: 4b 00
2194		if (buffer[0] != NI_USB_HS_PLUS_LED_REQUEST)
2195			dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n",
2196				(int)buffer[0], NI_USB_HS_PLUS_LED_REQUEST);
2197
2198		transfer_size = 9;
2199
2200		retval = ni_usb_receive_control_msg(ni_priv, NI_USB_HS_PLUS_0xf8_REQUEST,
2201						    USB_DIR_IN | USB_TYPE_VENDOR |
2202						    USB_RECIP_INTERFACE,
2203						    0x0, 0x1, buffer, transfer_size, 1000);
2204		if (retval < 0) {
2205			dev_err(&usb_dev->dev, "usb_control_msg request 0x%x returned %i\n",
2206				NI_USB_HS_PLUS_0xf8_REQUEST, retval);
2207			break;
2208		}
2209		// expected response data: f8 01 00 00 00 01 00 00 00
2210		if (buffer[0] != NI_USB_HS_PLUS_0xf8_REQUEST)
2211			dev_err(&usb_dev->dev, "unexpected data: buffer[0]=0x%x, expected 0x%x\n",
2212				(int)buffer[0], NI_USB_HS_PLUS_0xf8_REQUEST);
2213	} while (0);
2214
2215	// cleanup
2216	kfree(buffer);
2217	return retval;
2218}
2219
2220static inline int ni_usb_device_match(struct usb_interface *interface,
2221				      const struct gpib_board_config *config)
2222{
2223	if (gpib_match_device_path(&interface->dev, config->device_path) == 0)
2224		return 0;
2225	return 1;
2226}
2227
2228static int ni_usb_attach(struct gpib_board *board, const struct gpib_board_config *config)
2229{
2230	int retval;
2231	int i, index;
2232	struct ni_usb_priv *ni_priv;
2233	int product_id;
2234	struct usb_device *usb_dev;
2235
2236	mutex_lock(&ni_usb_hotplug_lock);
2237	retval = ni_usb_allocate_private(board);
2238	if (retval < 0)		{
2239		mutex_unlock(&ni_usb_hotplug_lock);
2240		return retval;
2241	}
2242	ni_priv = board->private_data;
2243	for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++)	{
2244		if (ni_usb_driver_interfaces[i] &&
2245		    !usb_get_intfdata(ni_usb_driver_interfaces[i]) &&
2246		    ni_usb_device_match(ni_usb_driver_interfaces[i], config)) {
2247			ni_priv->bus_interface = ni_usb_driver_interfaces[i];
2248			usb_set_intfdata(ni_usb_driver_interfaces[i], board);
2249			usb_dev = interface_to_usbdev(ni_priv->bus_interface);
2250			index = i;
2251			break;
2252		}
2253	}
2254	if (i == MAX_NUM_NI_USB_INTERFACES) {
2255		mutex_unlock(&ni_usb_hotplug_lock);
2256		dev_err(board->gpib_dev, "No supported adapters found, have you loaded its firmware?\n");
2257		return -ENODEV;
2258	}
2259	if (usb_reset_configuration(interface_to_usbdev(ni_priv->bus_interface)))
2260		dev_err(&usb_dev->dev, "usb_reset_configuration() failed.\n");
2261
2262	product_id = le16_to_cpu(usb_dev->descriptor.idProduct);
2263	ni_priv->product_id = product_id;
2264
2265	timer_setup(&ni_priv->bulk_timer, ni_usb_timeout_handler, 0);
2266
2267	switch (product_id) {
2268	case USB_DEVICE_ID_NI_USB_B:
2269		ni_priv->bulk_out_endpoint = NIUSB_B_BULK_OUT_ENDPOINT;
2270		ni_priv->bulk_in_endpoint = NIUSB_B_BULK_IN_ENDPOINT;
2271		ni_priv->interrupt_in_endpoint = NIUSB_B_INTERRUPT_IN_ENDPOINT;
2272		ni_usb_b_read_serial_number(ni_priv);
2273		break;
2274	case USB_DEVICE_ID_NI_USB_HS:
2275	case USB_DEVICE_ID_MC_USB_488:
2276	case USB_DEVICE_ID_KUSB_488A:
2277		ni_priv->bulk_out_endpoint = NIUSB_HS_BULK_OUT_ENDPOINT;
2278		ni_priv->bulk_in_endpoint = NIUSB_HS_BULK_IN_ENDPOINT;
2279		ni_priv->interrupt_in_endpoint = NIUSB_HS_INTERRUPT_IN_ENDPOINT;
2280		retval = ni_usb_hs_wait_for_ready(ni_priv);
2281		if (retval < 0) {
2282			mutex_unlock(&ni_usb_hotplug_lock);
2283			return retval;
2284		}
2285		break;
2286	case USB_DEVICE_ID_NI_USB_HS_PLUS:
2287		ni_priv->bulk_out_endpoint = NIUSB_HS_PLUS_BULK_OUT_ENDPOINT;
2288		ni_priv->bulk_in_endpoint = NIUSB_HS_PLUS_BULK_IN_ENDPOINT;
2289		ni_priv->interrupt_in_endpoint = NIUSB_HS_PLUS_INTERRUPT_IN_ENDPOINT;
2290		retval = ni_usb_hs_wait_for_ready(ni_priv);
2291		if (retval < 0) {
2292			mutex_unlock(&ni_usb_hotplug_lock);
2293			return retval;
2294		}
2295		retval = ni_usb_hs_plus_extra_init(ni_priv);
2296		if (retval < 0) {
2297			mutex_unlock(&ni_usb_hotplug_lock);
2298			return retval;
2299		}
2300		break;
2301	default:
2302		mutex_unlock(&ni_usb_hotplug_lock);
2303		dev_err(&usb_dev->dev, "\tDriver bug: unknown endpoints for usb device id %x\n",
2304			product_id);
2305		return -EINVAL;
2306	}
2307
2308	retval = ni_usb_setup_urbs(board);
2309	if (retval < 0) {
2310		mutex_unlock(&ni_usb_hotplug_lock);
2311		return retval;
2312	}
2313	retval = ni_usb_set_interrupt_monitor(board, 0);
2314	if (retval < 0) {
2315		mutex_unlock(&ni_usb_hotplug_lock);
2316		return retval;
2317	}
2318
2319	board->t1_nano_sec = 500;
2320
2321	retval = ni_usb_init(board);
2322	if (retval < 0) {
2323		mutex_unlock(&ni_usb_hotplug_lock);
2324		return retval;
2325	}
2326	retval = ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask);
2327	if (retval < 0)		{
2328		mutex_unlock(&ni_usb_hotplug_lock);
2329		return retval;
2330	}
2331
2332	mutex_unlock(&ni_usb_hotplug_lock);
2333	dev_info(&usb_dev->dev,
2334		 "bus %d dev num %d attached to gpib%d, intf %i\n",
2335		 usb_dev->bus->busnum, usb_dev->devnum, board->minor, index);
2336	return retval;
2337}
2338
2339static int ni_usb_shutdown_hardware(struct ni_usb_priv *ni_priv)
2340{
2341	struct usb_device *usb_dev = interface_to_usbdev(ni_priv->bus_interface);
2342	int retval;
2343	struct ni_usb_register writes[2];
2344	static const int writes_length = ARRAY_SIZE(writes);
2345	unsigned int ibsta;
2346
2347	writes[0].device = NIUSB_SUBDEV_TNT4882;
2348	writes[0].address = nec7210_to_tnt4882_offset(AUXMR);
2349	writes[0].value = AUX_CR;
2350	writes[1].device = NIUSB_SUBDEV_UNKNOWN3;
2351	writes[1].address = 0x10;
2352	writes[1].value = 0x0;
2353	retval = ni_usb_write_registers(ni_priv, writes, writes_length, &ibsta);
2354	if (retval) {
2355		dev_err(&usb_dev->dev, "register write failed, retval=%i\n", retval);
2356		return retval;
2357	}
2358	return 0;
2359}
2360
2361static void ni_usb_detach(struct gpib_board *board)
2362{
2363	struct ni_usb_priv *ni_priv;
2364
2365	mutex_lock(&ni_usb_hotplug_lock);
2366	/*
2367	 * under windows, software unplug does chip_reset nec7210 aux command,
2368	 * then writes 0x0 to address 0x10 of device 3
2369	 */
2370	ni_priv = board->private_data;
2371	if (ni_priv) {
2372		if (ni_priv->bus_interface) {
2373			ni_usb_set_interrupt_monitor(board, 0);
2374			ni_usb_shutdown_hardware(ni_priv);
2375			usb_set_intfdata(ni_priv->bus_interface, NULL);
2376		}
2377		mutex_lock(&ni_priv->bulk_transfer_lock);
2378		mutex_lock(&ni_priv->control_transfer_lock);
2379		mutex_lock(&ni_priv->interrupt_transfer_lock);
2380		ni_usb_cleanup_urbs(ni_priv);
2381		ni_usb_free_private(ni_priv);
2382	}
2383	mutex_unlock(&ni_usb_hotplug_lock);
2384}
2385
2386static struct gpib_interface ni_usb_gpib_interface = {
2387	.name = "ni_usb_b",
2388	.attach = ni_usb_attach,
2389	.detach = ni_usb_detach,
2390	.read = ni_usb_read,
2391	.write = ni_usb_write,
2392	.command = ni_usb_command,
2393	.take_control = ni_usb_take_control,
2394	.go_to_standby = ni_usb_go_to_standby,
2395	.request_system_control = ni_usb_request_system_control,
2396	.interface_clear = ni_usb_interface_clear,
2397	.remote_enable = ni_usb_remote_enable,
2398	.enable_eos = ni_usb_enable_eos,
2399	.disable_eos = ni_usb_disable_eos,
2400	.parallel_poll = ni_usb_parallel_poll,
2401	.parallel_poll_configure = ni_usb_parallel_poll_configure,
2402	.parallel_poll_response = ni_usb_parallel_poll_response,
2403	.local_parallel_poll_mode = NULL, // XXX
2404	.line_status = ni_usb_line_status,
2405	.update_status = ni_usb_update_status,
2406	.primary_address = ni_usb_primary_address,
2407	.secondary_address = ni_usb_secondary_address,
2408	.serial_poll_response = ni_usb_serial_poll_response,
2409	.serial_poll_status = ni_usb_serial_poll_status,
2410	.t1_delay = ni_usb_t1_delay,
2411	.return_to_local = ni_usb_return_to_local,
2412	.skip_check_for_command_acceptors = 1
2413};
2414
2415// Table with the USB-devices: just now only testing IDs
2416static struct usb_device_id ni_usb_driver_device_table[] = {
2417	{USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_NI_USB_B)},
2418	{USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_NI_USB_HS)},
2419	// gpib-usb-hs+ has a second interface for the analyzer, which we ignore
2420	{USB_DEVICE_INTERFACE_NUMBER(USB_VENDOR_ID_NI, USB_DEVICE_ID_NI_USB_HS_PLUS, 0)},
2421	{USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_KUSB_488A)},
2422	{USB_DEVICE(USB_VENDOR_ID_NI, USB_DEVICE_ID_MC_USB_488)},
2423	{} /* Terminating entry */
2424};
2425MODULE_DEVICE_TABLE(usb, ni_usb_driver_device_table);
2426
2427static int ni_usb_driver_probe(struct usb_interface *interface,	const struct usb_device_id *id)
2428{
2429	struct usb_device *usb_dev = interface_to_usbdev(interface);
2430	int i;
2431	char *path;
2432	static const int path_length = 1024;
2433
2434	mutex_lock(&ni_usb_hotplug_lock);
2435	usb_get_dev(usb_dev);
2436	for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++) {
2437		if (!ni_usb_driver_interfaces[i]) {
2438			ni_usb_driver_interfaces[i] = interface;
2439			usb_set_intfdata(interface, NULL);
2440			break;
2441		}
2442	}
2443	if (i == MAX_NUM_NI_USB_INTERFACES) {
2444		usb_put_dev(usb_dev);
2445		mutex_unlock(&ni_usb_hotplug_lock);
2446		dev_err(&usb_dev->dev, "ni_usb_driver_interfaces[] full\n");
2447		return -1;
2448	}
2449	path = kmalloc(path_length, GFP_KERNEL);
2450	if (!path) {
2451		usb_put_dev(usb_dev);
2452		mutex_unlock(&ni_usb_hotplug_lock);
2453		return -ENOMEM;
2454	}
2455	usb_make_path(usb_dev, path, path_length);
2456	dev_info(&usb_dev->dev, "probe succeeded for path: %s\n", path);
2457	kfree(path);
2458	mutex_unlock(&ni_usb_hotplug_lock);
2459	return 0;
2460}
2461
2462static void ni_usb_driver_disconnect(struct usb_interface *interface)
2463{
2464	struct usb_device *usb_dev = interface_to_usbdev(interface);
2465	int i;
2466
2467	mutex_lock(&ni_usb_hotplug_lock);
2468	for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++)	{
2469		if (ni_usb_driver_interfaces[i] == interface)	{
2470			struct gpib_board *board = usb_get_intfdata(interface);
2471
2472			if (board) {
2473				struct ni_usb_priv *ni_priv = board->private_data;
2474
2475				if (ni_priv) {
2476					mutex_lock(&ni_priv->bulk_transfer_lock);
2477					mutex_lock(&ni_priv->control_transfer_lock);
2478					mutex_lock(&ni_priv->interrupt_transfer_lock);
2479					ni_usb_cleanup_urbs(ni_priv);
2480					ni_priv->bus_interface = NULL;
2481					mutex_unlock(&ni_priv->interrupt_transfer_lock);
2482					mutex_unlock(&ni_priv->control_transfer_lock);
2483					mutex_unlock(&ni_priv->bulk_transfer_lock);
2484				}
2485			}
2486			ni_usb_driver_interfaces[i] = NULL;
2487			break;
2488		}
2489	}
2490	if (i == MAX_NUM_NI_USB_INTERFACES)
2491		dev_err(&usb_dev->dev, "unable to find interface  bug?\n");
2492	usb_put_dev(usb_dev);
2493	mutex_unlock(&ni_usb_hotplug_lock);
2494}
2495
2496static int ni_usb_driver_suspend(struct usb_interface *interface, pm_message_t message)
2497{
2498	struct usb_device *usb_dev = interface_to_usbdev(interface);
2499	struct gpib_board *board;
2500	int i, retval;
2501
2502	mutex_lock(&ni_usb_hotplug_lock);
2503
2504	for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++)	{
2505		if (ni_usb_driver_interfaces[i] == interface) {
2506			board = usb_get_intfdata(interface);
2507			if (board)
2508				break;
2509		}
2510	}
2511	if (i == MAX_NUM_NI_USB_INTERFACES) {
2512		mutex_unlock(&ni_usb_hotplug_lock);
2513		return 0;
2514	}
2515
2516	struct ni_usb_priv *ni_priv = board->private_data;
2517
2518	if (ni_priv) {
2519		ni_usb_set_interrupt_monitor(board, 0);
2520		retval = ni_usb_shutdown_hardware(ni_priv);
2521		if (retval) {
2522			mutex_unlock(&ni_usb_hotplug_lock);
2523			return retval;
2524		}
2525		if (ni_priv->interrupt_urb) {
2526			mutex_lock(&ni_priv->interrupt_transfer_lock);
2527			ni_usb_cleanup_urbs(ni_priv);
2528			mutex_unlock(&ni_priv->interrupt_transfer_lock);
2529		}
2530		dev_dbg(&usb_dev->dev,
2531			"bus %d dev num %d gpib%d, interface %i suspended\n",
2532			usb_dev->bus->busnum, usb_dev->devnum, board->minor, i);
2533	}
2534
2535	mutex_unlock(&ni_usb_hotplug_lock);
2536	return 0;
2537}
2538
2539static int ni_usb_driver_resume(struct usb_interface *interface)
2540{
2541	struct usb_device *usb_dev = interface_to_usbdev(interface);
2542
2543	struct gpib_board *board;
2544	int i, retval;
2545
2546	mutex_lock(&ni_usb_hotplug_lock);
2547
2548	for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++)	{
2549		if (ni_usb_driver_interfaces[i] == interface) {
2550			board = usb_get_intfdata(interface);
2551			if (board)
2552				break;
2553		}
2554	}
2555	if (i == MAX_NUM_NI_USB_INTERFACES) {
2556		mutex_unlock(&ni_usb_hotplug_lock);
2557		return 0;
2558	}
2559
2560	struct ni_usb_priv *ni_priv = board->private_data;
2561
2562	if (ni_priv) {
2563		if (ni_priv->interrupt_urb) {
2564			mutex_lock(&ni_priv->interrupt_transfer_lock);
2565			retval = usb_submit_urb(ni_priv->interrupt_urb, GFP_KERNEL);
2566			if (retval) {
2567				dev_err(&usb_dev->dev, "resume failed to resubmit interrupt urb, retval=%i\n",
2568					retval);
2569				mutex_unlock(&ni_priv->interrupt_transfer_lock);
2570				mutex_unlock(&ni_usb_hotplug_lock);
2571				return retval;
2572			}
2573			mutex_unlock(&ni_priv->interrupt_transfer_lock);
2574		} else {
2575			dev_err(&usb_dev->dev, "bug! resume int urb not set up\n");
2576			mutex_unlock(&ni_usb_hotplug_lock);
2577			return -EINVAL;
2578		}
2579
2580		switch (ni_priv->product_id) {
2581		case USB_DEVICE_ID_NI_USB_B:
2582			ni_usb_b_read_serial_number(ni_priv);
2583			break;
2584		case USB_DEVICE_ID_NI_USB_HS:
2585		case USB_DEVICE_ID_MC_USB_488:
2586		case USB_DEVICE_ID_KUSB_488A:
2587			retval = ni_usb_hs_wait_for_ready(ni_priv);
2588			if (retval < 0) {
2589				mutex_unlock(&ni_usb_hotplug_lock);
2590				return retval;
2591			}
2592			break;
2593		case USB_DEVICE_ID_NI_USB_HS_PLUS:
2594			retval = ni_usb_hs_wait_for_ready(ni_priv);
2595			if (retval < 0) {
2596				mutex_unlock(&ni_usb_hotplug_lock);
2597				return retval;
2598			}
2599			retval = ni_usb_hs_plus_extra_init(ni_priv);
2600			if (retval < 0) {
2601				mutex_unlock(&ni_usb_hotplug_lock);
2602				return retval;
2603			}
2604			break;
2605		default:
2606			mutex_unlock(&ni_usb_hotplug_lock);
2607			dev_err(&usb_dev->dev, "\tDriver bug: unknown endpoints for usb device id\n");
2608			return -EINVAL;
2609		}
2610
2611		retval = ni_usb_set_interrupt_monitor(board, 0);
2612		if (retval < 0) {
2613			mutex_unlock(&ni_usb_hotplug_lock);
2614			return retval;
2615		}
2616
2617		retval = ni_usb_init(board);
2618		if (retval < 0) {
2619			mutex_unlock(&ni_usb_hotplug_lock);
2620			return retval;
2621		}
2622		retval = ni_usb_set_interrupt_monitor(board, ni_usb_ibsta_monitor_mask);
2623		if (retval < 0)		{
2624			mutex_unlock(&ni_usb_hotplug_lock);
2625			return retval;
2626		}
2627		if (board->master)
2628			ni_usb_interface_clear(board, 1); // this is a pulsed action
2629		if (ni_priv->ren_state)
2630			ni_usb_remote_enable(board, 1);
2631
2632		dev_dbg(&usb_dev->dev,
2633			"bus %d dev num %d gpib%d, interface %i resumed\n",
2634			usb_dev->bus->busnum, usb_dev->devnum, board->minor, i);
2635	}
2636
2637	mutex_unlock(&ni_usb_hotplug_lock);
2638	return 0;
2639}
2640
2641static struct usb_driver ni_usb_bus_driver = {
2642	.name = DRV_NAME,
2643	.probe = ni_usb_driver_probe,
2644	.disconnect = ni_usb_driver_disconnect,
2645	.suspend = ni_usb_driver_suspend,
2646	.resume = ni_usb_driver_resume,
2647	.id_table = ni_usb_driver_device_table,
2648};
2649
2650static int __init ni_usb_init_module(void)
2651{
2652	int i;
2653	int ret;
2654
2655	for (i = 0; i < MAX_NUM_NI_USB_INTERFACES; i++)
2656		ni_usb_driver_interfaces[i] = NULL;
2657
2658	ret = usb_register(&ni_usb_bus_driver);
2659	if (ret) {
2660		pr_err("usb_register failed: error = %d\n", ret);
2661		return ret;
2662	}
2663
2664	ret = gpib_register_driver(&ni_usb_gpib_interface, THIS_MODULE);
2665	if (ret) {
2666		pr_err("gpib_register_driver failed: error = %d\n", ret);
2667		return ret;
2668	}
2669
2670	return 0;
2671}
2672
2673static void __exit ni_usb_exit_module(void)
2674{
2675	gpib_unregister_driver(&ni_usb_gpib_interface);
2676	usb_deregister(&ni_usb_bus_driver);
2677}
2678
2679module_init(ni_usb_init_module);
2680module_exit(ni_usb_exit_module);