iblib.c

  1// SPDX-License-Identifier: GPL-2.0
  2
  3/***************************************************************************
  4 *    copyright            : (C) 2001, 2002 by Frank Mori Hess
  5 ***************************************************************************/
  6
  7#define dev_fmt(fmt) KBUILD_MODNAME ": " fmt
  8
  9#include "ibsys.h"
 10#include <linux/delay.h>
 11#include <linux/kthread.h>
 12#include <linux/vmalloc.h>
 13
 14/*
 15 * IBCAC
 16 * Return to the controller active state from the
 17 * controller standby state, i.e., turn ATN on.  Note
 18 * that in order to enter the controller active state
 19 * from the controller idle state, ibsic must be called.
 20 * If sync is non-zero, attempt to take control synchronously.
 21 * If fallback_to_async is non-zero, try to take control asynchronously
 22 * if synchronous attempt fails.
 23 */
 24int ibcac(struct gpib_board *board, int sync, int fallback_to_async)
 25{
 26	int status = ibstatus(board);
 27	int retval;
 28
 29	if ((status & CIC) == 0)
 30		return -EINVAL;
 31
 32	if (status & ATN)
 33		return 0;
 34
 35	if (sync && (status & LACS) == 0)
 36		/*
 37		 * tcs (take control synchronously) can only possibly work when
 38		 * controller is listener.  Error code also needs to be -ETIMEDOUT
 39		 * or it will giveout without doing fallback.
 40		 */
 41		retval = -ETIMEDOUT;
 42	else
 43		retval = board->interface->take_control(board, sync);
 44
 45	if (retval < 0 && fallback_to_async) {
 46		if (sync && retval == -ETIMEDOUT)
 47			retval = board->interface->take_control(board, 0);
 48	}
 49	board->interface->update_status(board, 0);
 50
 51	return retval;
 52}
 53
 54/*
 55 * After ATN is asserted, it should cause any connected devices
 56 * to start listening for command bytes and leave acceptor idle state.
 57 * So if ATN is asserted and neither NDAC or NRFD are asserted,
 58 * then there are no devices and ibcmd should error out immediately.
 59 * Some gpib hardware sees itself asserting NDAC/NRFD when it
 60 * is controller in charge, in which case this check will
 61 * do nothing useful (but shouldn't cause any harm either).
 62 * Drivers that don't need this check (ni_usb for example) may
 63 * set the skip_check_for_command_acceptors flag in their
 64 * gpib_interface_struct to avoid useless overhead.
 65 */
 66static int check_for_command_acceptors(struct gpib_board *board)
 67{
 68	int lines;
 69
 70	if (board->interface->skip_check_for_command_acceptors)
 71		return 0;
 72	if (!board->interface->line_status)
 73		return 0;
 74
 75	udelay(2); // allow time for devices to respond to ATN if it was just asserted
 76
 77	lines = board->interface->line_status(board);
 78	if (lines < 0)
 79		return lines;
 80
 81	if ((lines & VALID_NRFD) && (lines & VALID_NDAC))	{
 82		if ((lines & BUS_NRFD) == 0 && (lines & BUS_NDAC) == 0)
 83			return -ENOTCONN;
 84	}
 85
 86	return 0;
 87}
 88
 89/*
 90 * IBCMD
 91 * Write cnt command bytes from buf to the GPIB.  The
 92 * command operation terminates only on I/O complete.
 93 *
 94 * NOTE:
 95 *      1.  Prior to beginning the command, the interface is
 96 *          placed in the controller active state.
 97 *      2.  Before calling ibcmd for the first time, ibsic
 98 *          must be called to initialize the GPIB and enable
 99 *          the interface to leave the controller idle state.
100 */
101int ibcmd(struct gpib_board *board, u8 *buf, size_t length, size_t *bytes_written)
102{
103	ssize_t ret = 0;
104	int status;
105
106	*bytes_written = 0;
107
108	status = ibstatus(board);
109
110	if ((status & CIC) == 0)
111		return -EINVAL;
112
113	os_start_timer(board, board->usec_timeout);
114
115	ret = ibcac(board, 1, 1);
116	if (ret == 0) {
117		ret = check_for_command_acceptors(board);
118		if (ret == 0)
119			ret = board->interface->command(board, buf, length, bytes_written);
120	}
121
122	os_remove_timer(board);
123
124	if (io_timed_out(board))
125		ret = -ETIMEDOUT;
126
127	return ret;
128}
129
130/*
131 * IBGTS
132 * Go to the controller standby state from the controller
133 * active state, i.e., turn ATN off.
134 */
135
136int ibgts(struct gpib_board *board)
137{
138	int status = ibstatus(board);
139	int retval;
140
141	if ((status & CIC) == 0)
142		return -EINVAL;
143
144	retval = board->interface->go_to_standby(board);    /* go to standby */
145
146	board->interface->update_status(board, 0);
147
148	return retval;
149}
150
151static int autospoll_wait_should_wake_up(struct gpib_board *board)
152{
153	int retval;
154
155	mutex_lock(&board->big_gpib_mutex);
156
157	retval = board->master && board->autospollers > 0 &&
158		!atomic_read(&board->stuck_srq) &&
159		test_and_clear_bit(SRQI_NUM, &board->status);
160
161	mutex_unlock(&board->big_gpib_mutex);
162	return retval;
163}
164
165static int autospoll_thread(void *board_void)
166{
167	struct gpib_board *board = board_void;
168	int retval = 0;
169
170	dev_dbg(board->gpib_dev, "entering autospoll thread\n");
171
172	while (1) {
173		wait_event_interruptible(board->wait,
174					 kthread_should_stop() ||
175					 autospoll_wait_should_wake_up(board));
176		dev_dbg(board->gpib_dev, "autospoll wait satisfied\n");
177		if (kthread_should_stop())
178			break;
179
180		mutex_lock(&board->big_gpib_mutex);
181		/* make sure we are still good after we have lock */
182		if (board->autospollers <= 0 || board->master == 0) {
183			mutex_unlock(&board->big_gpib_mutex);
184			continue;
185		}
186		mutex_unlock(&board->big_gpib_mutex);
187
188		if (try_module_get(board->provider_module)) {
189			retval = autopoll_all_devices(board);
190			module_put(board->provider_module);
191		} else {
192			dev_err(board->gpib_dev, "try_module_get() failed!\n");
193		}
194		if (retval <= 0) {
195			dev_err(board->gpib_dev, "stuck SRQ\n");
196
197			atomic_set(&board->stuck_srq, 1);	// XXX could be better
198			set_bit(SRQI_NUM, &board->status);
199		}
200	}
201	return retval;
202}
203
204int ibonline(struct gpib_board *board)
205{
206	int retval;
207
208	if (board->online)
209		return -EBUSY;
210	if (!board->interface)
211		return -ENODEV;
212	retval = gpib_allocate_board(board);
213	if (retval < 0)
214		return retval;
215
216	board->dev = NULL;
217	board->local_ppoll_mode = 0;
218	retval = board->interface->attach(board, &board->config);
219	if (retval < 0) {
220		board->interface->detach(board);
221		return retval;
222	}
223	/*
224	 * nios2nommu on 2.6.11 uclinux kernel has weird problems
225	 * with autospoll thread causing huge slowdowns
226	 */
227#ifndef CONFIG_NIOS2
228	board->autospoll_task = kthread_run(&autospoll_thread, board,
229					    "gpib%d_autospoll_kthread", board->minor);
230	if (IS_ERR(board->autospoll_task)) {
231		dev_err(board->gpib_dev, "failed to create autospoll thread\n");
232		board->interface->detach(board);
233		return PTR_ERR(board->autospoll_task);
234	}
235#endif
236	board->online = 1;
237	dev_dbg(board->gpib_dev, "board online\n");
238
239	return 0;
240}
241
242/* XXX need to make sure board is generally not in use (grab board lock?) */
243int iboffline(struct gpib_board *board)
244{
245	int retval;
246
247	if (board->online == 0)
248		return 0;
249	if (!board->interface)
250		return -ENODEV;
251
252	if (board->autospoll_task && !IS_ERR(board->autospoll_task)) {
253		retval = kthread_stop(board->autospoll_task);
254		if (retval)
255			dev_err(board->gpib_dev, "kthread_stop returned %i\n", retval);
256		board->autospoll_task = NULL;
257	}
258
259	board->interface->detach(board);
260	gpib_deallocate_board(board);
261	board->online = 0;
262	dev_dbg(board->gpib_dev, "board offline\n");
263
264	return 0;
265}
266
267/*
268 * IBLINES
269 * Poll the GPIB control lines and return their status in buf.
270 *
271 *      LSB (bits 0-7)  -  VALID lines mask (lines that can be monitored).
272 * Next LSB (bits 8-15) - STATUS lines mask (lines that are currently set).
273 *
274 */
275int iblines(const struct gpib_board *board, short *lines)
276{
277	int retval;
278
279	*lines = 0;
280	if (!board->interface->line_status)
281		return 0;
282	retval = board->interface->line_status(board);
283	if (retval < 0)
284		return retval;
285	*lines = retval;
286	return 0;
287}
288
289/*
290 * IBRD
291 * Read up to 'length' bytes of data from the GPIB into buf.  End
292 * on detection of END (EOI and or EOS) and set 'end_flag'.
293 *
294 * NOTE:
295 *      1.  The interface is placed in the controller standby
296 *          state prior to beginning the read.
297 *      2.  Prior to calling ibrd, the intended devices as well
298 *          as the interface board itself must be addressed by
299 *          calling ibcmd.
300 */
301
302int ibrd(struct gpib_board *board, u8 *buf, size_t length, int *end_flag, size_t *nbytes)
303{
304	ssize_t ret = 0;
305	int retval;
306	size_t bytes_read;
307
308	*nbytes = 0;
309	*end_flag = 0;
310	if (length == 0)
311		return 0;
312
313	if (board->master) {
314		retval = ibgts(board);
315		if (retval < 0)
316			return retval;
317	}
318	/*
319	 * XXX resetting timer here could cause timeouts take longer than they should,
320	 * since read_ioctl calls this
321	 * function in a loop, there is probably a similar problem with writes/commands
322	 */
323	os_start_timer(board, board->usec_timeout);
324
325	do {
326		ret = board->interface->read(board, buf, length - *nbytes, end_flag, &bytes_read);
327		if (ret < 0)
328			goto ibrd_out;
329
330		buf += bytes_read;
331		*nbytes += bytes_read;
332		if (need_resched())
333			schedule();
334	} while (ret == 0 && *nbytes > 0 && *nbytes < length && *end_flag == 0);
335ibrd_out:
336	os_remove_timer(board);
337
338	return ret;
339}
340
341/*
342 * IBRPP
343 * Conduct a parallel poll and return the byte in buf.
344 *
345 * NOTE:
346 *	1.  Prior to conducting the poll the interface is placed
347 *	    in the controller active state.
348 */
349int ibrpp(struct gpib_board *board, u8 *result)
350{
351	int retval = 0;
352
353	os_start_timer(board, board->usec_timeout);
354	retval = ibcac(board, 1, 1);
355	if (retval)
356		return -1;
357
358	retval =  board->interface->parallel_poll(board, result);
359
360	os_remove_timer(board);
361	return retval;
362}
363
364int ibppc(struct gpib_board *board, u8 configuration)
365{
366	configuration &= 0x1f;
367	board->interface->parallel_poll_configure(board, configuration);
368	board->parallel_poll_configuration = configuration;
369
370	return 0;
371}
372
373int ibrsv2(struct gpib_board *board, u8 status_byte, int new_reason_for_service)
374{
375	int board_status = ibstatus(board);
376	const unsigned int MSS = status_byte & request_service_bit;
377
378	if ((board_status & CIC))
379		return -EINVAL;
380
381	if (MSS == 0 && new_reason_for_service)
382		return -EINVAL;
383
384	if (board->interface->serial_poll_response2)	{
385		board->interface->serial_poll_response2(board, status_byte, new_reason_for_service);
386		// fall back on simpler serial_poll_response if the behavior would be the same
387	} else if (board->interface->serial_poll_response &&
388		   (MSS == 0 || (MSS && new_reason_for_service))) {
389		board->interface->serial_poll_response(board, status_byte);
390	} else {
391		return -EOPNOTSUPP;
392	}
393
394	return 0;
395}
396
397/*
398 * IBSIC
399 * Send IFC for at least 100 microseconds.
400 *
401 * NOTE:
402 *	1.  Ibsic must be called prior to the first call to
403 *	    ibcmd in order to initialize the bus and enable the
404 *	    interface to leave the controller idle state.
405 */
406int ibsic(struct gpib_board *board, unsigned int usec_duration)
407{
408	if (board->master == 0)
409		return -EINVAL;
410
411	if (usec_duration < 100)
412		usec_duration = 100;
413	if (usec_duration > 1000)
414		usec_duration = 1000;
415
416	dev_dbg(board->gpib_dev, "sending interface clear, delay = %ius\n", usec_duration);
417	board->interface->interface_clear(board, 1);
418	udelay(usec_duration);
419	board->interface->interface_clear(board, 0);
420
421	return 0;
422}
423
424int ibrsc(struct gpib_board *board, int request_control)
425{
426	int retval;
427
428	if (!board->interface->request_system_control)
429		return -EPERM;
430
431	retval = board->interface->request_system_control(board, request_control);
432
433	if (retval)
434		return retval;
435
436	board->master = request_control != 0;
437
438	return  0;
439}
440
441/*
442 * IBSRE
443 * Send REN true if v is non-zero or false if v is zero.
444 */
445int ibsre(struct gpib_board *board, int enable)
446{
447	if (board->master == 0)
448		return -EINVAL;
449
450	board->interface->remote_enable(board, enable);	/* set or clear REN */
451	if (!enable)
452		usleep_range(100, 150);
453
454	return 0;
455}
456
457/*
458 * IBPAD
459 * change the GPIB address of the interface board.  The address
460 * must be 0 through 30.  ibonl resets the address to PAD.
461 */
462int ibpad(struct gpib_board *board, unsigned int addr)
463{
464	if (addr > MAX_GPIB_PRIMARY_ADDRESS)
465		return -EINVAL;
466
467	board->pad = addr;
468	if (board->online)
469		board->interface->primary_address(board, board->pad);
470	dev_dbg(board->gpib_dev, "set primary addr to %i\n", board->pad);
471	return 0;
472}
473
474/*
475 * IBSAD
476 * change the secondary GPIB address of the interface board.
477 * The address must be 0 through 30, or negative disables.  ibonl resets the
478 * address to SAD.
479 */
480int ibsad(struct gpib_board *board, int addr)
481{
482	if (addr > MAX_GPIB_SECONDARY_ADDRESS)
483		return -EINVAL;
484	board->sad = addr;
485	if (board->online) {
486		if (board->sad >= 0)
487			board->interface->secondary_address(board, board->sad, 1);
488		else
489			board->interface->secondary_address(board, 0, 0);
490	}
491	dev_dbg(board->gpib_dev, "set secondary addr to %i\n", board->sad);
492
493	return 0;
494}
495
496/*
497 * IBEOS
498 * Set the end-of-string modes for I/O operations to v.
499 *
500 */
501int ibeos(struct gpib_board *board, int eos, int eosflags)
502{
503	int retval;
504
505	if (eosflags & ~EOS_MASK)
506		return -EINVAL;
507	if (eosflags & REOS) {
508		retval = board->interface->enable_eos(board, eos, eosflags & BIN);
509	} else {
510		board->interface->disable_eos(board);
511		retval = 0;
512	}
513	return retval;
514}
515
516int ibstatus(struct gpib_board *board)
517{
518	return general_ibstatus(board, NULL, 0, 0, NULL);
519}
520
521int general_ibstatus(struct gpib_board *board, const struct gpib_status_queue *device,
522		     int clear_mask, int set_mask, struct gpib_descriptor *desc)
523{
524	int status = 0;
525	short line_status;
526
527	if (board->private_data) {
528		status = board->interface->update_status(board, clear_mask);
529		/*
530		 * XXX should probably stop having drivers use TIMO bit in
531		 * board->status to avoid confusion
532		 */
533		status &= ~TIMO;
534		/* get real SRQI status if we can */
535		if (iblines(board, &line_status) == 0) {
536			if ((line_status & VALID_SRQ)) {
537				if ((line_status & BUS_SRQ))
538					status |= SRQI;
539				else
540					status &= ~SRQI;
541			}
542		}
543	}
544	if (device)
545		if (num_status_bytes(device))
546			status |= RQS;
547
548	if (desc) {
549		if (set_mask & CMPL)
550			atomic_set(&desc->io_in_progress, 0);
551		else if (clear_mask & CMPL)
552			atomic_set(&desc->io_in_progress, 1);
553
554		if (atomic_read(&desc->io_in_progress))
555			status &= ~CMPL;
556		else
557			status |= CMPL;
558	}
559	if (num_gpib_events(&board->event_queue))
560		status |= EVENT;
561	else
562		status &= ~EVENT;
563
564	return status;
565}
566
567struct wait_info {
568	struct gpib_board *board;
569	struct timer_list timer;
570	int timed_out;
571	unsigned long usec_timeout;
572};
573
574static void wait_timeout(struct timer_list *t)
575{
576	struct wait_info *winfo = timer_container_of(winfo, t, timer);
577
578	winfo->timed_out = 1;
579	wake_up_interruptible(&winfo->board->wait);
580}
581
582static void init_wait_info(struct wait_info *winfo)
583{
584	winfo->board = NULL;
585	winfo->timed_out = 0;
586	timer_setup_on_stack(&winfo->timer, wait_timeout, 0);
587}
588
589static int wait_satisfied(struct wait_info *winfo, struct gpib_status_queue *status_queue,
590			  int wait_mask, int *status, struct gpib_descriptor *desc)
591{
592	struct gpib_board *board = winfo->board;
593	int temp_status;
594
595	if (mutex_lock_interruptible(&board->big_gpib_mutex))
596		return -ERESTARTSYS;
597
598	temp_status = general_ibstatus(board, status_queue, 0, 0, desc);
599
600	mutex_unlock(&board->big_gpib_mutex);
601
602	if (winfo->timed_out)
603		temp_status |= TIMO;
604	else
605		temp_status &= ~TIMO;
606	if (wait_mask & temp_status) {
607		*status = temp_status;
608		return 1;
609	}
610// XXX does wait for END work?
611	return 0;
612}
613
614/* install timer interrupt handler */
615static void start_wait_timer(struct wait_info *winfo)
616/* Starts the timeout task  */
617{
618	winfo->timed_out = 0;
619
620	if (winfo->usec_timeout > 0)
621		mod_timer(&winfo->timer, jiffies + usec_to_jiffies(winfo->usec_timeout));
622}
623
624static void remove_wait_timer(struct wait_info *winfo)
625{
626	timer_delete_sync(&winfo->timer);
627	timer_destroy_on_stack(&winfo->timer);
628}
629
630/*
631 * IBWAIT
632 * Check or wait for a GPIB event to occur.  The mask argument
633 * is a bit vector corresponding to the status bit vector.  It
634 * has a bit set for each condition which can terminate the wait
635 * If the mask is 0 then
636 * no condition is waited for.
637 */
638int ibwait(struct gpib_board *board, int wait_mask, int clear_mask, int set_mask,
639	   int *status, unsigned long usec_timeout, struct gpib_descriptor *desc)
640{
641	int retval = 0;
642	struct gpib_status_queue *status_queue;
643	struct wait_info winfo;
644
645	if (desc->is_board)
646		status_queue = NULL;
647	else
648		status_queue = get_gpib_status_queue(board, desc->pad, desc->sad);
649
650	if (wait_mask == 0) {
651		*status = general_ibstatus(board, status_queue, clear_mask, set_mask, desc);
652		return 0;
653	}
654
655	mutex_unlock(&board->big_gpib_mutex);
656
657	init_wait_info(&winfo);
658	winfo.board = board;
659	winfo.usec_timeout = usec_timeout;
660	start_wait_timer(&winfo);
661
662	if (wait_event_interruptible(board->wait, wait_satisfied(&winfo, status_queue,
663								 wait_mask, status, desc))) {
664		dev_dbg(board->gpib_dev, "wait interrupted\n");
665		retval = -ERESTARTSYS;
666	}
667	remove_wait_timer(&winfo);
668
669	if (retval)
670		return retval;
671	if (mutex_lock_interruptible(&board->big_gpib_mutex))
672		return -ERESTARTSYS;
673
674	/* make sure we only clear status bits that we are reporting */
675	if (*status & clear_mask || set_mask)
676		general_ibstatus(board, status_queue, *status & clear_mask, set_mask, NULL);
677
678	return 0;
679}
680
681/*
682 * IBWRT
683 * Write cnt bytes of data from buf to the GPIB.  The write
684 * operation terminates only on I/O complete.
685 *
686 * NOTE:
687 *      1.  Prior to beginning the write, the interface is
688 *          placed in the controller standby state.
689 *      2.  Prior to calling ibwrt, the intended devices as
690 *          well as the interface board itself must be
691 *          addressed by calling ibcmd.
692 */
693int ibwrt(struct gpib_board *board, u8 *buf, size_t cnt, int send_eoi, size_t *bytes_written)
694{
695	int ret = 0;
696	int retval;
697
698	if (cnt == 0)
699		return 0;
700
701	if (board->master) {
702		retval = ibgts(board);
703		if (retval < 0)
704			return retval;
705	}
706	os_start_timer(board, board->usec_timeout);
707	ret = board->interface->write(board, buf, cnt, send_eoi, bytes_written);
708
709	if (io_timed_out(board))
710		ret = -ETIMEDOUT;
711
712	os_remove_timer(board);
713
714	return ret;
715}
716