Commit 703afc38 authored by David Schleef's avatar David Schleef Committed by Greg Kroah-Hartman
Browse files

Staging: comedi: add 8253.h header 



This is needed by a bunch of different comedi drivers.

From: David Schleef <ds@schleef.org>
Cc: Frank Mori Hess <fmhess@users.sourceforge.net>
Cc: Ian Abbott <abbotti@mev.co.uk>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent c995fe94

drivers/staging/comedi/drivers/8253.h

0 → 100644
+420 −0
Original line number Diff line number Diff line 
/*

    comedi/drivers/8253.h

    Header file for 8253



    COMEDI - Linux Control and Measurement Device Interface

    Copyright (C) 2000 David A. Schleef <ds@schleef.org>



    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.



    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.



    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.



*/



#ifndef _8253_H

#define _8253_H



#ifndef CMDTEST

#include "../comedi.h"

#else

#include "../comedi.h"

#endif



#define i8253_cascade_ns_to_timer i8253_cascade_ns_to_timer_2div



static inline void i8253_cascade_ns_to_timer_2div_old(int i8253_osc_base,

	unsigned int *d1, unsigned int *d2, unsigned int *nanosec,

	int round_mode)

{

	int divider;

	int div1, div2;

	int div1_glb, div2_glb, ns_glb;

	int div1_lub, div2_lub, ns_lub;

	int ns;



	divider = (*nanosec + i8253_osc_base / 2) / i8253_osc_base;



	/* find 2 integers 1<={x,y}<=65536 such that x*y is

	   close to divider */



	div1_lub = div2_lub = 0;

	div1_glb = div2_glb = 0;



	ns_glb = 0;

	ns_lub = 0xffffffff;



	div2 = 0x10000;

	for (div1 = divider / 65536 + 1; div1 < div2; div1++) {

		div2 = divider / div1;



		ns = i8253_osc_base * div1 * div2;

		if (ns <= *nanosec && ns > ns_glb) {

			ns_glb = ns;

			div1_glb = div1;

			div2_glb = div2;

		}



		div2++;

		if (div2 <= 65536) {

			ns = i8253_osc_base * div1 * div2;

			if (ns > *nanosec && ns < ns_lub) {

				ns_lub = ns;

				div1_lub = div1;

				div2_lub = div2;

			}

		}

	}



	*nanosec = div1_lub * div2_lub * i8253_osc_base;

	*d1 = div1_lub & 0xffff;

	*d2 = div2_lub & 0xffff;

	return;

}



static inline void i8253_cascade_ns_to_timer_power(int i8253_osc_base,

	unsigned int *d1, unsigned int *d2, unsigned int *nanosec,

	int round_mode)

{

	int div1, div2;

	int base;



	for (div1 = 2; div1 <= (1 << 16); div1 <<= 1) {

		base = i8253_osc_base * div1;

		round_mode &= TRIG_ROUND_MASK;

		switch (round_mode) {

		case TRIG_ROUND_NEAREST:

		default:

			div2 = (*nanosec + base / 2) / base;

			break;

		case TRIG_ROUND_DOWN:

			div2 = (*nanosec) / base;

			break;

		case TRIG_ROUND_UP:

			div2 = (*nanosec + base - 1) / base;

			break;

		}

		if (div2 < 2)

			div2 = 2;

		if (div2 <= 65536) {

			*nanosec = div2 * base;

			*d1 = div1 & 0xffff;

			*d2 = div2 & 0xffff;

			return;

		}

	}



	/* shouldn't get here */

	div1 = 0x10000;

	div2 = 0x10000;

	*nanosec = div1 * div2 * i8253_osc_base;

	*d1 = div1 & 0xffff;

	*d2 = div2 & 0xffff;

}



static inline void i8253_cascade_ns_to_timer_2div(int i8253_osc_base,

	unsigned int *d1, unsigned int *d2, unsigned int *nanosec,

	int round_mode)

