[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / comedi / drivers / unioxx5.c

/***************************************************************************
 *                                                                         *
 *  comedi/drivers/unioxx5.c                                               *
 *  Driver for Fastwel UNIOxx-5 (analog and digital i/o) boards.           *
 *                                                                         *
 *  Copyright (C) 2006 Kruchinin Daniil (asgard) [asgard@etersoft.ru]      *
 *                                                                         *
 *  COMEDI - Linux Control and Measurement Device Interface                *
 *  Copyright (C) 1998,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.              *
 *                                                                         *
 ***************************************************************************/
/*

Driver: unioxx5
Description: Driver for Fastwel UNIOxx-5 (analog and digital i/o) boards.
Author: Kruchinin Daniil (asgard) <asgard@etersoft.ru>
Status: unknown
Updated: 2006-10-09
Devices: [Fastwel] UNIOxx-5 (unioxx5),

 This card supports digital and analog I/O. It written for g01
 subdevices only.
 channels range: 0 .. 23 dio channels
 and 0 .. 11 analog modules range
 During attaching unioxx5 module displays modules identifiers
 (see dmesg after comedi_config) in format:
 | [module_number] module_id |

*/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include "../comedidev.h"
#include <linux/ioport.h>
#include <linux/slab.h>

#define DRIVER_NAME "unioxx5"
#define UNIOXX5_SIZE 0x10
#define UNIOXX5_SUBDEV_BASE 0xA000	/* base addr of first subdev */
#define UNIOXX5_SUBDEV_ODDS 0x400

/* modules types */
#define MODULE_DIGITAL 0
#define MODULE_OUTPUT_MASK 0x80	/* analog input/output */

/* constants for digital i/o */
#define UNIOXX5_NUM_OF_CHANS 24

/* constants for analog i/o */
#define TxBE  0x10		/* transmit buffer enable */
#define RxCA  0x20		/* 1 receive character available */
#define Rx2CA 0x40		/* 2 receive character available */
#define Rx4CA 0x80		/* 4 receive character available */

/* bytes mask errors */
#define Rx2CA_ERR_MASK 0x04	/* 2 bytes receiving error */
#define Rx4CA_ERR_MASK 0x08	/* 4 bytes receiving error */

/* channel modes */
#define ALL_2_INPUT  0		/* config all digital channels to input */
#define ALL_2_OUTPUT 1		/* config all digital channels to output */

/* 'private' structure for each subdevice */
struct unioxx5_subd_priv {
	int usp_iobase;
	/* 12 modules. each can be 70L or 73L */
	unsigned char usp_module_type[12];
	/* for saving previous written value for analog modules */
	unsigned char usp_extra_data[12][4];
	unsigned char usp_prev_wr_val[3];	/* previous written value */
	unsigned char usp_prev_cn_val[3];	/* previous channel value */
};

static int __unioxx5_define_chan_offset(int chan_num)
{

	if (chan_num < 0 || chan_num > 23)
		return -1;

	return (chan_num >> 3) + 1;
}

#if 0				/* not used? */
static void __unioxx5_digital_config(struct unioxx5_subd_priv *usp, int mode)
{
	int i, mask;

	mask = (mode == ALL_2_OUTPUT) ? 0xFF : 0x00;
	printk("COMEDI: mode = %d\n", mask);

	outb(1, usp->usp_iobase + 0);

	for (i = 0; i < 3; i++)
		outb(mask, usp->usp_iobase + i);

	outb(0, usp->usp_iobase + 0);
}
#endif

/* configure channels for analog i/o (even to output, odd to input) */
static void __unioxx5_analog_config(struct unioxx5_subd_priv *usp, int channel)
{
	int chan_a, chan_b, conf, channel_offset;

	channel_offset = __unioxx5_define_chan_offset(channel);
	conf = usp->usp_prev_cn_val[channel_offset - 1];
	chan_a = chan_b = 1;

	/* setting channel A and channel B mask */
	if (channel % 2 == 0) {
		chan_a <<= channel & 0x07;
		chan_b <<= (channel + 1) & 0x07;
	} else {
		chan_a <<= (channel - 1) & 0x07;
		chan_b <<= channel & 0x07;
	}

	conf |= chan_a;		/* even channel ot output */
	conf &= ~chan_b;	/* odd channel to input */

	outb(1, usp->usp_iobase + 0);
	outb(conf, usp->usp_iobase + channel_offset);
	outb(0, usp->usp_iobase + 0);

	usp->usp_prev_cn_val[channel_offset - 1] = conf;
}

static int __unioxx5_digital_read(struct unioxx5_subd_priv *usp,
				  unsigned int *data, int channel, int minor)
{
	int channel_offset, mask = 1 << (channel & 0x07);

	channel_offset = __unioxx5_define_chan_offset(channel);
	if (channel_offset < 0) {
		pr_err("comedi%d: undefined channel %d. channel range is 0 .. 23\n",
		       minor, channel);
		return 0;
	}

	*data = inb(usp->usp_iobase + channel_offset);
	*data &= mask;

	/* correct the read value to 0 or 1 */
	if (channel_offset > 1)
		channel -= 2 << channel_offset;
	*data >>= channel;
	return 1;
}

static int __unioxx5_analog_read(struct unioxx5_subd_priv *usp,
				 unsigned int *data, int channel, int minor)
{
	int module_no, read_ch;
	char control;

	module_no = channel / 2;
	read_ch = channel % 2;	/* depend on type of channel (A or B) */

	/* defining if given module can work on input */
	if (usp->usp_module_type[module_no] & MODULE_OUTPUT_MASK) {
		pr_err("comedi%d: module in position %d with id 0x%02x is for output only",
		       minor, module_no, usp->usp_module_type[module_no]);
		return 0;
	}

	__unioxx5_analog_config(usp, channel);
	/* sends module number to card(1 .. 12) */
	outb(module_no + 1, usp->usp_iobase + 5);
	outb('V', usp->usp_iobase + 6);	/* sends to module (V)erify command */
	control = inb(usp->usp_iobase);	/* get control register byte */

	/* waits while reading four bytes will be allowed */
	while (!((control = inb(usp->usp_iobase + 0)) & Rx4CA))
		;

	/* if four bytes readding error occurs - return 0(false) */
	if ((control & Rx4CA_ERR_MASK)) {
		printk("COMEDI: 4 bytes error\n");
		return 0;
	}

	if (read_ch)
		*data = inw(usp->usp_iobase + 6);	/* channel B */
	else
		*data = inw(usp->usp_iobase + 4);	/* channel A */

	return 1;
}

static int __unioxx5_digital_write(struct unioxx5_subd_priv *usp,
				   unsigned int *data, int channel, int minor)
{
	int channel_offset, val;
	int mask = 1 << (channel & 0x07);

	channel_offset = __unioxx5_define_chan_offset(channel);
	if (channel_offset < 0) {
		pr_err("comedi%d: undefined channel %d. channel range is 0 .. 23\n",
		       minor, channel);
		return 0;
	}

	/* getting previous written value */
	val = usp->usp_prev_wr_val[channel_offset - 1];

	if (*data)
		val |= mask;
	else
		val &= ~mask;

	outb(val, usp->usp_iobase + channel_offset);
	/* saving new written value */
	usp->usp_prev_wr_val[channel_offset - 1] = val;

	return 1;
}

static int __unioxx5_analog_write(struct unioxx5_subd_priv *usp,
				  unsigned int *data, int channel, int minor)
{
	int module, i;

	module = channel / 2;	/* definig module number(0 .. 11) */
	i = (channel % 2) << 1;	/* depends on type of channel (A or B) */

	/* defining if given module can work on output */
	if (!(usp->usp_module_type[module] & MODULE_OUTPUT_MASK)) {
		pr_err("comedi%d: module in position %d with id 0x%0x is for input only!\n",
		       minor, module, usp->usp_module_type[module]);
		return 0;
	}

	__unioxx5_analog_config(usp, channel);
	/* saving minor byte */
	usp->usp_extra_data[module][i++] = (unsigned char)(*data & 0x00FF);
	/* saving major byte */
	usp->usp_extra_data[module][i] = (unsigned char)((*data & 0xFF00) >> 8);

	/* while(!((inb(usp->usp_iobase + 0)) & TxBE)); */
	/* sending module number to card(1 .. 12) */
	outb(module + 1, usp->usp_iobase + 5);
	outb('W', usp->usp_iobase + 6);	/* sends (W)rite command to module */

	/* sending for bytes to module(one byte per cycle iteration) */
	for (i = 0; i < 4; i++) {
		while (!((inb(usp->usp_iobase + 0)) & TxBE))
			;	/* waits while writting will be allowed */
		outb(usp->usp_extra_data[module][i], usp->usp_iobase + 6);
	}

	return 1;
}

static int unioxx5_subdev_read(struct comedi_device *dev,
			       struct comedi_subdevice *subdev,
			       struct comedi_insn *insn, unsigned int *data)
{
	struct unioxx5_subd_priv *usp = subdev->private;
	int channel, type;

	channel = CR_CHAN(insn->chanspec);
	/* defining module type(analog or digital) */
	type = usp->usp_module_type[channel / 2];

	if (type == MODULE_DIGITAL) {
		if (!__unioxx5_digital_read(usp, data, channel, dev->minor))
			return -1;
	} else {
		if (!__unioxx5_analog_read(usp, data, channel, dev->minor))
			return -1;
	}

	return 1;
}

static int unioxx5_subdev_write(struct comedi_device *dev,
				struct comedi_subdevice *subdev,
				struct comedi_insn *insn, unsigned int *data)
{
	struct unioxx5_subd_priv *usp = subdev->private;
	int channel, type;

	channel = CR_CHAN(insn->chanspec);
	/* defining module type(analog or digital) */
	type = usp->usp_module_type[channel / 2];

	if (type == MODULE_DIGITAL) {
		if (!__unioxx5_digital_write(usp, data, channel, dev->minor))
			return -1;
	} else {
		if (!__unioxx5_analog_write(usp, data, channel, dev->minor))
			return -1;
	}

	return 1;
}

/* for digital modules only */
static int unioxx5_insn_config(struct comedi_device *dev,
			       struct comedi_subdevice *subdev,
			       struct comedi_insn *insn, unsigned int *data)
{
	int channel_offset, flags, channel = CR_CHAN(insn->chanspec), type;
	struct unioxx5_subd_priv *usp = subdev->private;
	int mask = 1 << (channel & 0x07);

	type = usp->usp_module_type[channel / 2];

	if (type != MODULE_DIGITAL) {
		dev_err(dev->class_dev,
			"comedi%d: channel configuration accessible only for digital modules\n",
			dev->minor);
		return -1;
	}

	channel_offset = __unioxx5_define_chan_offset(channel);
	if (channel_offset < 0) {
		dev_err(dev->class_dev,
			"comedi%d: undefined channel %d. channel range is 0 .. 23\n",
			dev->minor, channel);
		return -1;
	}

	/* gets previously written value */
	flags = usp->usp_prev_cn_val[channel_offset - 1];

	switch (*data) {
	case COMEDI_INPUT:
		flags &= ~mask;
		break;
	case COMEDI_OUTPUT:
		flags |= mask;
		break;
	default:
		dev_err(dev->class_dev,
			"comedi%d: unknown flag\n", dev->minor);
		return -1;
	}

	/*                                                        *\
	 * sets channels buffer to 1(after this we are allowed to *
	 * change channel type on input or output)                *
	 \*                                                        */
	outb(1, usp->usp_iobase + 0);
	/* changes type of _one_ channel */
	outb(flags, usp->usp_iobase + channel_offset);
	/* sets channels bank to 0(allows directly input/output) */
	outb(0, usp->usp_iobase + 0);
	/* saves written value */
	usp->usp_prev_cn_val[channel_offset - 1] = flags;

	return 0;
}

/* initializing subdevice with given address */
static int __unioxx5_subdev_init(struct comedi_device *dev,
				 struct comedi_subdevice *s,
				 int iobase)
{
	struct unioxx5_subd_priv *usp;
	int i, to, ndef_flag = 0;
	int ret;

	usp = kzalloc(sizeof(*usp), GFP_KERNEL);
	if (usp == NULL)
		return -ENOMEM;

	ret = __comedi_request_region(dev, iobase, UNIOXX5_SIZE);
	if (ret) {
		kfree(usp);
		return ret;
	}
	usp->usp_iobase = iobase;

	/* defining modules types */
	for (i = 0; i < 12; i++) {
		to = 10000;

		__unioxx5_analog_config(usp, i * 2);
		/* sends channel number to card */
		outb(i + 1, iobase + 5);
		outb('H', iobase + 6);	/* requests EEPROM world */
		while (!(inb(iobase + 0) & TxBE))
			;	/* waits while writting will be allowed */
		outb(0, iobase + 6);

		/* waits while reading of two bytes will be allowed */
		while (!(inb(iobase + 0) & Rx2CA)) {
			if (--to <= 0) {
				ndef_flag = 1;
				break;
			}
		}

		if (ndef_flag) {
			usp->usp_module_type[i] = 0;
			ndef_flag = 0;
		} else
			usp->usp_module_type[i] = inb(iobase + 6);

		udelay(1);
	}

	/* initial subdevice for digital or analog i/o */
	s->type = COMEDI_SUBD_DIO;
	s->private = usp;
	s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
	s->n_chan = UNIOXX5_NUM_OF_CHANS;
	s->maxdata = 0xFFF;
	s->range_table = &range_digital;
	s->insn_read = unioxx5_subdev_read;
	s->insn_write = unioxx5_subdev_write;
	/* for digital modules only!!! */
	s->insn_config = unioxx5_insn_config;

	return 0;
}

static int unioxx5_attach(struct comedi_device *dev,
			  struct comedi_devconfig *it)
{
	struct comedi_subdevice *s;
	int iobase, i, n_subd;
	int id, num, ba;
	int ret;

	iobase = it->options[0];

	dev->iobase = iobase;
	iobase += UNIOXX5_SUBDEV_BASE;

	/* defining number of subdevices and getting they types (it must be 'g01')  */
	for (i = n_subd = 0, ba = iobase; i < 4; i++, ba += UNIOXX5_SUBDEV_ODDS) {
		id = inb(ba + 0xE);
		num = inb(ba + 0xF);

		if (id != 'g' || num != 1)
			continue;

		n_subd++;
	}

	/* unioxx5 can has from two to four subdevices */
	if (n_subd < 2) {
		dev_err(dev->class_dev,
			"your card must has at least 2 'g01' subdevices\n");
		return -1;
	}

	ret = comedi_alloc_subdevices(dev, n_subd);
	if (ret)
		return ret;

	/* initializing each of for same subdevices */
	for (i = 0; i < n_subd; i++, iobase += UNIOXX5_SUBDEV_ODDS) {
		s = &dev->subdevices[i];
		ret = __unioxx5_subdev_init(dev, s, iobase);
		if (ret)
			return ret;
	}

	return 0;
}

static void unioxx5_detach(struct comedi_device *dev)
{
	int i;
	struct comedi_subdevice *subdev;
	struct unioxx5_subd_priv *usp;

	for (i = 0; i < dev->n_subdevices; i++) {
		subdev = &dev->subdevices[i];
		usp = subdev->private;
		release_region(usp->usp_iobase, UNIOXX5_SIZE);
		kfree(subdev->private);
	}
}

static struct comedi_driver unioxx5_driver = {
	.driver_name	= DRIVER_NAME,
	.module		= THIS_MODULE,
	.attach		= unioxx5_attach,
	.detach		= unioxx5_detach,
};
module_comedi_driver(unioxx5_driver);

MODULE_AUTHOR("Comedi http://www.comedi.org");
MODULE_DESCRIPTION("Comedi low-level driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
110526ed KD	1	/***************************************************************************
	2	* *
	3	* comedi/drivers/unioxx5.c *
	4	* Driver for Fastwel UNIOxx-5 (analog and digital i/o) boards. *
	5	* *
	6	* Copyright (C) 2006 Kruchinin Daniil (asgard) [asgard@etersoft.ru] *
	7	* *
	8	* COMEDI - Linux Control and Measurement Device Interface *
	9	* Copyright (C) 1998,2000 David A. Schleef <ds@schleef.org> *
	10	* *
	11	* This program is free software; you can redistribute it and/or modify *
	12	* it under the terms of the GNU General Public License as published by *
	13	* the Free Software Foundation; either version 2 of the License, or *
	14	* (at your option) any later version. *
	15	* *
	16	* This program is distributed in the hope that it will be useful, *
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	19	* GNU General Public License for more details. *
	20	* *
	21	* You should have received a copy of the GNU General Public License *
	22	* along with this program; if not, write to the Free Software *
	23	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
	24	* *
	25	***************************************************************************/
	26	/*
	27
	28	Driver: unioxx5
	29	Description: Driver for Fastwel UNIOxx-5 (analog and digital i/o) boards.
	30	Author: Kruchinin Daniil (asgard) <asgard@etersoft.ru>
	31	Status: unknown
	32	Updated: 2006-10-09
	33	Devices: [Fastwel] UNIOxx-5 (unioxx5),
	34
	35	This card supports digital and analog I/O. It written for g01
	36	subdevices only.
	37	channels range: 0 .. 23 dio channels
	38	and 0 .. 11 analog modules range
	39	During attaching unioxx5 module displays modules identifiers
	40	(see dmesg after comedi_config) in format:
	41	\| [module_number] module_id \|
	42
	43	*/
	44
cf7d9b42 YT	45	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
cf7d9b42 YT	46
110526ed KD	47	#include "../comedidev.h"
110526ed KD	48	#include <linux/ioport.h>
5a0e3ad6	49	#include <linux/slab.h>
110526ed KD	50
	51	#define DRIVER_NAME "unioxx5"
	52	#define UNIOXX5_SIZE 0x10
	53	#define UNIOXX5_SUBDEV_BASE 0xA000 /* base addr of first subdev */
	54	#define UNIOXX5_SUBDEV_ODDS 0x400
	55
	56	/* modules types */
	57	#define MODULE_DIGITAL 0
	58	#define MODULE_OUTPUT_MASK 0x80 /* analog input/output */
	59
	60	/* constants for digital i/o */
	61	#define UNIOXX5_NUM_OF_CHANS 24
	62
	63	/* constants for analog i/o */
	64	#define TxBE 0x10 /* transmit buffer enable */
	65	#define RxCA 0x20 /* 1 receive character available */
	66	#define Rx2CA 0x40 /* 2 receive character available */
	67	#define Rx4CA 0x80 /* 4 receive character available */
	68
	69	/* bytes mask errors */
	70	#define Rx2CA_ERR_MASK 0x04 /* 2 bytes receiving error */
	71	#define Rx4CA_ERR_MASK 0x08 /* 4 bytes receiving error */
	72
	73	/* channel modes */
	74	#define ALL_2_INPUT 0 /* config all digital channels to input */
	75	#define ALL_2_OUTPUT 1 /* config all digital channels to output */
	76
	77	/* 'private' structure for each subdevice */
33a4640f	78	struct unioxx5_subd_priv {
110526ed	79	int usp_iobase;
33e73e00 R	80	/* 12 modules. each can be 70L or 73L */
	81	unsigned char usp_module_type[12];
	82	/* for saving previous written value for analog modules */
	83	unsigned char usp_extra_data[12][4];
110526ed KD	84	unsigned char usp_prev_wr_val[3]; /* previous written value */
110526ed KD	85	unsigned char usp_prev_cn_val[3]; /* previous channel value */
33a4640f	86	};
110526ed	87
d22418b0 HS	88	static int __unioxx5_define_chan_offset(int chan_num)
	89	{
	90
	91	if (chan_num < 0 \|\| chan_num > 23)
	92	return -1;
	93
	94	return (chan_num >> 3) + 1;
	95	}
	96
	97	#if 0 /* not used? */
	98	static void __unioxx5_digital_config(struct unioxx5_subd_priv *usp, int mode)
	99	{
	100	int i, mask;
	101
	102	mask = (mode == ALL_2_OUTPUT) ? 0xFF : 0x00;
	103	printk("COMEDI: mode = %d\n", mask);
	104
	105	outb(1, usp->usp_iobase + 0);
	106
	107	for (i = 0; i < 3; i++)
	108	outb(mask, usp->usp_iobase + i);
	109
	110	outb(0, usp->usp_iobase + 0);
	111	}
	112	#endif
	113
	114	/* configure channels for analog i/o (even to output, odd to input) */
	115	static void __unioxx5_analog_config(struct unioxx5_subd_priv *usp, int channel)
	116	{
	117	int chan_a, chan_b, conf, channel_offset;
	118
	119	channel_offset = __unioxx5_define_chan_offset(channel);
	120	conf = usp->usp_prev_cn_val[channel_offset - 1];
	121	chan_a = chan_b = 1;
	122
	123	/* setting channel A and channel B mask */
	124	if (channel % 2 == 0) {
	125	chan_a <<= channel & 0x07;
	126	chan_b <<= (channel + 1) & 0x07;
	127	} else {
	128	chan_a <<= (channel - 1) & 0x07;
	129	chan_b <<= channel & 0x07;
	130	}
	131
	132	conf \|= chan_a; /* even channel ot output */
	133	conf &= ~chan_b; /* odd channel to input */
	134
	135	outb(1, usp->usp_iobase + 0);
	136	outb(conf, usp->usp_iobase + channel_offset);
	137	outb(0, usp->usp_iobase + 0);
	138
	139	usp->usp_prev_cn_val[channel_offset - 1] = conf;
	140	}
	141
0a85b6f0	142	static int __unioxx5_digital_read(struct unioxx5_subd_priv *usp,
d22418b0 HS	143	unsigned int *data, int channel, int minor)
	144	{
	145	int channel_offset, mask = 1 << (channel & 0x07);
	146
	147	channel_offset = __unioxx5_define_chan_offset(channel);
	148	if (channel_offset < 0) {
cf7d9b42	149	pr_err("comedi%d: undefined channel %d. channel range is 0 .. 23\n",
d22418b0 HS	150	minor, channel);
	151	return 0;
	152	}
	153
	154	*data = inb(usp->usp_iobase + channel_offset);
	155	*data &= mask;
	156
	157	/* correct the read value to 0 or 1 */
	158	if (channel_offset > 1)
	159	channel -= 2 << channel_offset;
	160	*data >>= channel;
	161	return 1;
	162	}
	163
0a85b6f0	164	static int __unioxx5_analog_read(struct unioxx5_subd_priv *usp,
d22418b0 HS	165	unsigned int *data, int channel, int minor)
	166	{
	167	int module_no, read_ch;
	168	char control;
	169
	170	module_no = channel / 2;
	171	read_ch = channel % 2; /* depend on type of channel (A or B) */
	172
	173	/* defining if given module can work on input */
	174	if (usp->usp_module_type[module_no] & MODULE_OUTPUT_MASK) {
cf7d9b42	175	pr_err("comedi%d: module in position %d with id 0x%02x is for output only",
d22418b0 HS	176	minor, module_no, usp->usp_module_type[module_no]);
	177	return 0;
	178	}
	179
	180	__unioxx5_analog_config(usp, channel);
	181	/* sends module number to card(1 .. 12) */
	182	outb(module_no + 1, usp->usp_iobase + 5);
	183	outb('V', usp->usp_iobase + 6); /* sends to module (V)erify command */
	184	control = inb(usp->usp_iobase); /* get control register byte */
	185
	186	/* waits while reading four bytes will be allowed */
	187	while (!((control = inb(usp->usp_iobase + 0)) & Rx4CA))
	188	;
	189
	190	/* if four bytes readding error occurs - return 0(false) */
	191	if ((control & Rx4CA_ERR_MASK)) {
	192	printk("COMEDI: 4 bytes error\n");
	193	return 0;
	194	}
	195
	196	if (read_ch)
	197	data = inw(usp->usp_iobase + 6); / channel B */
	198	else
	199	data = inw(usp->usp_iobase + 4); / channel A */
	200
	201	return 1;
	202	}
	203
	204	static int __unioxx5_digital_write(struct unioxx5_subd_priv *usp,
	205	unsigned int *data, int channel, int minor)
	206	{
	207	int channel_offset, val;
	208	int mask = 1 << (channel & 0x07);
	209
	210	channel_offset = __unioxx5_define_chan_offset(channel);
	211	if (channel_offset < 0) {
cf7d9b42	212	pr_err("comedi%d: undefined channel %d. channel range is 0 .. 23\n",
d22418b0 HS	213	minor, channel);
	214	return 0;
	215	}
	216
	217	/* getting previous written value */
	218	val = usp->usp_prev_wr_val[channel_offset - 1];
	219
	220	if (*data)
	221	val \|= mask;
	222	else
	223	val &= ~mask;
	224
	225	outb(val, usp->usp_iobase + channel_offset);
	226	/* saving new written value */
	227	usp->usp_prev_wr_val[channel_offset - 1] = val;
	228
	229	return 1;
	230	}
	231
	232	static int __unioxx5_analog_write(struct unioxx5_subd_priv *usp,
	233	unsigned int *data, int channel, int minor)
	234	{
	235	int module, i;
	236
	237	module = channel / 2; /* definig module number(0 .. 11) */
	238	i = (channel % 2) << 1; /* depends on type of channel (A or B) */
	239
	240	/* defining if given module can work on output */
	241	if (!(usp->usp_module_type[module] & MODULE_OUTPUT_MASK)) {
cf7d9b42	242	pr_err("comedi%d: module in position %d with id 0x%0x is for input only!\n",
d22418b0 HS	243	minor, module, usp->usp_module_type[module]);
	244	return 0;
	245	}
	246
	247	__unioxx5_analog_config(usp, channel);
	248	/* saving minor byte */
	249	usp->usp_extra_data[module][i++] = (unsigned char)(*data & 0x00FF);
	250	/* saving major byte */
	251	usp->usp_extra_data[module][i] = (unsigned char)((*data & 0xFF00) >> 8);
	252
	253	/* while(!((inb(usp->usp_iobase + 0)) & TxBE)); */
	254	/* sending module number to card(1 .. 12) */
	255	outb(module + 1, usp->usp_iobase + 5);
	256	outb('W', usp->usp_iobase + 6); /* sends (W)rite command to module */
	257
	258	/* sending for bytes to module(one byte per cycle iteration) */
	259	for (i = 0; i < 4; i++) {
	260	while (!((inb(usp->usp_iobase + 0)) & TxBE))
	261	; /* waits while writting will be allowed */
	262	outb(usp->usp_extra_data[module][i], usp->usp_iobase + 6);
	263	}
	264
	265	return 1;
	266	}
110526ed	267
0a85b6f0 MT	268	static int unioxx5_subdev_read(struct comedi_device *dev,
	269	struct comedi_subdevice *subdev,
	270	struct comedi_insn insn, unsigned int data)
110526ed	271	{
33a4640f	272	struct unioxx5_subd_priv *usp = subdev->private;
110526ed KD	273	int channel, type;
	274
	275	channel = CR_CHAN(insn->chanspec);
33e73e00 R	276	/* defining module type(analog or digital) */
33e73e00 R	277	type = usp->usp_module_type[channel / 2];
110526ed KD	278
	279	if (type == MODULE_DIGITAL) {
	280	if (!__unioxx5_digital_read(usp, data, channel, dev->minor))
	281	return -1;
	282	} else {
	283	if (!__unioxx5_analog_read(usp, data, channel, dev->minor))
	284	return -1;
	285	}
	286
	287	return 1;
	288	}
	289
0a85b6f0 MT	290	static int unioxx5_subdev_write(struct comedi_device *dev,
	291	struct comedi_subdevice *subdev,
	292	struct comedi_insn insn, unsigned int data)
110526ed	293	{
33a4640f	294	struct unioxx5_subd_priv *usp = subdev->private;
110526ed KD	295	int channel, type;
	296
	297	channel = CR_CHAN(insn->chanspec);
33e73e00 R	298	/* defining module type(analog or digital) */
33e73e00 R	299	type = usp->usp_module_type[channel / 2];
110526ed KD	300
	301	if (type == MODULE_DIGITAL) {
	302	if (!__unioxx5_digital_write(usp, data, channel, dev->minor))
	303	return -1;
	304	} else {
	305	if (!__unioxx5_analog_write(usp, data, channel, dev->minor))
	306	return -1;
	307	}
	308
	309	return 1;
	310	}
	311
	312	/* for digital modules only */
0a85b6f0 MT	313	static int unioxx5_insn_config(struct comedi_device *dev,
	314	struct comedi_subdevice *subdev,
	315	struct comedi_insn insn, unsigned int data)
110526ed KD	316	{
110526ed KD	317	int channel_offset, flags, channel = CR_CHAN(insn->chanspec), type;
33a4640f	318	struct unioxx5_subd_priv *usp = subdev->private;
110526ed KD	319	int mask = 1 << (channel & 0x07);
	320
	321	type = usp->usp_module_type[channel / 2];
	322
	323	if (type != MODULE_DIGITAL) {
cf7d9b42 YT	324	dev_err(dev->class_dev,
	325	"comedi%d: channel configuration accessible only for digital modules\n",
	326	dev->minor);
110526ed KD	327	return -1;
	328	}
	329
c3744138 BP	330	channel_offset = __unioxx5_define_chan_offset(channel);
c3744138 BP	331	if (channel_offset < 0) {
cf7d9b42 YT	332	dev_err(dev->class_dev,
	333	"comedi%d: undefined channel %d. channel range is 0 .. 23\n",
	334	dev->minor, channel);
110526ed KD	335	return -1;
	336	}
	337
	338	/* gets previously written value */
	339	flags = usp->usp_prev_cn_val[channel_offset - 1];
	340
	341	switch (*data) {
	342	case COMEDI_INPUT:
	343	flags &= ~mask;
	344	break;
	345	case COMEDI_OUTPUT:
	346	flags \|= mask;
	347	break;
	348	default:
cf7d9b42 YT	349	dev_err(dev->class_dev,
cf7d9b42 YT	350	"comedi%d: unknown flag\n", dev->minor);
110526ed KD	351	return -1;
	352	}
	353
	354	/* *\
	355	* sets channels buffer to 1(after this we are allowed to *
	356	* change channel type on input or output) *
	357	\* */
	358	outb(1, usp->usp_iobase + 0);
33e73e00 R	359	/* changes type of _one_ channel */
	360	outb(flags, usp->usp_iobase + channel_offset);
	361	/* sets channels bank to 0(allows directly input/output) */
	362	outb(0, usp->usp_iobase + 0);
	363	/* saves written value */
	364	usp->usp_prev_cn_val[channel_offset - 1] = flags;
110526ed KD	365
	366	return 0;
	367	}
	368
110526ed	369	/* initializing subdevice with given address */
dba89b14 HS	370	static int __unioxx5_subdev_init(struct comedi_device *dev,
	371	struct comedi_subdevice *s,
	372	int iobase)
110526ed	373	{
33a4640f	374	struct unioxx5_subd_priv *usp;
110526ed	375	int i, to, ndef_flag = 0;
dba89b14	376	int ret;
110526ed	377
dd671a39 HS	378	usp = kzalloc(sizeof(*usp), GFP_KERNEL);
	379	if (usp == NULL)
	380	return -ENOMEM;
	381
dba89b14	382	ret = __comedi_request_region(dev, iobase, UNIOXX5_SIZE);
f4362867 HS	383	if (ret) {
f4362867 HS	384	kfree(usp);
dba89b14	385	return ret;
f4362867	386	}
dba89b14	387	usp->usp_iobase = iobase;
110526ed	388
110526ed KD	389	/* defining modules types */
	390	for (i = 0; i < 12; i++) {
	391	to = 10000;
	392
	393	__unioxx5_analog_config(usp, i * 2);
33e73e00	394	/* sends channel number to card */
dba89b14 HS	395	outb(i + 1, iobase + 5);
	396	outb('H', iobase + 6); /* requests EEPROM world */
	397	while (!(inb(iobase + 0) & TxBE))
6fd071cc	398	; /* waits while writting will be allowed */
dba89b14	399	outb(0, iobase + 6);
110526ed KD	400
110526ed KD	401	/* waits while reading of two bytes will be allowed */
dba89b14	402	while (!(inb(iobase + 0) & Rx2CA)) {
110526ed KD	403	if (--to <= 0) {
	404	ndef_flag = 1;
	405	break;
	406	}
	407	}
	408
	409	if (ndef_flag) {
	410	usp->usp_module_type[i] = 0;
	411	ndef_flag = 0;
	412	} else
dba89b14	413	usp->usp_module_type[i] = inb(iobase + 6);
110526ed	414
5f74ea14	415	udelay(1);
110526ed KD	416	}
110526ed KD	417
110526ed	418	/* initial subdevice for digital or analog i/o */
dba89b14 HS	419	s->type = COMEDI_SUBD_DIO;
	420	s->private = usp;
	421	s->subdev_flags = SDF_READABLE \| SDF_WRITABLE;
	422	s->n_chan = UNIOXX5_NUM_OF_CHANS;
	423	s->maxdata = 0xFFF;
	424	s->range_table = &range_digital;
	425	s->insn_read = unioxx5_subdev_read;
	426	s->insn_write = unioxx5_subdev_write;
33e73e00	427	/* for digital modules only!!! */
dba89b14	428	s->insn_config = unioxx5_insn_config;
110526ed	429
110526ed KD	430	return 0;
	431	}
	432
40e7f510 HS	433	static int unioxx5_attach(struct comedi_device *dev,
	434	struct comedi_devconfig *it)
	435	{
dba89b14	436	struct comedi_subdevice *s;
40e7f510 HS	437	int iobase, i, n_subd;
40e7f510 HS	438	int id, num, ba;
8b6c5694	439	int ret;
40e7f510 HS	440
	441	iobase = it->options[0];
	442
40e7f510 HS	443	dev->iobase = iobase;
	444	iobase += UNIOXX5_SUBDEV_BASE;
	445
	446	/* defining number of subdevices and getting they types (it must be 'g01') */
	447	for (i = n_subd = 0, ba = iobase; i < 4; i++, ba += UNIOXX5_SUBDEV_ODDS) {
	448	id = inb(ba + 0xE);
	449	num = inb(ba + 0xF);
	450
	451	if (id != 'g' \|\| num != 1)
	452	continue;
	453
	454	n_subd++;
	455	}
	456
	457	/* unioxx5 can has from two to four subdevices */
	458	if (n_subd < 2) {
cf7d9b42 YT	459	dev_err(dev->class_dev,
cf7d9b42 YT	460	"your card must has at least 2 'g01' subdevices\n");
40e7f510 HS	461	return -1;
	462	}
	463
8b6c5694 HS	464	ret = comedi_alloc_subdevices(dev, n_subd);
	465	if (ret)
	466	return ret;
40e7f510 HS	467
	468	/* initializing each of for same subdevices */
	469	for (i = 0; i < n_subd; i++, iobase += UNIOXX5_SUBDEV_ODDS) {
dba89b14 HS	470	s = &dev->subdevices[i];
	471	ret = __unioxx5_subdev_init(dev, s, iobase);
	472	if (ret)
	473	return ret;
40e7f510 HS	474	}
40e7f510 HS	475
40e7f510 HS	476	return 0;
	477	}
	478
484ecc95	479	static void unioxx5_detach(struct comedi_device *dev)
40e7f510 HS	480	{
	481	int i;
	482	struct comedi_subdevice *subdev;
	483	struct unioxx5_subd_priv *usp;
	484
	485	for (i = 0; i < dev->n_subdevices; i++) {
	486	subdev = &dev->subdevices[i];
	487	usp = subdev->private;
	488	release_region(usp->usp_iobase, UNIOXX5_SIZE);
	489	kfree(subdev->private);
	490	}
40e7f510 HS	491	}
	492
	493	static struct comedi_driver unioxx5_driver = {
	494	.driver_name = DRIVER_NAME,
	495	.module = THIS_MODULE,
	496	.attach = unioxx5_attach,
	497	.detach = unioxx5_detach,
	498	};
	499	module_comedi_driver(unioxx5_driver);
	500
90f703d3 AT	501	MODULE_AUTHOR("Comedi http://www.comedi.org");
	502	MODULE_DESCRIPTION("Comedi low-level driver");
	503	MODULE_LICENSE("GPL");