gpib_os.c

   1// SPDX-License-Identifier: GPL-2.0
   2
   3/***************************************************************************
   4 *    copyright            : (C) 2001, 2004 by Frank Mori Hess
   5 ***************************************************************************
   6 */
   7
   8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9#define dev_fmt pr_fmt
  10
  11#include "ibsys.h"
  12#include <linux/module.h>
  13#include <linux/wait.h>
  14#include <linux/list.h>
  15#include <linux/fs.h>
  16#include <linux/pci.h>
  17#include <linux/device.h>
  18#include <linux/init.h>
  19#include <linux/string.h>
  20#include <linux/vmalloc.h>
  21#include <linux/fcntl.h>
  22#include <linux/kmod.h>
  23#include <linux/uaccess.h>
  24
  25MODULE_LICENSE("GPL");
  26MODULE_DESCRIPTION("GPIB base support");
  27MODULE_ALIAS_CHARDEV_MAJOR(GPIB_CODE);
  28
  29static int board_type_ioctl(struct gpib_file_private *file_priv,
  30			    struct gpib_board *board, unsigned long arg);
  31static int read_ioctl(struct gpib_file_private *file_priv, struct gpib_board *board,
  32		      unsigned long arg);
  33static int write_ioctl(struct gpib_file_private *file_priv, struct gpib_board *board,
  34		       unsigned long arg);
  35static int command_ioctl(struct gpib_file_private *file_priv, struct gpib_board *board,
  36			 unsigned long arg);
  37static int open_dev_ioctl(struct file *filep, struct gpib_board *board, unsigned long arg);
  38static int close_dev_ioctl(struct file *filep, struct gpib_board *board, unsigned long arg);
  39static int serial_poll_ioctl(struct gpib_board *board, unsigned long arg);
  40static int wait_ioctl(struct gpib_file_private *file_priv,
  41		      struct gpib_board *board, unsigned long arg);
  42static int parallel_poll_ioctl(struct gpib_board *board, unsigned long arg);
  43static int online_ioctl(struct gpib_board *board, unsigned long arg);
  44static int remote_enable_ioctl(struct gpib_board *board, unsigned long arg);
  45static int take_control_ioctl(struct gpib_board *board, unsigned long arg);
  46static int line_status_ioctl(struct gpib_board *board, unsigned long arg);
  47static int pad_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
  48		     unsigned long arg);
  49static int sad_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
  50		     unsigned long arg);
  51static int eos_ioctl(struct gpib_board *board, unsigned long arg);
  52static int request_service_ioctl(struct gpib_board *board, unsigned long arg);
  53static int request_service2_ioctl(struct gpib_board *board, unsigned long arg);
  54static int iobase_ioctl(struct gpib_board_config *config, unsigned long arg);
  55static int irq_ioctl(struct gpib_board_config *config, unsigned long arg);
  56static int dma_ioctl(struct gpib_board_config *config, unsigned long arg);
  57static int autospoll_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
  58			   unsigned long arg);
  59static int mutex_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
  60		       unsigned long arg);
  61static int timeout_ioctl(struct gpib_board *board, unsigned long arg);
  62static int status_bytes_ioctl(struct gpib_board *board, unsigned long arg);
  63static int board_info_ioctl(const struct gpib_board *board, unsigned long arg);
  64static int ppc_ioctl(struct gpib_board *board, unsigned long arg);
  65static int set_local_ppoll_mode_ioctl(struct gpib_board *board, unsigned long arg);
  66static int get_local_ppoll_mode_ioctl(struct gpib_board *board, unsigned long arg);
  67static int query_board_rsv_ioctl(struct gpib_board *board, unsigned long arg);
  68static int interface_clear_ioctl(struct gpib_board *board, unsigned long arg);
  69static int select_pci_ioctl(struct gpib_board_config *config, unsigned long arg);
  70static int select_device_path_ioctl(struct gpib_board_config *config, unsigned long arg);
  71static int event_ioctl(struct gpib_board *board, unsigned long arg);
  72static int request_system_control_ioctl(struct gpib_board *board, unsigned long arg);
  73static int t1_delay_ioctl(struct gpib_board *board, unsigned long arg);
  74
  75static int cleanup_open_devices(struct gpib_file_private *file_priv, struct gpib_board *board);
  76
  77static int pop_gpib_event_nolock(struct gpib_board *board,
  78				 struct gpib_event_queue *queue, short *event_type);
  79
  80/*
  81 * Timer functions
  82 */
  83
  84/* Watchdog timeout routine */
  85
  86static void watchdog_timeout(struct timer_list *t)
  87{
  88	struct gpib_board *board = timer_container_of(board, t, timer);
  89
  90	set_bit(TIMO_NUM, &board->status);
  91	wake_up_interruptible(&board->wait);
  92}
  93
  94/* install timer interrupt handler */
  95void os_start_timer(struct gpib_board *board, unsigned int usec_timeout)
  96/* Starts the timeout task  */
  97{
  98	if (timer_pending(&board->timer)) {
  99		dev_err(board->gpib_dev, "bug! timer already running?\n");
 100		return;
 101	}
 102	clear_bit(TIMO_NUM, &board->status);
 103
 104	if (usec_timeout > 0) {
 105		board->timer.function = watchdog_timeout;
 106		/* set number of ticks */
 107		mod_timer(&board->timer, jiffies + usec_to_jiffies(usec_timeout));
 108	}
 109}
 110
 111void os_remove_timer(struct gpib_board *board)
 112/* Removes the timeout task */
 113{
 114	if (timer_pending(&board->timer))
 115		timer_delete_sync(&board->timer);
 116}
 117
 118int io_timed_out(struct gpib_board *board)
 119{
 120	if (test_bit(TIMO_NUM, &board->status))
 121		return 1;
 122	return 0;
 123}
 124
 125/*
 126 * this is a function instead of a constant because of Suse
 127 * defining HZ to be a function call to get_hz()
 128 */
 129static inline int pseudo_irq_period(void)
 130{
 131	return (HZ + 99) / 100;
 132}
 133
 134static void pseudo_irq_handler(struct timer_list *t)
 135{
 136	struct gpib_pseudo_irq *pseudo_irq = timer_container_of(pseudo_irq, t,
 137								timer);
 138
 139	if (pseudo_irq->handler)
 140		pseudo_irq->handler(0, pseudo_irq->board);
 141	else
 142		pr_err("gpib: bug! pseudo_irq.handler is NULL\n");
 143
 144	if (atomic_read(&pseudo_irq->active))
 145		mod_timer(&pseudo_irq->timer, jiffies + pseudo_irq_period());
 146}
 147
 148int gpib_request_pseudo_irq(struct gpib_board *board, irqreturn_t (*handler)(int, void *))
 149{
 150	if (timer_pending(&board->pseudo_irq.timer) || board->pseudo_irq.handler) {
 151		dev_err(board->gpib_dev, "only one pseudo interrupt per board allowed\n");
 152		return -1;
 153	}
 154
 155	board->pseudo_irq.handler = handler;
 156	board->pseudo_irq.timer.function = pseudo_irq_handler;
 157	board->pseudo_irq.board = board;
 158
 159	atomic_set(&board->pseudo_irq.active, 1);
 160
 161	mod_timer(&board->pseudo_irq.timer, jiffies + pseudo_irq_period());
 162
 163	return 0;
 164}
 165EXPORT_SYMBOL(gpib_request_pseudo_irq);
 166
 167void gpib_free_pseudo_irq(struct gpib_board *board)
 168{
 169	atomic_set(&board->pseudo_irq.active, 0);
 170
 171	timer_delete_sync(&board->pseudo_irq.timer);
 172	board->pseudo_irq.handler = NULL;
 173}
 174EXPORT_SYMBOL(gpib_free_pseudo_irq);
 175
 176static const unsigned int serial_timeout = 1000000;
 177
 178unsigned int num_status_bytes(const struct gpib_status_queue *dev)
 179{
 180	if (!dev)
 181		return 0;
 182	return dev->num_status_bytes;
 183}
 184
 185// push status byte onto back of status byte fifo
 186int push_status_byte(struct gpib_board *board, struct gpib_status_queue *device, u8 poll_byte)
 187{
 188	struct list_head *head = &device->status_bytes;
 189	struct gpib_status_byte *status;
 190	static const unsigned int max_num_status_bytes = 1024;
 191	int retval;
 192
 193	if (num_status_bytes(device) >= max_num_status_bytes) {
 194		u8 lost_byte;
 195
 196		device->dropped_byte = 1;
 197		retval = pop_status_byte(board, device, &lost_byte);
 198		if (retval < 0)
 199			return retval;
 200	}
 201
 202	status = kmalloc(sizeof(*status), GFP_KERNEL);
 203	if (!status)
 204		return -ENOMEM;
 205
 206	INIT_LIST_HEAD(&status->list);
 207	status->poll_byte = poll_byte;
 208
 209	list_add_tail(&status->list, head);
 210
 211	device->num_status_bytes++;
 212
 213	dev_dbg(board->gpib_dev, "pushed status byte 0x%x, %i in queue\n",
 214		(int)poll_byte, num_status_bytes(device));
 215
 216	return 0;
 217}
 218
 219// pop status byte from front of status byte fifo
 220int pop_status_byte(struct gpib_board *board, struct gpib_status_queue *device, u8 *poll_byte)
 221{
 222	struct list_head *head = &device->status_bytes;
 223	struct list_head *front = head->next;
 224	struct gpib_status_byte *status;
 225
 226	if (num_status_bytes(device) == 0)
 227		return -EIO;
 228
 229	if (front == head)
 230		return -EIO;
 231
 232	if (device->dropped_byte) {
 233		device->dropped_byte = 0;
 234		return -EPIPE;
 235	}
 236
 237	status = list_entry(front, struct gpib_status_byte, list);
 238	*poll_byte = status->poll_byte;
 239
 240	list_del(front);
 241	kfree(status);
 242
 243	device->num_status_bytes--;
 244
 245	dev_dbg(board->gpib_dev, "popped status byte 0x%x, %i in queue\n",
 246		(int)*poll_byte, num_status_bytes(device));
 247
 248	return 0;
 249}
 250
 251struct gpib_status_queue *get_gpib_status_queue(struct gpib_board *board, unsigned int pad, int sad)
 252{
 253	struct gpib_status_queue *device;
 254	struct list_head *list_ptr;
 255	const struct list_head *head = &board->device_list;
 256
 257	for (list_ptr = head->next; list_ptr != head; list_ptr = list_ptr->next) {
 258		device = list_entry(list_ptr, struct gpib_status_queue, list);
 259		if (gpib_address_equal(device->pad, device->sad, pad, sad))
 260			return device;
 261	}
 262
 263	return NULL;
 264}
 265
 266int get_serial_poll_byte(struct gpib_board *board, unsigned int pad, int sad,
 267			 unsigned int usec_timeout, u8 *poll_byte)
 268{
 269	struct gpib_status_queue *device;
 270
 271	device = get_gpib_status_queue(board, pad, sad);
 272	if (num_status_bytes(device))
 273		return pop_status_byte(board, device, poll_byte);
 274	else
 275		return dvrsp(board, pad, sad, usec_timeout, poll_byte);
 276}
 277
 278int autopoll_all_devices(struct gpib_board *board)
 279{
 280	int retval;
 281
 282	if (mutex_lock_interruptible(&board->user_mutex))
 283		return -ERESTARTSYS;
 284	if (mutex_lock_interruptible(&board->big_gpib_mutex)) {
 285		mutex_unlock(&board->user_mutex);
 286		return -ERESTARTSYS;
 287	}
 288
 289	dev_dbg(board->gpib_dev, "autopoll has board lock\n");
 290
 291	retval = serial_poll_all(board, serial_timeout);
 292	if (retval < 0)	{
 293		mutex_unlock(&board->big_gpib_mutex);
 294		mutex_unlock(&board->user_mutex);
 295		return retval;
 296	}
 297
 298	dev_dbg(board->gpib_dev, "complete\n");
 299	/*
 300	 * need to wake wait queue in case someone is
 301	 * waiting on RQS
 302	 */
 303	wake_up_interruptible(&board->wait);
 304	mutex_unlock(&board->big_gpib_mutex);
 305	mutex_unlock(&board->user_mutex);
 306
 307	return retval;
 308}
 309
 310static int setup_serial_poll(struct gpib_board *board, unsigned int usec_timeout)
 311{
 312	u8 cmd_string[8];
 313	int i;
 314	size_t bytes_written;
 315	int ret;
 316
 317	os_start_timer(board, usec_timeout);
 318	ret = ibcac(board, 1, 1);
 319	if (ret < 0) {
 320		os_remove_timer(board);
 321		return ret;
 322	}
 323
 324	i = 0;
 325	cmd_string[i++] = UNL;
 326	cmd_string[i++] = MLA(board->pad);	/* controller's listen address */
 327	if (board->sad >= 0)
 328		cmd_string[i++] = MSA(board->sad);
 329	cmd_string[i++] = SPE;	// serial poll enable
 330
 331	ret = board->interface->command(board, cmd_string, i, &bytes_written);
 332	if (ret < 0 || bytes_written < i) {
 333		dev_dbg(board->gpib_dev, "failed to setup serial poll\n");
 334		os_remove_timer(board);
 335		return -EIO;
 336	}
 337	os_remove_timer(board);
 338
 339	return 0;
 340}
 341
 342static int read_serial_poll_byte(struct gpib_board *board, unsigned int pad,
 343				 int sad, unsigned int usec_timeout, u8 *result)
 344{
 345	u8 cmd_string[8];
 346	int end_flag;
 347	int ret;
 348	int i;
 349	size_t nbytes;
 350
 351	dev_dbg(board->gpib_dev, "entering  pad=%i sad=%i\n", pad, sad);
 352
 353	os_start_timer(board, usec_timeout);
 354	ret = ibcac(board, 1, 1);
 355	if (ret < 0) {
 356		os_remove_timer(board);
 357		return ret;
 358	}
 359
 360	i = 0;
 361	// send talk address
 362	cmd_string[i++] = MTA(pad);
 363	if (sad >= 0)
 364		cmd_string[i++] = MSA(sad);
 365
 366	ret = board->interface->command(board, cmd_string, i, &nbytes);
 367	if (ret < 0 || nbytes < i) {
 368		dev_err(board->gpib_dev, "failed to setup serial poll\n");
 369		os_remove_timer(board);
 370		return -EIO;
 371	}
 372
 373	ibgts(board);
 374
 375	// read poll result
 376	ret = board->interface->read(board, result, 1, &end_flag, &nbytes);
 377	if (ret < 0 || nbytes < 1) {
 378		dev_err(board->gpib_dev, "serial poll failed\n");
 379		os_remove_timer(board);
 380		return -EIO;
 381	}
 382	os_remove_timer(board);
 383
 384	return 0;
 385}
 386
 387static int cleanup_serial_poll(struct gpib_board *board, unsigned int usec_timeout)
 388{
 389	u8 cmd_string[8];
 390	int ret;
 391	size_t bytes_written;
 392
 393	os_start_timer(board, usec_timeout);
 394	ret = ibcac(board, 1, 1);
 395	if (ret < 0) {
 396		os_remove_timer(board);
 397		return ret;
 398	}
 399
 400	cmd_string[0] = SPD;	/* disable serial poll bytes */
 401	cmd_string[1] = UNT;
 402	ret = board->interface->command(board, cmd_string, 2, &bytes_written);
 403	if (ret < 0 || bytes_written < 2) {
 404		dev_err(board->gpib_dev, "failed to disable serial poll\n");
 405		os_remove_timer(board);
 406		return -EIO;
 407	}
 408	os_remove_timer(board);
 409
 410	return 0;
 411}
 412
 413static int serial_poll_single(struct gpib_board *board, unsigned int pad, int sad,
 414			      unsigned int usec_timeout, u8 *result)
 415{
 416	int retval, cleanup_retval;
 417
 418	retval = setup_serial_poll(board, usec_timeout);
 419	if (retval < 0)
 420		return retval;
 421	retval = read_serial_poll_byte(board, pad, sad, usec_timeout, result);
 422	cleanup_retval = cleanup_serial_poll(board, usec_timeout);
 423	if (retval < 0)
 424		return retval;
 425	if (cleanup_retval < 0)
 426		return retval;
 427
 428	return 0;
 429}
 430
 431int serial_poll_all(struct gpib_board *board, unsigned int usec_timeout)
 432{
 433	int retval = 0;
 434	struct list_head *cur;
 435	const struct list_head *head = NULL;
 436	struct gpib_status_queue *device;
 437	u8 result;
 438	unsigned int num_bytes = 0;
 439
 440	head = &board->device_list;
 441	if (head->next == head)
 442		return 0;
 443
 444	retval = setup_serial_poll(board, usec_timeout);
 445	if (retval < 0)
 446		return retval;
 447
 448	for (cur = head->next; cur != head; cur = cur->next) {
 449		device = list_entry(cur, struct gpib_status_queue, list);
 450		retval = read_serial_poll_byte(board,
 451					       device->pad, device->sad, usec_timeout, &result);
 452		if (retval < 0)
 453			continue;
 454		if (result & request_service_bit) {
 455			retval = push_status_byte(board, device, result);
 456			if (retval < 0)
 457				continue;
 458			num_bytes++;
 459		}
 460	}
 461
 462	retval = cleanup_serial_poll(board, usec_timeout);
 463	if (retval < 0)
 464		return retval;
 465
 466	return num_bytes;
 467}
 468
 469/*
 470 * DVRSP
 471 * This function performs a serial poll of the device with primary
 472 * address pad and secondary address sad. If the device has no
 473 * secondary address, pass a negative number in for this argument.  At the
 474 * end of a successful serial poll the response is returned in result.
 475 * SPD and UNT are sent at the completion of the poll.
 476 */
 477
 478int dvrsp(struct gpib_board *board, unsigned int pad, int sad,
 479	  unsigned int usec_timeout, u8 *result)
 480{
 481	int status = ibstatus(board);
 482	int retval;
 483
 484	if ((status & CIC) == 0) {
 485		dev_err(board->gpib_dev, "not CIC during serial poll\n");
 486		return -1;
 487	}
 488
 489	if (pad > MAX_GPIB_PRIMARY_ADDRESS || sad > MAX_GPIB_SECONDARY_ADDRESS || sad < -1) {
 490		dev_err(board->gpib_dev, "bad address for serial poll");
 491		return -1;
 492	}
 493
 494	retval = serial_poll_single(board, pad, sad, usec_timeout, result);
 495	if (io_timed_out(board))
 496		retval = -ETIMEDOUT;
 497
 498	return retval;
 499}
 500
 501static struct gpib_descriptor *handle_to_descriptor(const struct gpib_file_private *file_priv,
 502						    int handle)
 503{
 504	if (handle < 0 || handle >= GPIB_MAX_NUM_DESCRIPTORS) {
 505		pr_err("gpib: invalid handle %i\n", handle);
 506		return NULL;
 507	}
 508
 509	return file_priv->descriptors[handle];
 510}
 511
 512static int init_gpib_file_private(struct gpib_file_private *priv)
 513{
 514	memset(priv, 0, sizeof(*priv));
 515	atomic_set(&priv->holding_mutex, 0);
 516	priv->descriptors[0] = kmalloc(sizeof(struct gpib_descriptor), GFP_KERNEL);
 517	if (!priv->descriptors[0]) {
 518		pr_err("gpib: failed to allocate default board descriptor\n");
 519		return -ENOMEM;
 520	}
 521	init_gpib_descriptor(priv->descriptors[0]);
 522	priv->descriptors[0]->is_board = 1;
 523	mutex_init(&priv->descriptors_mutex);
 524	return 0;
 525}
 526
 527int ibopen(struct inode *inode, struct file *filep)
 528{
 529	unsigned int minor = iminor(inode);
 530	struct gpib_board *board;
 531	struct gpib_file_private *priv;
 532
 533	if (minor >= GPIB_MAX_NUM_BOARDS) {
 534		pr_err("gpib: invalid minor number of device file\n");
 535		return -ENXIO;
 536	}
 537
 538	board = &board_array[minor];
 539
 540	filep->private_data = kmalloc(sizeof(struct gpib_file_private), GFP_KERNEL);
 541	if (!filep->private_data)
 542		return -ENOMEM;
 543
 544	priv = filep->private_data;
 545	init_gpib_file_private((struct gpib_file_private *)filep->private_data);
 546
 547	if (board->use_count == 0) {
 548		int retval;
 549
 550		retval = request_module("gpib%i", minor);
 551		if (retval)
 552			dev_dbg(board->gpib_dev, "request module returned %i\n", retval);
 553	}
 554	if (board->interface) {
 555		if (!try_module_get(board->provider_module)) {
 556			dev_err(board->gpib_dev, "try_module_get() failed\n");
 557			return -EIO;
 558		}
 559		board->use_count++;
 560		priv->got_module = 1;
 561	}
 562	return 0;
 563}
 564
 565int ibclose(struct inode *inode, struct file *filep)
 566{
 567	unsigned int minor = iminor(inode);
 568	struct gpib_board *board;
 569	struct gpib_file_private *priv = filep->private_data;
 570	struct gpib_descriptor *desc;
 571
 572	if (minor >= GPIB_MAX_NUM_BOARDS) {
 573		pr_err("gpib: invalid minor number of device file\n");
 574		return -ENODEV;
 575	}
 576
 577	board = &board_array[minor];
 578
 579	if (priv) {
 580		desc = handle_to_descriptor(priv, 0);
 581		if (desc) {
 582			if (desc->autopoll_enabled) {
 583				dev_dbg(board->gpib_dev, "decrementing autospollers\n");
 584				if (board->autospollers > 0)
 585					board->autospollers--;
 586				else
 587					dev_err(board->gpib_dev,
 588						"Attempt to decrement zero autospollers\n");
 589			}
 590		} else {
 591			dev_err(board->gpib_dev, "Unexpected null gpib_descriptor\n");
 592		}
 593
 594		cleanup_open_devices(priv, board);
 595
 596		if (atomic_read(&priv->holding_mutex))
 597			mutex_unlock(&board->user_mutex);
 598
 599		if (priv->got_module && board->use_count) {
 600			module_put(board->provider_module);
 601			--board->use_count;
 602		}
 603
 604		kfree(filep->private_data);
 605		filep->private_data = NULL;
 606	}
 607
 608	return 0;
 609}
 610
 611long ibioctl(struct file *filep, unsigned int cmd, unsigned long arg)
 612{
 613	unsigned int minor = iminor(file_inode(filep));
 614	struct gpib_board *board;
 615	struct gpib_file_private *file_priv = filep->private_data;
 616	long retval = -ENOTTY;
 617
 618	if (minor >= GPIB_MAX_NUM_BOARDS) {
 619		pr_err("gpib: invalid minor number of device file\n");
 620		return -ENODEV;
 621	}
 622	board = &board_array[minor];
 623
 624	if (mutex_lock_interruptible(&board->big_gpib_mutex))
 625		return -ERESTARTSYS;
 626
 627	dev_dbg(board->gpib_dev, "ioctl %d, interface=%s, use=%d, onl=%d\n",
 628		cmd & 0xff,
 629		board->interface ? board->interface->name : "",
 630		board->use_count,
 631		board->online);
 632
 633	switch (cmd) {
 634	case CFCBOARDTYPE:
 635		retval = board_type_ioctl(file_priv, board, arg);
 636		goto done;
 637	case IBONL:
 638		retval = online_ioctl(board, arg);
 639		goto done;
 640	default:
 641		break;
 642	}
 643	if (!board->interface) {
 644		dev_err(board->gpib_dev, "no gpib board configured\n");
 645		retval = -ENODEV;
 646		goto done;
 647	}
 648	if (file_priv->got_module == 0)	{
 649		if (!try_module_get(board->provider_module)) {
 650			dev_err(board->gpib_dev, "try_module_get() failed\n");
 651			retval = -EIO;
 652			goto done;
 653		}
 654		file_priv->got_module = 1;
 655		board->use_count++;
 656	}
 657	switch (cmd) {
 658	case CFCBASE:
 659		retval = iobase_ioctl(&board->config, arg);
 660		goto done;
 661	case CFCIRQ:
 662		retval = irq_ioctl(&board->config, arg);
 663		goto done;
 664	case CFCDMA:
 665		retval = dma_ioctl(&board->config, arg);
 666		goto done;
 667	case IBAUTOSPOLL:
 668		retval = autospoll_ioctl(board, file_priv, arg);
 669		goto done;
 670	case IBBOARD_INFO:
 671		retval = board_info_ioctl(board, arg);
 672		goto done;
 673	case IBMUTEX:
 674		/*
 675		 * Need to unlock board->big_gpib_mutex before potentially locking board->user_mutex
 676		 * to maintain consistent locking order
 677		 */
 678		mutex_unlock(&board->big_gpib_mutex);
 679		return mutex_ioctl(board, file_priv, arg);
 680	case IBPAD:
 681		retval = pad_ioctl(board, file_priv, arg);
 682		goto done;
 683	case IBSAD:
 684		retval = sad_ioctl(board, file_priv, arg);
 685		goto done;
 686	case IBSELECT_PCI:
 687		retval = select_pci_ioctl(&board->config, arg);
 688		goto done;
 689	case IBSELECT_DEVICE_PATH:
 690		retval = select_device_path_ioctl(&board->config, arg);
 691		goto done;
 692	default:
 693		break;
 694	}
 695
 696	if (!board->online) {
 697		retval = -EINVAL;
 698		goto done;
 699	}
 700
 701	switch (cmd) {
 702	case IBEVENT:
 703		retval = event_ioctl(board, arg);
 704		goto done;
 705	case IBCLOSEDEV:
 706		retval = close_dev_ioctl(filep, board, arg);
 707		goto done;
 708	case IBOPENDEV:
 709		retval = open_dev_ioctl(filep, board, arg);
 710		goto done;
 711	case IBSPOLL_BYTES:
 712		retval = status_bytes_ioctl(board, arg);
 713		goto done;
 714	case IBWAIT:
 715		retval = wait_ioctl(file_priv, board, arg);
 716		if (retval == -ERESTARTSYS)
 717			return retval;
 718		goto done;
 719	case IBLINES:
 720		retval = line_status_ioctl(board, arg);
 721		goto done;
 722	case IBLOC:
 723		board->interface->return_to_local(board);
 724		retval = 0;
 725		goto done;
 726	default:
 727		break;
 728	}
 729
 730	spin_lock(&board->locking_pid_spinlock);
 731	if (current->pid != board->locking_pid)	{
 732		spin_unlock(&board->locking_pid_spinlock);
 733		retval = -EPERM;
 734		goto done;
 735	}
 736	spin_unlock(&board->locking_pid_spinlock);
 737
 738	switch (cmd) {
 739	case IB_T1_DELAY:
 740		retval = t1_delay_ioctl(board, arg);
 741		goto done;
 742	case IBCAC:
 743		retval = take_control_ioctl(board, arg);
 744		goto done;
 745	case IBCMD:
 746		/*
 747		 * IO ioctls can take a long time, we need to unlock board->big_gpib_mutex
 748		 * before we call them.
 749		 */
 750		mutex_unlock(&board->big_gpib_mutex);
 751		return command_ioctl(file_priv, board, arg);
 752	case IBEOS:
 753		retval = eos_ioctl(board, arg);
 754		goto done;
 755	case IBGTS:
 756		retval = ibgts(board);
 757		goto done;
 758	case IBPPC:
 759		retval = ppc_ioctl(board, arg);
 760		goto done;
 761	case IBPP2_SET:
 762		retval = set_local_ppoll_mode_ioctl(board, arg);
 763		goto done;
 764	case IBPP2_GET:
 765		retval = get_local_ppoll_mode_ioctl(board, arg);
 766		goto done;
 767	case IBQUERY_BOARD_RSV:
 768		retval = query_board_rsv_ioctl(board, arg);
 769		goto done;
 770	case IBRD:
 771		/*
 772		 * IO ioctls can take a long time, we need to unlock board->big_gpib_mutex
 773		 * before we call them.
 774		 */
 775		mutex_unlock(&board->big_gpib_mutex);
 776		return read_ioctl(file_priv, board, arg);
 777	case IBRPP:
 778		retval = parallel_poll_ioctl(board, arg);
 779		goto done;
 780	case IBRSC:
 781		retval = request_system_control_ioctl(board, arg);
 782		goto done;
 783	case IBRSP:
 784		retval = serial_poll_ioctl(board, arg);
 785		goto done;
 786	case IBRSV:
 787		retval = request_service_ioctl(board, arg);
 788		goto done;
 789	case IBRSV2:
 790		retval = request_service2_ioctl(board, arg);
 791		goto done;
 792	case IBSIC:
 793		retval = interface_clear_ioctl(board, arg);
 794		goto done;
 795	case IBSRE:
 796		retval = remote_enable_ioctl(board, arg);
 797		goto done;
 798	case IBTMO:
 799		retval = timeout_ioctl(board, arg);
 800		goto done;
 801	case IBWRT:
 802		/*
 803		 * IO ioctls can take a long time, we need to unlock board->big_gpib_mutex
 804		 * before we call them.
 805		 */
 806		mutex_unlock(&board->big_gpib_mutex);
 807		return write_ioctl(file_priv, board, arg);
 808	default:
 809		retval = -ENOTTY;
 810		goto done;
 811	}
 812
 813done:
 814	mutex_unlock(&board->big_gpib_mutex);
 815	dev_dbg(board->gpib_dev, "ioctl done status = 0x%lx\n", board->status);
 816	return retval;
 817}
 818
 819static int board_type_ioctl(struct gpib_file_private *file_priv,
 820			    struct gpib_board *board, unsigned long arg)
 821{
 822	struct list_head *list_ptr;
 823	struct gpib_board_type_ioctl cmd;
 824	int retval;
 825
 826	if (!capable(CAP_SYS_ADMIN))
 827		return -EPERM;
 828	if (board->online)
 829		return -EBUSY;
 830
 831	retval = copy_from_user(&cmd, (void __user *)arg,
 832				sizeof(struct gpib_board_type_ioctl));
 833	if (retval)
 834		return -EFAULT;
 835
 836	for (list_ptr = registered_drivers.next; list_ptr != &registered_drivers;
 837	     list_ptr = list_ptr->next) {
 838		struct gpib_interface_list *entry;
 839
 840		entry = list_entry(list_ptr, struct gpib_interface_list, list);
 841		if (strcmp(entry->interface->name, cmd.name) == 0) {
 842			int i;
 843			int had_module = file_priv->got_module;
 844
 845			if (board->use_count) {
 846				for (i = 0; i < board->use_count; ++i)
 847					module_put(board->provider_module);
 848				board->interface = NULL;
 849				file_priv->got_module = 0;
 850			}
 851			board->interface = entry->interface;
 852			board->provider_module = entry->module;
 853			for (i = 0; i < board->use_count; ++i) {
 854				if (!try_module_get(entry->module)) {
 855					board->use_count = i;
 856					return -EIO;
 857				}
 858			}
 859			if (had_module == 0) {
 860				if (!try_module_get(entry->module))
 861					return -EIO;
 862				++board->use_count;
 863			}
 864			file_priv->got_module = 1;
 865			return 0;
 866		}
 867	}
 868
 869	return -EINVAL;
 870}
 871
 872static int read_ioctl(struct gpib_file_private *file_priv, struct gpib_board *board,
 873		      unsigned long arg)
 874{
 875	struct gpib_read_write_ioctl read_cmd;
 876	u8 __user *userbuf;
 877	unsigned long remain;
 878	int end_flag = 0;
 879	int retval;
 880	ssize_t read_ret = 0;
 881	struct gpib_descriptor *desc;
 882	size_t nbytes;
 883
 884	retval = copy_from_user(&read_cmd, (void __user *)arg, sizeof(read_cmd));
 885	if (retval)
 886		return -EFAULT;
 887
 888	if (read_cmd.completed_transfer_count > read_cmd.requested_transfer_count)
 889		return -EINVAL;
 890
 891	if (WARN_ON_ONCE(sizeof(userbuf) > sizeof(read_cmd.buffer_ptr)))
 892		return -EFAULT;
 893
 894	userbuf = (u8 __user *)(unsigned long)read_cmd.buffer_ptr;
 895	userbuf += read_cmd.completed_transfer_count;
 896
 897	remain = read_cmd.requested_transfer_count - read_cmd.completed_transfer_count;
 898
 899	/* Check write access to buffer */
 900	if (!access_ok(userbuf, remain))
 901		return -EFAULT;
 902
 903	/* Lock descriptors to prevent concurrent close from freeing descriptor */
 904	if (mutex_lock_interruptible(&file_priv->descriptors_mutex))
 905		return -ERESTARTSYS;
 906	desc = handle_to_descriptor(file_priv, read_cmd.handle);
 907	if (!desc) {
 908		mutex_unlock(&file_priv->descriptors_mutex);
 909		return -EINVAL;
 910	}
 911	atomic_inc(&desc->descriptor_busy);
 912	mutex_unlock(&file_priv->descriptors_mutex);
 913
 914	atomic_set(&desc->io_in_progress, 1);
 915
 916	/* Read buffer loads till we fill the user supplied buffer */
 917	while (remain > 0 && end_flag == 0) {
 918		nbytes = 0;
 919		read_ret = ibrd(board, board->buffer, (board->buffer_length < remain) ?
 920				board->buffer_length : remain, &end_flag, &nbytes);
 921		if (nbytes == 0)
 922			break;
 923		retval = copy_to_user(userbuf, board->buffer, nbytes);
 924		if (retval) {
 925			retval = -EFAULT;
 926			break;
 927		}
 928		remain -= nbytes;
 929		userbuf += nbytes;
 930		if (read_ret < 0)
 931			break;
 932	}
 933	read_cmd.completed_transfer_count = read_cmd.requested_transfer_count - remain;
 934	read_cmd.end = end_flag;
 935	/*
 936	 * suppress errors (for example due to timeout or interruption by device clear)
 937	 * if all bytes got sent.  This prevents races that can occur in the various drivers
 938	 * if a device receives a device clear immediately after a transfer completes and
 939	 * the driver code wasn't careful enough to handle that case.
 940	 */
 941	if (remain == 0 || end_flag)
 942		read_ret = 0;
 943	if (retval == 0)
 944		retval = copy_to_user((void __user *)arg, &read_cmd, sizeof(read_cmd));
 945
 946	atomic_set(&desc->io_in_progress, 0);
 947	atomic_dec(&desc->descriptor_busy);
 948
 949	wake_up_interruptible(&board->wait);
 950	if (retval)
 951		return -EFAULT;
 952
 953	return read_ret;
 954}
 955
 956static int command_ioctl(struct gpib_file_private *file_priv,
 957			 struct gpib_board *board, unsigned long arg)
 958{
 959	struct gpib_read_write_ioctl cmd;
 960	u8 __user *userbuf;
 961	unsigned long remain;
 962	int retval;
 963	int fault = 0;
 964	struct gpib_descriptor *desc;
 965	size_t bytes_written;
 966	int no_clear_io_in_prog;
 967
 968	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
 969	if (retval)
 970		return -EFAULT;
 971
 972	if (cmd.completed_transfer_count > cmd.requested_transfer_count)
 973		return -EINVAL;
 974
 975	userbuf = (u8 __user *)(unsigned long)cmd.buffer_ptr;
 976	userbuf += cmd.completed_transfer_count;
 977
 978	no_clear_io_in_prog = cmd.end;
 979	cmd.end = 0;
 980
 981	remain = cmd.requested_transfer_count - cmd.completed_transfer_count;
 982
 983	/* Check read access to buffer */
 984	if (!access_ok(userbuf, remain))
 985		return -EFAULT;
 986
 987	/* Lock descriptors to prevent concurrent close from freeing descriptor */
 988	if (mutex_lock_interruptible(&file_priv->descriptors_mutex))
 989		return -ERESTARTSYS;
 990	desc = handle_to_descriptor(file_priv, cmd.handle);
 991	if (!desc) {
 992		mutex_unlock(&file_priv->descriptors_mutex);
 993		return -EINVAL;
 994	}
 995	atomic_inc(&desc->descriptor_busy);
 996	mutex_unlock(&file_priv->descriptors_mutex);
 997
 998	/*
 999	 * Write buffer loads till we empty the user supplied buffer.
1000	 * Call drivers at least once, even if remain is zero, in
1001	 * order to allow them to insure previous commands were
1002	 * completely finished, in the case of a restarted ioctl.
1003	 */
1004
1005	atomic_set(&desc->io_in_progress, 1);
1006
1007	do {
1008		fault = copy_from_user(board->buffer, userbuf, (board->buffer_length < remain) ?
1009				       board->buffer_length : remain);
1010		if (fault) {
1011			retval = -EFAULT;
1012			bytes_written = 0;
1013		} else {
1014			retval = ibcmd(board, board->buffer, (board->buffer_length < remain) ?
1015				       board->buffer_length : remain, &bytes_written);
1016		}
1017		remain -= bytes_written;
1018		userbuf += bytes_written;
1019		if (retval < 0) {
1020			atomic_set(&desc->io_in_progress, 0);
1021			atomic_dec(&desc->descriptor_busy);
1022
1023			wake_up_interruptible(&board->wait);
1024			break;
1025		}
1026	} while (remain > 0);
1027
1028	cmd.completed_transfer_count = cmd.requested_transfer_count - remain;
1029
1030	if (fault == 0)
1031		fault = copy_to_user((void __user *)arg, &cmd, sizeof(cmd));
1032
1033	/*
1034	 * no_clear_io_in_prog (cmd.end) is true when io_in_progress should
1035	 * not be set to zero because the cmd in progress is the address setup
1036	 * operation for an async read or write. This causes CMPL not to be set
1037	 * in general_ibstatus until the async read or write completes.
1038	 */
1039	if (!no_clear_io_in_prog || fault)
1040		atomic_set(&desc->io_in_progress, 0);
1041	atomic_dec(&desc->descriptor_busy);
1042
1043	wake_up_interruptible(&board->wait);
1044	if (fault)
1045		return -EFAULT;
1046
1047	return retval;
1048}
1049
1050static int write_ioctl(struct gpib_file_private *file_priv, struct gpib_board *board,
1051		       unsigned long arg)
1052{
1053	struct gpib_read_write_ioctl write_cmd;
1054	u8 __user *userbuf;
1055	unsigned long remain;
1056	int retval = 0;
1057	int fault;
1058	struct gpib_descriptor *desc;
1059
1060	fault = copy_from_user(&write_cmd, (void __user *)arg, sizeof(write_cmd));
1061	if (fault)
1062		return -EFAULT;
1063
1064	if (write_cmd.completed_transfer_count > write_cmd.requested_transfer_count)
1065		return -EINVAL;
1066
1067	userbuf = (u8 __user *)(unsigned long)write_cmd.buffer_ptr;
1068	userbuf += write_cmd.completed_transfer_count;
1069
1070	remain = write_cmd.requested_transfer_count - write_cmd.completed_transfer_count;
1071
1072	/* Check read access to buffer */
1073	if (!access_ok(userbuf, remain))
1074		return -EFAULT;
1075
1076	/* Lock descriptors to prevent concurrent close from freeing descriptor */
1077	if (mutex_lock_interruptible(&file_priv->descriptors_mutex))
1078		return -ERESTARTSYS;
1079	desc = handle_to_descriptor(file_priv, write_cmd.handle);
1080	if (!desc) {
1081		mutex_unlock(&file_priv->descriptors_mutex);
1082		return -EINVAL;
1083	}
1084	atomic_inc(&desc->descriptor_busy);
1085	mutex_unlock(&file_priv->descriptors_mutex);
1086
1087	atomic_set(&desc->io_in_progress, 1);
1088
1089	/* Write buffer loads till we empty the user supplied buffer */
1090	while (remain > 0) {
1091		int send_eoi;
1092		size_t bytes_written = 0;
1093
1094		send_eoi = remain <= board->buffer_length && write_cmd.end;
1095		fault = copy_from_user(board->buffer, userbuf, (board->buffer_length < remain) ?
1096				       board->buffer_length : remain);
1097		if (fault) {
1098			retval = -EFAULT;
1099			break;
1100		}
1101		retval = ibwrt(board, board->buffer, (board->buffer_length < remain) ?
1102			       board->buffer_length : remain, send_eoi, &bytes_written);
1103		remain -= bytes_written;
1104		userbuf += bytes_written;
1105		if (retval < 0)
1106			break;
1107	}
1108	write_cmd.completed_transfer_count = write_cmd.requested_transfer_count - remain;
1109	/*
1110	 * suppress errors (for example due to timeout or interruption by device clear)
1111	 * if all bytes got sent.  This prevents races that can occur in the various drivers
1112	 * if a device receives a device clear immediately after a transfer completes and
1113	 * the driver code wasn't careful enough to handle that case.
1114	 */
1115	if (remain == 0)
1116		retval = 0;
1117	if (fault == 0)
1118		fault = copy_to_user((void __user *)arg, &write_cmd, sizeof(write_cmd));
1119
1120	atomic_set(&desc->io_in_progress, 0);
1121	atomic_dec(&desc->descriptor_busy);
1122
1123	wake_up_interruptible(&board->wait);
1124	if (fault)
1125		return -EFAULT;
1126
1127	return retval;
1128}
1129
1130static int status_bytes_ioctl(struct gpib_board *board, unsigned long arg)
1131{
1132	struct gpib_status_queue *device;
1133	struct gpib_spoll_bytes_ioctl cmd;
1134	int retval;
1135
1136	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
1137	if (retval)
1138		return -EFAULT;
1139
1140	device = get_gpib_status_queue(board, cmd.pad, cmd.sad);
1141	if (!device)
1142		cmd.num_bytes = 0;
1143	else
1144		cmd.num_bytes = num_status_bytes(device);
1145
1146	retval = copy_to_user((void __user *)arg, &cmd, sizeof(cmd));
1147	if (retval)
1148		return -EFAULT;
1149
1150	return 0;
1151}
1152
1153static int increment_open_device_count(struct gpib_board *board, struct list_head *head,
1154				       unsigned int pad, int sad)
1155{
1156	struct list_head *list_ptr;
1157	struct gpib_status_queue *device;
1158
1159	/*
1160	 * first see if address has already been opened, then increment
1161	 * open count
1162	 */
1163	for (list_ptr = head->next; list_ptr != head; list_ptr = list_ptr->next) {
1164		device = list_entry(list_ptr, struct gpib_status_queue, list);
1165		if (gpib_address_equal(device->pad, device->sad, pad, sad)) {
1166			dev_dbg(board->gpib_dev, "incrementing open count for pad %i, sad %i\n",
1167				device->pad, device->sad);
1168			device->reference_count++;
1169			return 0;
1170		}
1171	}
1172
1173	/* otherwise we need to allocate a new struct gpib_status_queue */
1174	device = kmalloc(sizeof(struct gpib_status_queue), GFP_ATOMIC);
1175	if (!device)
1176		return -ENOMEM;
1177	init_gpib_status_queue(device);
1178	device->pad = pad;
1179	device->sad = sad;
1180	device->reference_count = 1;
1181
1182	list_add(&device->list, head);
1183
1184	dev_dbg(board->gpib_dev, "opened pad %i, sad %i\n", device->pad, device->sad);
1185
1186	return 0;
1187}
1188
1189static int subtract_open_device_count(struct gpib_board *board, struct list_head *head,
1190				      unsigned int pad, int sad, unsigned int count)
1191{
1192	struct gpib_status_queue *device;
1193	struct list_head *list_ptr;
1194
1195	for (list_ptr = head->next; list_ptr != head; list_ptr = list_ptr->next) {
1196		device = list_entry(list_ptr, struct gpib_status_queue, list);
1197		if (gpib_address_equal(device->pad, device->sad, pad, sad)) {
1198			dev_dbg(board->gpib_dev, "decrementing open count for pad %i, sad %i\n",
1199				device->pad, device->sad);
1200			if (count > device->reference_count) {
1201				dev_err(board->gpib_dev, "bug! in %s()\n", __func__);
1202				return -EINVAL;
1203			}
1204			device->reference_count -= count;
1205			if (device->reference_count == 0) {
1206				dev_dbg(board->gpib_dev, "closing pad %i, sad %i\n",
1207					device->pad, device->sad);
1208				list_del(list_ptr);
1209				kfree(device);
1210			}
1211			return 0;
1212		}
1213	}
1214	dev_err(board->gpib_dev, "bug! tried to close address that was never opened!\n");
1215	return -EINVAL;
1216}
1217
1218static inline int decrement_open_device_count(struct gpib_board *board, struct list_head *head,
1219					      unsigned int pad, int sad)
1220{
1221	return subtract_open_device_count(board, head, pad, sad, 1);
1222}
1223
1224static int cleanup_open_devices(struct gpib_file_private *file_priv, struct gpib_board *board)
1225{
1226	int retval = 0;
1227	int i;
1228
1229	for (i = 0; i < GPIB_MAX_NUM_DESCRIPTORS; i++) {
1230		struct gpib_descriptor *desc;
1231
1232		desc = file_priv->descriptors[i];
1233		if (!desc)
1234			continue;
1235
1236		if (desc->is_board == 0) {
1237			retval = decrement_open_device_count(board, &board->device_list, desc->pad,
1238							     desc->sad);
1239			if (retval < 0)
1240				return retval;
1241		}
1242		kfree(desc);
1243		file_priv->descriptors[i] = NULL;
1244	}
1245
1246	return 0;
1247}
1248
1249static int open_dev_ioctl(struct file *filep, struct gpib_board *board, unsigned long arg)
1250{
1251	struct gpib_open_dev_ioctl open_dev_cmd;
1252	int retval;
1253	struct gpib_file_private *file_priv = filep->private_data;
1254	int i;
1255
1256	retval = copy_from_user(&open_dev_cmd, (void __user *)arg, sizeof(open_dev_cmd));
1257	if (retval)
1258		return -EFAULT;
1259
1260	if (mutex_lock_interruptible(&file_priv->descriptors_mutex))
1261		return -ERESTARTSYS;
1262	for (i = 0; i < GPIB_MAX_NUM_DESCRIPTORS; i++)
1263		if (!file_priv->descriptors[i])
1264			break;
1265	if (i == GPIB_MAX_NUM_DESCRIPTORS) {
1266		mutex_unlock(&file_priv->descriptors_mutex);
1267		return -ERANGE;
1268	}
1269	file_priv->descriptors[i] = kmalloc(sizeof(struct gpib_descriptor), GFP_KERNEL);
1270	if (!file_priv->descriptors[i]) {
1271		mutex_unlock(&file_priv->descriptors_mutex);
1272		return -ENOMEM;
1273	}
1274	init_gpib_descriptor(file_priv->descriptors[i]);
1275
1276	file_priv->descriptors[i]->pad = open_dev_cmd.pad;
1277	file_priv->descriptors[i]->sad = open_dev_cmd.sad;
1278	file_priv->descriptors[i]->is_board = open_dev_cmd.is_board;
1279	mutex_unlock(&file_priv->descriptors_mutex);
1280
1281	retval = increment_open_device_count(board, &board->device_list, open_dev_cmd.pad,
1282					     open_dev_cmd.sad);
1283	if (retval < 0)
1284		return retval;
1285
1286	/*
1287	 * clear stuck srq state, since we may be able to find service request on
1288	 * the new device
1289	 */
1290	atomic_set(&board->stuck_srq, 0);
1291
1292	open_dev_cmd.handle = i;
1293	retval = copy_to_user((void __user *)arg, &open_dev_cmd, sizeof(open_dev_cmd));
1294	if (retval)
1295		return -EFAULT;
1296
1297	return 0;
1298}
1299
1300static int close_dev_ioctl(struct file *filep, struct gpib_board *board, unsigned long arg)
1301{
1302	struct gpib_close_dev_ioctl cmd;
1303	struct gpib_file_private *file_priv = filep->private_data;
1304	struct gpib_descriptor *desc;
1305	unsigned int pad;
1306	int sad;
1307	int retval;
1308
1309	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
1310	if (retval)
1311		return -EFAULT;
1312
1313	if (cmd.handle >= GPIB_MAX_NUM_DESCRIPTORS)
1314		return -EINVAL;
1315
1316	mutex_lock(&file_priv->descriptors_mutex);
1317	desc = file_priv->descriptors[cmd.handle];
1318	if (!desc) {
1319		mutex_unlock(&file_priv->descriptors_mutex);
1320		return -EINVAL;
1321	}
1322	if (atomic_read(&desc->descriptor_busy)) {
1323		mutex_unlock(&file_priv->descriptors_mutex);
1324		return -EBUSY;
1325	}
1326	/* Remove from table while holding lock to prevent new IO from starting */
1327	file_priv->descriptors[cmd.handle] = NULL;
1328	pad = desc->pad;
1329	sad = desc->sad;
1330	mutex_unlock(&file_priv->descriptors_mutex);
1331
1332	retval = decrement_open_device_count(board, &board->device_list, pad, sad);
1333
1334	kfree(desc);
1335	return retval;
1336}
1337
1338static int serial_poll_ioctl(struct gpib_board *board, unsigned long arg)
1339{
1340	struct gpib_serial_poll_ioctl serial_cmd;
1341	int retval;
1342
1343	retval = copy_from_user(&serial_cmd, (void __user *)arg, sizeof(serial_cmd));
1344	if (retval)
1345		return -EFAULT;
1346
1347	retval = get_serial_poll_byte(board, serial_cmd.pad, serial_cmd.sad, board->usec_timeout,
1348				      &serial_cmd.status_byte);
1349	if (retval < 0)
1350		return retval;
1351
1352	retval = copy_to_user((void __user *)arg, &serial_cmd, sizeof(serial_cmd));
1353	if (retval)
1354		return -EFAULT;
1355
1356	return 0;
1357}
1358
1359static int wait_ioctl(struct gpib_file_private *file_priv, struct gpib_board *board,
1360		      unsigned long arg)
1361{
1362	struct gpib_wait_ioctl wait_cmd;
1363	int retval;
1364	struct gpib_descriptor *desc;
1365
1366	retval = copy_from_user(&wait_cmd, (void __user *)arg, sizeof(wait_cmd));
1367	if (retval)
1368		return -EFAULT;
1369
1370	/*
1371	 * Lock descriptors to prevent concurrent close from freeing
1372	 * descriptor.  ibwait() releases big_gpib_mutex when wait_mask
1373	 * is non-zero, so desc must be pinned with descriptor_busy.
1374	 */
1375	mutex_lock(&file_priv->descriptors_mutex);
1376	desc = handle_to_descriptor(file_priv, wait_cmd.handle);
1377	if (!desc) {
1378		mutex_unlock(&file_priv->descriptors_mutex);
1379		return -EINVAL;
1380	}
1381	atomic_inc(&desc->descriptor_busy);
1382	mutex_unlock(&file_priv->descriptors_mutex);
1383
1384	retval = ibwait(board, wait_cmd.wait_mask, wait_cmd.clear_mask,
1385			wait_cmd.set_mask, &wait_cmd.ibsta, wait_cmd.usec_timeout, desc);
1386
1387	atomic_dec(&desc->descriptor_busy);
1388
1389	if (retval < 0)
1390		return retval;
1391
1392	retval = copy_to_user((void __user *)arg, &wait_cmd, sizeof(wait_cmd));
1393	if (retval)
1394		return -EFAULT;
1395
1396	return 0;
1397}
1398
1399static int parallel_poll_ioctl(struct gpib_board *board, unsigned long arg)
1400{
1401	u8 poll_byte;
1402	int retval;
1403
1404	retval = ibrpp(board, &poll_byte);
1405	if (retval < 0)
1406		return retval;
1407
1408	retval = copy_to_user((void __user *)arg, &poll_byte, sizeof(poll_byte));
1409	if (retval)
1410		return -EFAULT;
1411
1412	return 0;
1413}
1414
1415static int online_ioctl(struct gpib_board *board, unsigned long arg)
1416{
1417	struct gpib_online_ioctl online_cmd;
1418	int retval;
1419	void __user *init_data = NULL;
1420
1421	board->config.init_data = NULL;
1422
1423	if (!capable(CAP_SYS_ADMIN))
1424		return -EPERM;
1425
1426	retval = copy_from_user(&online_cmd, (void __user *)arg, sizeof(online_cmd));
1427	if (retval)
1428		return -EFAULT;
1429	if (online_cmd.init_data_length > 0) {
1430		board->config.init_data = vmalloc(online_cmd.init_data_length);
1431		if (!board->config.init_data)
1432			return -ENOMEM;
1433		if (WARN_ON_ONCE(sizeof(init_data) > sizeof(online_cmd.init_data_ptr)))
1434			return -EFAULT;
1435		init_data = (void __user *)(unsigned long)(online_cmd.init_data_ptr);
1436		retval = copy_from_user(board->config.init_data, init_data,
1437					online_cmd.init_data_length);
1438		if (retval) {
1439			vfree(board->config.init_data);
1440			return -EFAULT;
1441		}
1442		board->config.init_data_length = online_cmd.init_data_length;
1443	} else {
1444		board->config.init_data = NULL;
1445		board->config.init_data_length = 0;
1446	}
1447	if (online_cmd.online)
1448		retval = ibonline(board);
1449	else
1450		retval = iboffline(board);
1451	if (board->config.init_data) {
1452		vfree(board->config.init_data);
1453		board->config.init_data = NULL;
1454		board->config.init_data_length = 0;
1455	}
1456	return retval;
1457}
1458
1459static int remote_enable_ioctl(struct gpib_board *board, unsigned long arg)
1460{
1461	int enable;
1462	int retval;
1463
1464	retval = copy_from_user(&enable, (void __user *)arg, sizeof(enable));
1465	if (retval)
1466		return -EFAULT;
1467
1468	return ibsre(board, enable);
1469}
1470
1471static int take_control_ioctl(struct gpib_board *board, unsigned long arg)
1472{
1473	int synchronous;
1474	int retval;
1475
1476	retval = copy_from_user(&synchronous, (void __user *)arg, sizeof(synchronous));
1477	if (retval)
1478		return -EFAULT;
1479
1480	return ibcac(board, synchronous, 1);
1481}
1482
1483static int line_status_ioctl(struct gpib_board *board, unsigned long arg)
1484{
1485	short lines;
1486	int retval;
1487
1488	retval = iblines(board, &lines);
1489	if (retval < 0)
1490		return retval;
1491
1492	retval = copy_to_user((void __user *)arg, &lines, sizeof(lines));
1493	if (retval)
1494		return -EFAULT;
1495
1496	return 0;
1497}
1498
1499static int pad_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
1500		     unsigned long arg)
1501{
1502	struct gpib_pad_ioctl cmd;
1503	int retval;
1504	struct gpib_descriptor *desc;
1505
1506	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
1507	if (retval)
1508		return -EFAULT;
1509
1510	desc = handle_to_descriptor(file_priv, cmd.handle);
1511	if (!desc)
1512		return -EINVAL;
1513
1514	if (desc->is_board) {
1515		retval = ibpad(board, cmd.pad);
1516		if (retval < 0)
1517			return retval;
1518	} else {
1519		retval = decrement_open_device_count(board, &board->device_list, desc->pad,
1520						     desc->sad);
1521		if (retval < 0)
1522			return retval;
1523
1524		desc->pad = cmd.pad;
1525
1526		retval = increment_open_device_count(board, &board->device_list, desc->pad,
1527						     desc->sad);
1528		if (retval < 0)
1529			return retval;
1530	}
1531
1532	return 0;
1533}
1534
1535static int sad_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
1536		     unsigned long arg)
1537{
1538	struct gpib_sad_ioctl cmd;
1539	int retval;
1540	struct gpib_descriptor *desc;
1541
1542	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
1543	if (retval)
1544		return -EFAULT;
1545
1546	desc = handle_to_descriptor(file_priv, cmd.handle);
1547	if (!desc)
1548		return -EINVAL;
1549
1550	if (desc->is_board) {
1551		retval = ibsad(board, cmd.sad);
1552		if (retval < 0)
1553			return retval;
1554	} else {
1555		retval = decrement_open_device_count(board, &board->device_list, desc->pad,
1556						     desc->sad);
1557		if (retval < 0)
1558			return retval;
1559
1560		desc->sad = cmd.sad;
1561
1562		retval = increment_open_device_count(board, &board->device_list, desc->pad,
1563						     desc->sad);
1564		if (retval < 0)
1565			return retval;
1566	}
1567	return 0;
1568}
1569
1570static int eos_ioctl(struct gpib_board *board, unsigned long arg)
1571{
1572	struct gpib_eos_ioctl eos_cmd;
1573	int retval;
1574
1575	retval = copy_from_user(&eos_cmd, (void __user *)arg, sizeof(eos_cmd));
1576	if (retval)
1577		return -EFAULT;
1578
1579	return ibeos(board, eos_cmd.eos, eos_cmd.eos_flags);
1580}
1581
1582static int request_service_ioctl(struct gpib_board *board, unsigned long arg)
1583{
1584	u8 status_byte;
1585	int retval;
1586
1587	retval = copy_from_user(&status_byte, (void __user *)arg, sizeof(status_byte));
1588	if (retval)
1589		return -EFAULT;
1590
1591	return ibrsv2(board, status_byte, status_byte & request_service_bit);
1592}
1593
1594static int request_service2_ioctl(struct gpib_board *board, unsigned long arg)
1595{
1596	struct gpib_request_service2 request_service2_cmd;
1597	int retval;
1598
1599	retval = copy_from_user(&request_service2_cmd, (void __user *)arg,
1600				sizeof(struct gpib_request_service2));
1601	if (retval)
1602		return -EFAULT;
1603
1604	return ibrsv2(board, request_service2_cmd.status_byte,
1605		      request_service2_cmd.new_reason_for_service);
1606}
1607
1608static int iobase_ioctl(struct gpib_board_config *config, unsigned long arg)
1609{
1610	u64 base_addr;
1611	int retval;
1612
1613	if (!capable(CAP_SYS_ADMIN))
1614		return -EPERM;
1615
1616	retval = copy_from_user(&base_addr, (void __user *)arg, sizeof(base_addr));
1617	if (retval)
1618		return -EFAULT;
1619
1620	if (WARN_ON_ONCE(sizeof(void *) > sizeof(base_addr)))
1621		return -EFAULT;
1622	config->ibbase = base_addr;
1623
1624	return 0;
1625}
1626
1627static int irq_ioctl(struct gpib_board_config *config, unsigned long arg)
1628{
1629	unsigned int irq;
1630	int retval;
1631
1632	if (!capable(CAP_SYS_ADMIN))
1633		return -EPERM;
1634
1635	retval = copy_from_user(&irq, (void __user *)arg, sizeof(irq));
1636	if (retval)
1637		return -EFAULT;
1638
1639	config->ibirq = irq;
1640
1641	return 0;
1642}
1643
1644static int dma_ioctl(struct gpib_board_config *config, unsigned long arg)
1645{
1646	unsigned int dma_channel;
1647	int retval;
1648
1649	if (!capable(CAP_SYS_ADMIN))
1650		return -EPERM;
1651
1652	retval = copy_from_user(&dma_channel, (void __user *)arg, sizeof(dma_channel));
1653	if (retval)
1654		return -EFAULT;
1655
1656	config->ibdma = dma_channel;
1657
1658	return 0;
1659}
1660
1661static int autospoll_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
1662			   unsigned long arg)
1663{
1664	short enable;
1665	int retval;
1666	struct gpib_descriptor *desc;
1667
1668	retval = copy_from_user(&enable, (void __user *)arg, sizeof(enable));
1669	if (retval)
1670		return -EFAULT;
1671
1672	desc = handle_to_descriptor(file_priv, 0); /* board handle is 0 */
1673
1674	if (enable) {
1675		if (!desc->autopoll_enabled) {
1676			board->autospollers++;
1677			desc->autopoll_enabled = 1;
1678		}
1679		retval = 0;
1680	} else {
1681		if (desc->autopoll_enabled) {
1682			desc->autopoll_enabled = 0;
1683			if (board->autospollers > 0) {
1684				board->autospollers--;
1685				retval = 0;
1686			} else {
1687				dev_err(board->gpib_dev,
1688					"tried to set number of autospollers negative\n");
1689				retval = -EINVAL;
1690			}
1691		} else {
1692			dev_err(board->gpib_dev, "autopoll disable requested before enable\n");
1693			retval = -EINVAL;
1694		}
1695	}
1696	return retval;
1697}
1698
1699static int mutex_ioctl(struct gpib_board *board, struct gpib_file_private *file_priv,
1700		       unsigned long arg)
1701{
1702	int retval, lock_mutex;
1703
1704	retval = copy_from_user(&lock_mutex, (void __user *)arg, sizeof(lock_mutex));
1705	if (retval)
1706		return -EFAULT;
1707
1708	if (lock_mutex)	{
1709		retval = mutex_lock_interruptible(&board->user_mutex);
1710		if (retval)
1711			return -ERESTARTSYS;
1712
1713		spin_lock(&board->locking_pid_spinlock);
1714		board->locking_pid = current->pid;
1715		spin_unlock(&board->locking_pid_spinlock);
1716
1717		atomic_set(&file_priv->holding_mutex, 1);
1718
1719		dev_dbg(board->gpib_dev, "locked board mutex\n");
1720	} else {
1721		spin_lock(&board->locking_pid_spinlock);
1722		if (current->pid != board->locking_pid) {
1723			dev_err(board->gpib_dev, "bug! pid %i tried to release mutex held by pid %i\n",
1724				current->pid, board->locking_pid);
1725			spin_unlock(&board->locking_pid_spinlock);
1726			return -EPERM;
1727		}
1728		board->locking_pid = 0;
1729		spin_unlock(&board->locking_pid_spinlock);
1730
1731		atomic_set(&file_priv->holding_mutex, 0);
1732
1733		mutex_unlock(&board->user_mutex);
1734		dev_dbg(board->gpib_dev, "unlocked board mutex\n");
1735	}
1736	return 0;
1737}
1738
1739static int timeout_ioctl(struct gpib_board *board, unsigned long arg)
1740{
1741	unsigned int timeout;
1742	int retval;
1743
1744	retval = copy_from_user(&timeout, (void __user *)arg, sizeof(timeout));
1745	if (retval)
1746		return -EFAULT;
1747
1748	board->usec_timeout = timeout;
1749	dev_dbg(board->gpib_dev, "timeout set to %i usec\n", timeout);
1750
1751	return 0;
1752}
1753
1754static int ppc_ioctl(struct gpib_board *board, unsigned long arg)
1755{
1756	struct gpib_ppoll_config_ioctl cmd;
1757	int retval;
1758
1759	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
1760	if (retval)
1761		return -EFAULT;
1762
1763	if (cmd.set_ist) {
1764		board->ist = 1;
1765		board->interface->parallel_poll_response(board, board->ist);
1766	} else if (cmd.clear_ist) {
1767		board->ist = 0;
1768		board->interface->parallel_poll_response(board, board->ist);
1769	}
1770
1771	if (cmd.config)	{
1772		retval = ibppc(board, cmd.config);
1773		if (retval < 0)
1774			return retval;
1775	}
1776
1777	return 0;
1778}
1779
1780static int set_local_ppoll_mode_ioctl(struct gpib_board *board, unsigned long arg)
1781{
1782	short cmd;
1783	int retval;
1784
1785	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
1786	if (retval)
1787		return -EFAULT;
1788
1789	if (!board->interface->local_parallel_poll_mode)
1790		return -ENOENT;
1791	board->local_ppoll_mode = cmd != 0;
1792	board->interface->local_parallel_poll_mode(board, board->local_ppoll_mode);
1793
1794	return 0;
1795}
1796
1797static int get_local_ppoll_mode_ioctl(struct gpib_board *board, unsigned long arg)
1798{
1799	short cmd;
1800	int retval;
1801
1802	cmd = board->local_ppoll_mode;
1803	retval = copy_to_user((void __user *)arg, &cmd, sizeof(cmd));
1804	if (retval)
1805		return -EFAULT;
1806
1807	return 0;
1808}
1809
1810static int query_board_rsv_ioctl(struct gpib_board *board, unsigned long arg)
1811{
1812	int status;
1813	int retval;
1814
1815	status = board->interface->serial_poll_status(board);
1816
1817	retval = copy_to_user((void __user *)arg, &status, sizeof(status));
1818	if (retval)
1819		return -EFAULT;
1820
1821	return 0;
1822}
1823
1824static int board_info_ioctl(const struct gpib_board *board, unsigned long arg)
1825{
1826	struct gpib_board_info_ioctl info = { };
1827	int retval;
1828
1829	info.pad = board->pad;
1830	info.sad = board->sad;
1831	info.parallel_poll_configuration = board->parallel_poll_configuration;
1832	info.is_system_controller = board->master;
1833	if (board->autospollers)
1834		info.autopolling = 1;
1835	else
1836		info.autopolling = 0;
1837	info.t1_delay = board->t1_nano_sec;
1838	info.ist = board->ist;
1839	info.no_7_bit_eos = board->interface->no_7_bit_eos;
1840	retval = copy_to_user((void __user *)arg, &info, sizeof(info));
1841	if (retval)
1842		return -EFAULT;
1843
1844	return 0;
1845}
1846
1847static int interface_clear_ioctl(struct gpib_board *board, unsigned long arg)
1848{
1849	unsigned int usec_duration;
1850	int retval;
1851
1852	retval = copy_from_user(&usec_duration, (void __user *)arg, sizeof(usec_duration));
1853	if (retval)
1854		return -EFAULT;
1855
1856	return ibsic(board, usec_duration);
1857}
1858
1859static int select_pci_ioctl(struct gpib_board_config *config, unsigned long arg)
1860{
1861	struct gpib_select_pci_ioctl selection;
1862	int retval;
1863
1864	if (!capable(CAP_SYS_ADMIN))
1865		return -EPERM;
1866
1867	retval = copy_from_user(&selection, (void __user *)arg, sizeof(selection));
1868	if (retval)
1869		return -EFAULT;
1870
1871	config->pci_bus = selection.pci_bus;
1872	config->pci_slot = selection.pci_slot;
1873
1874	return 0;
1875}
1876
1877static int select_device_path_ioctl(struct gpib_board_config *config, unsigned long arg)
1878{
1879	struct gpib_select_device_path_ioctl *selection;
1880	int retval;
1881
1882	if (!capable(CAP_SYS_ADMIN))
1883		return -EPERM;
1884
1885	selection = vmalloc(sizeof(struct gpib_select_device_path_ioctl));
1886	if (!selection)
1887		return -ENOMEM;
1888
1889	retval = copy_from_user(selection, (void __user *)arg,
1890				sizeof(struct gpib_select_device_path_ioctl));
1891	if (retval) {
1892		vfree(selection);
1893		return -EFAULT;
1894	}
1895
1896	selection->device_path[sizeof(selection->device_path) - 1] = '\0';
1897	kfree(config->device_path);
1898	config->device_path = NULL;
1899	if (strlen(selection->device_path) > 0)
1900		config->device_path = kstrdup(selection->device_path, GFP_KERNEL);
1901
1902	vfree(selection);
1903	return 0;
1904}
1905
1906unsigned int num_gpib_events(const struct gpib_event_queue *queue)
1907{
1908	return queue->num_events;
1909}
1910
1911static int push_gpib_event_nolock(struct gpib_board *board, short event_type)
1912{
1913	struct gpib_event_queue *queue = &board->event_queue;
1914	struct list_head *head = &queue->event_head;
1915	struct gpib_event *event;
1916	static const unsigned int max_num_events = 1024;
1917	int retval;
1918
1919	if (num_gpib_events(queue) >= max_num_events) {
1920		short lost_event;
1921
1922		queue->dropped_event = 1;
1923		retval = pop_gpib_event_nolock(board, queue, &lost_event);
1924		if (retval < 0)
1925			return retval;
1926	}
1927
1928	event = kmalloc(sizeof(struct gpib_event), GFP_ATOMIC);
1929	if (!event) {
1930		queue->dropped_event = 1;
1931		dev_err(board->gpib_dev, "failed to allocate memory for event\n");
1932		return -ENOMEM;
1933	}
1934
1935	INIT_LIST_HEAD(&event->list);
1936	event->event_type = event_type;
1937
1938	list_add_tail(&event->list, head);
1939
1940	queue->num_events++;
1941
1942	dev_dbg(board->gpib_dev, "pushed event %i, %i in queue\n",
1943		(int)event_type, num_gpib_events(queue));
1944
1945	return 0;
1946}
1947
1948// push event onto back of event queue
1949int push_gpib_event(struct gpib_board *board, short event_type)
1950{
1951	unsigned long flags;
1952	int retval;
1953
1954	spin_lock_irqsave(&board->event_queue.lock, flags);
1955	retval = push_gpib_event_nolock(board, event_type);
1956	spin_unlock_irqrestore(&board->event_queue.lock, flags);
1957
1958	if (event_type == EVENT_DEV_TRG)
1959		board->status |= DTAS;
1960	if (event_type == EVENT_DEV_CLR)
1961		board->status |= DCAS;
1962
1963	return retval;
1964}
1965EXPORT_SYMBOL(push_gpib_event);
1966
1967static int pop_gpib_event_nolock(struct gpib_board *board,
1968				 struct gpib_event_queue *queue, short *event_type)
1969{
1970	struct list_head *head = &queue->event_head;
1971	struct list_head *front = head->next;
1972	struct gpib_event *event;
1973
1974	if (num_gpib_events(queue) == 0) {
1975		*event_type = EVENT_NONE;
1976		return 0;
1977	}
1978
1979	if (front == head)
1980		return -EIO;
1981
1982	if (queue->dropped_event) {
1983		queue->dropped_event = 0;
1984		return -EPIPE;
1985	}
1986
1987	event = list_entry(front, struct gpib_event, list);
1988	*event_type = event->event_type;
1989
1990	list_del(front);
1991	kfree(event);
1992
1993	queue->num_events--;
1994
1995	dev_dbg(board->gpib_dev, "popped event %i, %i in queue\n",
1996		(int)*event_type, num_gpib_events(queue));
1997
1998	return 0;
1999}
2000
2001// pop event from front of event queue
2002int pop_gpib_event(struct gpib_board *board, struct gpib_event_queue *queue, short *event_type)
2003{
2004	unsigned long flags;
2005	int retval;
2006
2007	spin_lock_irqsave(&queue->lock, flags);
2008	retval = pop_gpib_event_nolock(board, queue, event_type);
2009	spin_unlock_irqrestore(&queue->lock, flags);
2010	return retval;
2011}
2012
2013static int event_ioctl(struct gpib_board *board, unsigned long arg)
2014{
2015	short user_event;
2016	int retval;
2017	short event;
2018
2019	retval = pop_gpib_event(board, &board->event_queue, &event);
2020	if (retval < 0)
2021		return retval;
2022
2023	user_event = event;
2024
2025	retval = copy_to_user((void __user *)arg, &user_event, sizeof(user_event));
2026	if (retval)
2027		return -EFAULT;
2028
2029	return 0;
2030}
2031
2032static int request_system_control_ioctl(struct gpib_board *board, unsigned long arg)
2033{
2034	int request_control;
2035	int retval;
2036
2037	retval = copy_from_user(&request_control, (void __user *)arg, sizeof(request_control));
2038	if (retval)
2039		return -EFAULT;
2040
2041	return ibrsc(board, request_control);
2042}
2043
2044static int t1_delay_ioctl(struct gpib_board *board, unsigned long arg)
2045{
2046	unsigned int cmd;
2047	unsigned int delay;
2048	int retval;
2049
2050	if (!board->interface->t1_delay)
2051		return -ENOENT;
2052
2053	retval = copy_from_user(&cmd, (void __user *)arg, sizeof(cmd));
2054	if (retval)
2055		return -EFAULT;
2056
2057	delay = cmd;
2058
2059	retval = board->interface->t1_delay(board, delay);
2060	if (retval < 0)
2061		return retval;
2062
2063	board->t1_nano_sec = retval;
2064	return 0;
2065}
2066
2067static const struct file_operations ib_fops = {
2068	.owner = THIS_MODULE,
2069	.llseek = NULL,
2070	.unlocked_ioctl = &ibioctl,
2071	.compat_ioctl = &ibioctl,
2072	.open = &ibopen,
2073	.release = &ibclose,
2074};
2075
2076struct gpib_board board_array[GPIB_MAX_NUM_BOARDS];
2077
2078LIST_HEAD(registered_drivers);
2079
2080void init_gpib_descriptor(struct gpib_descriptor *desc)
2081{
2082	desc->pad = 0;
2083	desc->sad = -1;
2084	desc->is_board = 0;
2085	desc->autopoll_enabled = 0;
2086	atomic_set(&desc->io_in_progress, 0);
2087	atomic_set(&desc->descriptor_busy, 0);
2088}
2089
2090int gpib_register_driver(struct gpib_interface *interface, struct module *provider_module)
2091{
2092	struct gpib_interface_list *entry;
2093
2094	entry = kmalloc(sizeof(*entry), GFP_KERNEL);
2095	if (!entry)
2096		return -ENOMEM;
2097
2098	entry->interface = interface;
2099	entry->module = provider_module;
2100	list_add(&entry->list, &registered_drivers);
2101
2102	return 0;
2103}
2104EXPORT_SYMBOL(gpib_register_driver);
2105
2106void gpib_unregister_driver(struct gpib_interface *interface)
2107{
2108	int i;
2109	struct list_head *list_ptr;
2110
2111	for (i = 0; i < GPIB_MAX_NUM_BOARDS; i++) {
2112		struct gpib_board *board = &board_array[i];
2113
2114		if (board->interface == interface) {
2115			if (board->use_count > 0)
2116				pr_warn("gpib: Warning: deregistered interface %s in use\n",
2117					interface->name);
2118			iboffline(board);
2119			board->interface = NULL;
2120		}
2121	}
2122	for (list_ptr = registered_drivers.next; list_ptr != &registered_drivers;) {
2123		struct gpib_interface_list *entry;
2124
2125		entry = list_entry(list_ptr, struct gpib_interface_list, list);
2126		list_ptr = list_ptr->next;
2127		if (entry->interface == interface) {
2128			list_del(&entry->list);
2129			kfree(entry);
2130		}
2131	}
2132}
2133EXPORT_SYMBOL(gpib_unregister_driver);
2134
2135static void init_gpib_board_config(struct gpib_board_config *config)
2136{
2137	memset(config, 0, sizeof(struct gpib_board_config));
2138	config->pci_bus = -1;
2139	config->pci_slot = -1;
2140}
2141
2142void init_gpib_board(struct gpib_board *board)
2143{
2144	board->interface = NULL;
2145	board->provider_module = NULL;
2146	board->buffer = NULL;
2147	board->buffer_length = 0;
2148	board->status = 0;
2149	init_waitqueue_head(&board->wait);
2150	mutex_init(&board->user_mutex);
2151	mutex_init(&board->big_gpib_mutex);
2152	board->locking_pid = 0;
2153	spin_lock_init(&board->locking_pid_spinlock);
2154	spin_lock_init(&board->spinlock);
2155	timer_setup(&board->timer, NULL, 0);
2156	board->dev = NULL;
2157	board->gpib_dev = NULL;
2158	init_gpib_board_config(&board->config);
2159	board->private_data = NULL;
2160	board->use_count = 0;
2161	INIT_LIST_HEAD(&board->device_list);
2162	board->pad = 0;
2163	board->sad = -1;
2164	board->usec_timeout = 3000000;
2165	board->parallel_poll_configuration = 0;
2166	board->online = 0;
2167	board->autospollers = 0;
2168	board->autospoll_task = NULL;
2169	init_event_queue(&board->event_queue);
2170	board->minor = -1;
2171	init_gpib_pseudo_irq(&board->pseudo_irq);
2172	board->master = 1;
2173	atomic_set(&board->stuck_srq, 0);
2174	board->local_ppoll_mode = 0;
2175}
2176
2177int gpib_allocate_board(struct gpib_board *board)
2178{
2179	if (!board->buffer) {
2180		board->buffer_length = 0x4000;
2181		board->buffer = vmalloc(board->buffer_length);
2182		if (!board->buffer) {
2183			board->buffer_length = 0;
2184			return -ENOMEM;
2185		}
2186	}
2187	return 0;
2188}
2189
2190void gpib_deallocate_board(struct gpib_board *board)
2191{
2192	short dummy;
2193
2194	if (board->buffer) {
2195		vfree(board->buffer);
2196		board->buffer = NULL;
2197		board->buffer_length = 0;
2198	}
2199	while (num_gpib_events(&board->event_queue))
2200		pop_gpib_event(board, &board->event_queue, &dummy);
2201}
2202
2203static void init_board_array(struct gpib_board *board_array, unsigned int length)
2204{
2205	int i;
2206
2207	for (i = 0; i < length; i++) {
2208		init_gpib_board(&board_array[i]);
2209		board_array[i].minor = i;
2210	}
2211}
2212
2213void init_gpib_status_queue(struct gpib_status_queue *device)
2214{
2215	INIT_LIST_HEAD(&device->list);
2216	INIT_LIST_HEAD(&device->status_bytes);
2217	device->num_status_bytes = 0;
2218	device->reference_count = 0;
2219	device->dropped_byte = 0;
2220}
2221
2222static struct class *gpib_class;
2223
2224static int __init gpib_common_init_module(void)
2225{
2226	int i;
2227
2228	pr_info("GPIB core driver\n");
2229	init_board_array(board_array, GPIB_MAX_NUM_BOARDS);
2230	if (register_chrdev(GPIB_CODE, "gpib", &ib_fops)) {
2231		pr_err("gpib: can't get major %d\n", GPIB_CODE);
2232		return -EIO;
2233	}
2234	gpib_class = class_create("gpib_common");
2235	if (IS_ERR(gpib_class)) {
2236		pr_err("gpib: failed to create gpib class\n");
2237		unregister_chrdev(GPIB_CODE, "gpib");
2238		return PTR_ERR(gpib_class);
2239	}
2240	for (i = 0; i < GPIB_MAX_NUM_BOARDS; ++i)
2241		board_array[i].gpib_dev = device_create(gpib_class, NULL,
2242							MKDEV(GPIB_CODE, i), NULL, "gpib%i", i);
2243
2244	return 0;
2245}
2246
2247static void __exit gpib_common_exit_module(void)
2248{
2249	int i;
2250
2251	for (i = 0; i < GPIB_MAX_NUM_BOARDS; ++i)
2252		device_destroy(gpib_class, MKDEV(GPIB_CODE, i));
2253
2254	class_destroy(gpib_class);
2255	unregister_chrdev(GPIB_CODE, "gpib");
2256}
2257
2258int gpib_match_device_path(struct device *dev, const char *device_path_in)
2259{
2260	if (device_path_in) {
2261		char *device_path;
2262
2263		device_path = kobject_get_path(&dev->kobj, GFP_KERNEL);
2264		if (!device_path) {
2265			dev_err(dev, "kobject_get_path returned NULL.");
2266			return 0;
2267		}
2268		if (strcmp(device_path_in, device_path) != 0) {
2269			kfree(device_path);
2270			return 0;
2271		}
2272		kfree(device_path);
2273	}
2274	return 1;
2275}
2276EXPORT_SYMBOL(gpib_match_device_path);
2277
2278struct pci_dev *gpib_pci_get_device(const struct gpib_board_config *config, unsigned int vendor_id,
2279				    unsigned int device_id, struct pci_dev *from)
2280{
2281	struct pci_dev *pci_device = from;
2282
2283	while ((pci_device = pci_get_device(vendor_id, device_id, pci_device)))	{
2284		if (config->pci_bus >= 0 && config->pci_bus != pci_device->bus->number)
2285			continue;
2286		if (config->pci_slot >= 0 && config->pci_slot !=
2287		    PCI_SLOT(pci_device->devfn))
2288			continue;
2289		if (gpib_match_device_path(&pci_device->dev, config->device_path) == 0)
2290			continue;
2291		return pci_device;
2292	}
2293	return NULL;
2294}
2295EXPORT_SYMBOL(gpib_pci_get_device);
2296
2297struct pci_dev *gpib_pci_get_subsys(const struct gpib_board_config *config, unsigned int vendor_id,
2298				    unsigned int device_id, unsigned int ss_vendor,
2299				    unsigned int ss_device,
2300				    struct pci_dev *from)
2301{
2302	struct pci_dev *pci_device = from;
2303
2304	while ((pci_device = pci_get_subsys(vendor_id, device_id,
2305					    ss_vendor, ss_device, pci_device))) {
2306		if (config->pci_bus >= 0 && config->pci_bus != pci_device->bus->number)
2307			continue;
2308		if (config->pci_slot >= 0 && config->pci_slot !=
2309		    PCI_SLOT(pci_device->devfn))
2310			continue;
2311		if (gpib_match_device_path(&pci_device->dev, config->device_path) == 0)
2312			continue;
2313		return pci_device;
2314	}
2315	return NULL;
2316}
2317EXPORT_SYMBOL(gpib_pci_get_subsys);
2318
2319module_init(gpib_common_init_module);
2320module_exit(gpib_common_exit_module);
2321