{

	unsigned int divider;

	unsigned int div1, div2;

	unsigned int div1_glb, div2_glb, ns_glb;

	unsigned int div1_lub, div2_lub, ns_lub;

	unsigned int ns;

	unsigned int start;

	unsigned int ns_low, ns_high;

	static const unsigned int max_count = 0x10000;

	/* exit early if everything is already correct (this can save time

	 * since this function may be called repeatedly during command tests

	 * and execution) */

	div1 = *d1 ? *d1 : max_count;

	div2 = *d2 ? *d2 : max_count;

	divider = div1 * div2;

	if (div1 * div2 * i8253_osc_base == *nanosec &&

		div1 > 1 && div1 <= max_count &&

		div2 > 1 && div2 <= max_count &&

		/* check for overflow */

		divider > div1 && divider > div2 &&

		divider * i8253_osc_base > divider &&

		divider * i8253_osc_base > i8253_osc_base) {

		return;

	}



	divider = *nanosec / i8253_osc_base;



	div1_lub = div2_lub = 0;

	div1_glb = div2_glb = 0;



	ns_glb = 0;

	ns_lub = 0xffffffff;



	div2 = max_count;

	start = divider / div2;

	if (start < 2)

		start = 2;

	for (div1 = start; div1 <= divider / div1 + 1 && div1 <= max_count;

		div1++) {

		for (div2 = divider / div1;

			div1 * div2 <= divider + div1 + 1 && div2 <= max_count;

			div2++) {

			ns = i8253_osc_base * div1 * div2;

			if (ns <= *nanosec && ns > ns_glb) {

				ns_glb = ns;

				div1_glb = div1;

				div2_glb = div2;

			}

			if (ns >= *nanosec && ns < ns_lub) {

				ns_lub = ns;

				div1_lub = div1;

				div2_lub = div2;

			}

		}

	}



	round_mode &= TRIG_ROUND_MASK;

	switch (round_mode) {

	case TRIG_ROUND_NEAREST:

	default:

		ns_high = div1_lub * div2_lub * i8253_osc_base;

		ns_low = div1_glb * div2_glb * i8253_osc_base;

		if (ns_high - *nanosec < *nanosec - ns_low) {

			div1 = div1_lub;

			div2 = div2_lub;

		} else {

			div1 = div1_glb;

			div2 = div2_glb;

		}

		break;

	case TRIG_ROUND_UP:

		div1 = div1_lub;

		div2 = div2_lub;

		break;

	case TRIG_ROUND_DOWN:

		div1 = div1_glb;

		div2 = div2_glb;

		break;

	}



	*nanosec = div1 * div2 * i8253_osc_base;

	*d1 = div1 & 0xffff;	// masking is done since counter maps zero to 0x10000

	*d2 = div2 & 0xffff;

	return;

}



#ifndef CMDTEST

/* i8254_load programs 8254 counter chip.  It should also work for the 8253.

 * base_address is the lowest io address for the chip (the address of counter 0).

 * counter_number is the counter you want to load (0,1 or 2)

 * count is the number to load into the counter.

 *

 * You probably want to use mode 2.

 *

 * Use i8254_mm_load() if you board uses memory-mapped io, it is

 * the same as i8254_load() except it uses writeb() instead of outb().

 *

 * Neither i8254_load() or i8254_read() do their loading/reading

 * atomically.  The 16 bit read/writes are performed with two successive

 * 8 bit read/writes.  So if two parts of your driver do a load/read on

 * the same counter, it may be necessary to protect these functions

 * with a spinlock.

 *

 * FMH

 */



#define i8254_control_reg	3



static inline int i8254_load(unsigned long base_address, unsigned int regshift,

	unsigned int counter_number, unsigned int count, unsigned int mode)

{

	unsigned int byte;



	if (counter_number > 2)

		return -1;

	if (count > 0xffff)

		return -1;

	if (mode > 5)

		return -1;

	if ((mode == 2 || mode == 3) && count == 1)

		return -1;



	byte = counter_number << 6;

	byte |= 0x30;		// load low then high byte

	byte |= (mode << 1);	// set counter mode

	outb(byte, base_address + (i8254_control_reg << regshift));

	byte = count & 0xff;	// lsb of counter value

	outb(byte, base_address + (counter_number << regshift));

	byte = (count >> 8) & 0xff;	// msb of counter value

	outb(byte, base_address + (counter_number << regshift));



	return 0;

}



static inline int i8254_mm_load(void *base_address, unsigned int regshift,

	unsigned int counter_number, unsigned int count, unsigned int mode)

{

	unsigned int byte;



	if (counter_number > 2)

		return -1;

	if (count > 0xffff)

		return -1;

	if (mode > 5)

		return -1;

	if ((mode == 2 || mode == 3) && count == 1)

		return -1;



	byte = counter_number << 6;

	byte |= 0x30;		// load low then high byte

	byte |= (mode << 1);	// set counter mode

	writeb(byte, base_address + (i8254_control_reg << regshift));

	byte = count & 0xff;	// lsb of counter value

	writeb(byte, base_address + (counter_number << regshift));

	byte = (count >> 8) & 0xff;	// msb of counter value

	writeb(byte, base_address + (counter_number << regshift));



	return 0;

}



/* Returns 16 bit counter value, should work for 8253 also.*/

static inline int i8254_read(unsigned long base_address, unsigned int regshift,

	unsigned int counter_number)

{

	unsigned int byte;

	int ret;



	if (counter_number > 2)

		return -1;



	// latch counter

	byte = counter_number << 6;

	outb(byte, base_address + (i8254_control_reg << regshift));



	// read lsb

	ret = inb(base_address + (counter_number << regshift));

	// read msb

	ret += inb(base_address + (counter_number << regshift)) << 8;



	return ret;

}



static inline int i8254_mm_read(void *base_address, unsigned int regshift,

	unsigned int counter_number)

{

	unsigned int byte;

	int ret;



	if (counter_number > 2)

		return -1;



	// latch counter

	byte = counter_number << 6;

	writeb(byte, base_address + (i8254_control_reg << regshift));



	// read lsb

	ret = readb(base_address + (counter_number << regshift));

	// read msb

	ret += readb(base_address + (counter_number << regshift)) << 8;



	return ret;

}



/* Loads 16 bit initial counter value, should work for 8253 also. */

static inline void i8254_write(unsigned long base_address,

	unsigned int regshift, unsigned int counter_number, unsigned int count)

{

	unsigned int byte;



	if (counter_number > 2)

		return;



	byte = count & 0xff;	// lsb of counter value

	outb(byte, base_address + (counter_number << regshift));

	byte = (count >> 8) & 0xff;	// msb of counter value

	outb(byte, base_address + (counter_number << regshift));

}



static inline void i8254_mm_write(void *base_address,

	unsigned int regshift, unsigned int counter_number, unsigned int count)

{

	unsigned int byte;



	if (counter_number > 2)

		return;



	byte = count & 0xff;	// lsb of counter value

	writeb(byte, base_address + (counter_number << regshift));

	byte = (count >> 8) & 0xff;	// msb of counter value

	writeb(byte, base_address + (counter_number << regshift));

}



/* Set counter mode, should work for 8253 also.

 * Note: the 'mode' value is different to that for i8254_load() and comes

 * from the INSN_CONFIG_8254_SET_MODE command:

 *   I8254_MODE0, I8254_MODE1, ..., I8254_MODE5

 * OR'ed with:

 *   I8254_BCD, I8254_BINARY

 */

static inline int i8254_set_mode(unsigned long base_address,

	unsigned int regshift, unsigned int counter_number, unsigned int mode)

{

	unsigned int byte;



	if (counter_number > 2)

		return -1;

	if (mode > (I8254_MODE5 | I8254_BINARY))

		return -1;



	byte = counter_number << 6;

	byte |= 0x30;		// load low then high byte

	byte |= mode;		// set counter mode and BCD|binary

	outb(byte, base_address + (i8254_control_reg << regshift));



	return 0;

}



static inline int i8254_mm_set_mode(void *base_address,

	unsigned int regshift, unsigned int counter_number, unsigned int mode)

{

	unsigned int byte;



	if (counter_number > 2)

		return -1;

	if (mode > (I8254_MODE5 | I8254_BINARY))

		return -1;



	byte = counter_number << 6;

	byte |= 0x30;		// load low then high byte

	byte |= mode;		// set counter mode and BCD|binary

	writeb(byte, base_address + (i8254_control_reg << regshift));



	return 0;

}



static inline int i8254_status(unsigned long base_address,

	unsigned int regshift, unsigned int counter_number)

{

	outb(0xE0 | (2 << counter_number),

		base_address + (i8254_control_reg << regshift));

	return inb(base_address + (counter_number << regshift));

}



static inline int i8254_mm_status(void *base_address,

	unsigned int regshift, unsigned int counter_number)

{

	writeb(0xE0 | (2 << counter_number),

		base_address + (i8254_control_reg << regshift));

	return readb(base_address + (counter_number << regshift));

}



#endif



#endif