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

/*
    comedi/drivers/ssv_dnp.c
    generic comedi driver for SSV Embedded Systems' DIL/Net-PCs
    Copyright (C) 2001 Robert Schwebel <robert@schwebel.de>

    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.

*/
/*
Driver: ssv_dnp
Description: SSV Embedded Systems DIL/Net-PC
Author: Robert Schwebel <robert@schwebel.de>
Devices: [SSV Embedded Systems] DIL/Net-PC 1486 (dnp-1486)
Status: unknown
*/

/* include files ----------------------------------------------------------- */

#include "../comedidev.h"

/* Some global definitions: the registers of the DNP ----------------------- */
/*                                                                           */
/* For port A and B the mode register has bits corresponding to the output   */
/* pins, where Bit-N = 0 -> input, Bit-N = 1 -> output. Note that bits       */
/* 4 to 7 correspond to pin 0..3 for port C data register. Ensure that bits  */
/* 0..3 remain unchanged! For details about Port C Mode Register see         */
/* the remarks in dnp_insn_config() below.                                   */

#define CSCIR 0x22		/* Chip Setup and Control Index Register       */
#define CSCDR 0x23		/* Chip Setup and Control Data Register        */
#define PAMR  0xa5		/* Port A Mode Register                        */
#define PADR  0xa9		/* Port A Data Register                        */
#define PBMR  0xa4		/* Port B Mode Register                        */
#define PBDR  0xa8		/* Port B Data Register                        */
#define PCMR  0xa3		/* Port C Mode Register                        */
#define PCDR  0xa7		/* Port C Data Register                        */

/* This data structure holds information about the supported boards -------- */

struct dnp_board {
	const char *name;
	int ai_chans;
	int ai_bits;
	int have_dio;
};

static const struct dnp_board dnp_boards[] = {	/* we only support one DNP 'board'   */
	{			/* variant at the moment             */
	      name:	"dnp-1486",
	      ai_chans:16,
	      ai_bits:	12,
	      have_dio:1,
		},
};

/* Useful for shorthand access to the particular board structure ----------- */
#define thisboard ((const struct dnp_board *)dev->board_ptr)

/* This structure is for data unique to the DNP driver --------------------- */
struct dnp_private_data {

};


/* Shorthand macro for faster access to the private data ------------------- */
#define devpriv ((dnp_private *)dev->private)

/* ------------------------------------------------------------------------- */
/* The struct comedi_driver structure tells the Comedi core module which functions  */
/* to call to configure/deconfigure (attach/detach) the board, and also      */
/* about the kernel module that contains the device code.                    */
/*                                                                           */
/* In the following section we define the API of this driver.                */
/* ------------------------------------------------------------------------- */

static int dnp_attach(struct comedi_device * dev, struct comedi_devconfig * it);
static int dnp_detach(struct comedi_device * dev);

static struct comedi_driver driver_dnp = {
      driver_name:"ssv_dnp",
      module:THIS_MODULE,
      attach:dnp_attach,
      detach:dnp_detach,
      board_name:&dnp_boards[0].name,
	/* only necessary for non-PnP devs   */
      offset:sizeof(struct dnp_board),/* like ISA-PnP, PCI or PCMCIA.      */
      num_names:sizeof(dnp_boards) / sizeof(struct dnp_board),
};

COMEDI_INITCLEANUP(driver_dnp);

static int dnp_dio_insn_bits(struct comedi_device * dev,
	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data);

static int dnp_dio_insn_config(struct comedi_device * dev,
	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data);

/* ------------------------------------------------------------------------- */
/* Attach is called by comedi core to configure the driver for a particular  */
/* board. If you specified a board_name array in the driver structure,       */
/* dev->board_ptr contains that address.                                     */
/* ------------------------------------------------------------------------- */

static int dnp_attach(struct comedi_device * dev, struct comedi_devconfig * it)
{

	struct comedi_subdevice *s;

	printk("comedi%d: dnp: ", dev->minor);

	/* Autoprobing: this should find out which board we have. Currently only   */
	/* the 1486 board is supported and autoprobing is not implemented :-)      */
	/* dev->board_ptr = dnp_probe(dev); */

	/* Initialize the name of the board. We can use the "thisboard" macro now. */
	dev->board_name = thisboard->name;

	/* Allocate the private structure area. alloc_private() is a convenient    */
	/* macro defined in comedidev.h.                                           */
	if (alloc_private(dev, sizeof(struct dnp_private_data)) < 0)
		return -ENOMEM;

	/* Allocate the subdevice structures. alloc_subdevice() is a convenient    */
	/* macro defined in comedidev.h.                                           */

	if (alloc_subdevices(dev, 1) < 0)
		return -ENOMEM;

	s = dev->subdevices + 0;
	/* digital i/o subdevice                                                   */
	s->type = COMEDI_SUBD_DIO;
	s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
	s->n_chan = 20;
	s->maxdata = 1;
	s->range_table = &range_digital;
	s->insn_bits = dnp_dio_insn_bits;
	s->insn_config = dnp_dio_insn_config;

	printk("attached\n");

	/* We use the I/O ports 0x22,0x23 and 0xa3-0xa9, which are always
	 * allocated for the primary 8259, so we don't need to allocate them
	 * ourselves. */

	/* configure all ports as input (default)                                  */
	outb(PAMR, CSCIR);
	outb(0x00, CSCDR);
	outb(PBMR, CSCIR);
	outb(0x00, CSCDR);
	outb(PCMR, CSCIR);
	outb((inb(CSCDR) & 0xAA), CSCDR);

	return 1;

}

/* ------------------------------------------------------------------------- */
/* detach is called to deconfigure a device. It should deallocate the        */
/* resources. This function is also called when _attach() fails, so it       */
/* should be careful not to release resources that were not necessarily      */
/* allocated by _attach(). dev->private and dev->subdevices are              */
/* deallocated automatically by the core.                                    */
/* ------------------------------------------------------------------------- */

static int dnp_detach(struct comedi_device * dev)
{

	/* configure all ports as input (default)                                  */
	outb(PAMR, CSCIR);
	outb(0x00, CSCDR);
	outb(PBMR, CSCIR);
	outb(0x00, CSCDR);
	outb(PCMR, CSCIR);
	outb((inb(CSCDR) & 0xAA), CSCDR);

	/* announce that we are finished                                           */
	printk("comedi%d: dnp: remove\n", dev->minor);

	return 0;

}

/* ------------------------------------------------------------------------- */
/* The insn_bits interface allows packed reading/writing of DIO channels.    */
/* The comedi core can convert between insn_bits and insn_read/write, so you */
/* are able to use these instructions as well.                               */
/* ------------------------------------------------------------------------- */

static int dnp_dio_insn_bits(struct comedi_device * dev,
	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data)
{

	if (insn->n != 2)
		return -EINVAL;	/* insn uses data[0] and data[1]     */

	/* The insn data is a mask in data[0] and the new data in data[1], each    */
	/* channel cooresponding to a bit.                                         */

	/* Ports A and B are straight forward: each bit corresponds to an output   */
	/* pin with the same order. Port C is different: bits 0...3 correspond to  */
	/* bits 4...7 of the output register (PCDR).                               */

	if (data[0]) {

		outb(PADR, CSCIR);
		outb((inb(CSCDR)
				& ~(u8) (data[0] & 0x0000FF))
			| (u8) (data[1] & 0x0000FF), CSCDR);

		outb(PBDR, CSCIR);
		outb((inb(CSCDR)
				& ~(u8) ((data[0] & 0x00FF00) >> 8))
			| (u8) ((data[1] & 0x00FF00) >> 8), CSCDR);

		outb(PCDR, CSCIR);
		outb((inb(CSCDR)
				& ~(u8) ((data[0] & 0x0F0000) >> 12))
			| (u8) ((data[1] & 0x0F0000) >> 12), CSCDR);
	}

	/* on return, data[1] contains the value of the digital input lines.       */
	outb(PADR, CSCIR);
	data[0] = inb(CSCDR);
	outb(PBDR, CSCIR);
	data[0] += inb(CSCDR) << 8;
	outb(PCDR, CSCIR);
	data[0] += ((inb(CSCDR) & 0xF0) << 12);

	return 2;

}

/* ------------------------------------------------------------------------- */
/* Configure the direction of the bidirectional digital i/o pins. chanspec   */
/* contains the channel to be changed and data[0] contains either            */
/* COMEDI_INPUT or COMEDI_OUTPUT.                                            */
/* ------------------------------------------------------------------------- */

static int dnp_dio_insn_config(struct comedi_device * dev,
	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data)
{

	u8 register_buffer;

	int chan = CR_CHAN(insn->chanspec);	/* reduces chanspec to lower 16 bits */

	switch (data[0]) {
	case INSN_CONFIG_DIO_OUTPUT:
	case INSN_CONFIG_DIO_INPUT:
		break;
	case INSN_CONFIG_DIO_QUERY:
		data[1] =
			(inb(CSCDR) & (1 << chan)) ? COMEDI_OUTPUT :
			COMEDI_INPUT;
		return insn->n;
		break;
	default:
		return -EINVAL;
		break;
	}
	/* Test: which port does the channel belong to?                            */

	/* We have to pay attention with port C: this is the meaning of PCMR:      */
	/* Bit in PCMR:              7 6 5 4 3 2 1 0                               */
	/* Corresponding port C pin: d 3 d 2 d 1 d 0   d= don't touch              */

	if ((chan >= 0) && (chan <= 7)) {
		/* this is port A */
		outb(PAMR, CSCIR);
	} else if ((chan >= 8) && (chan <= 15)) {
		/* this is port B */
		chan -= 8;
		outb(PBMR, CSCIR);
	} else if ((chan >= 16) && (chan <= 19)) {
		/* this is port C; multiplication with 2 brings bits into correct        */
		/* position for PCMR!                                                    */
		chan -= 16;
		chan *= 2;
		outb(PCMR, CSCIR);
	} else {
		return -EINVAL;
	}

	/* read 'old' direction of the port and set bits (out=1, in=0)             */
	register_buffer = inb(CSCDR);
	if (data[0] == COMEDI_OUTPUT) {
		register_buffer |= (1 << chan);
	} else {
		register_buffer &= ~(1 << chan);
	}
	outb(register_buffer, CSCDR);

	return 1;

}
Commit	Line	Data
18222f98 RS	1	/*
	2	comedi/drivers/ssv_dnp.c
	3	generic comedi driver for SSV Embedded Systems' DIL/Net-PCs
	4	Copyright (C) 2001 Robert Schwebel <robert@schwebel.de>
	5
	6	COMEDI - Linux Control and Measurement Device Interface
	7	Copyright (C) 2000 David A. Schleef <ds@schleef.org>
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	22
	23	*/
	24	/*
	25	Driver: ssv_dnp
	26	Description: SSV Embedded Systems DIL/Net-PC
	27	Author: Robert Schwebel <robert@schwebel.de>
	28	Devices: [SSV Embedded Systems] DIL/Net-PC 1486 (dnp-1486)
	29	Status: unknown
	30	*/
	31
	32	/* include files ----------------------------------------------------------- */
	33
	34	#include "../comedidev.h"
	35
	36	/* Some global definitions: the registers of the DNP ----------------------- */
	37	/* */
	38	/* For port A and B the mode register has bits corresponding to the output */
	39	/* pins, where Bit-N = 0 -> input, Bit-N = 1 -> output. Note that bits */
	40	/* 4 to 7 correspond to pin 0..3 for port C data register. Ensure that bits */
	41	/* 0..3 remain unchanged! For details about Port C Mode Register see */
	42	/* the remarks in dnp_insn_config() below. */
	43
	44	#define CSCIR 0x22 /* Chip Setup and Control Index Register */
	45	#define CSCDR 0x23 /* Chip Setup and Control Data Register */
	46	#define PAMR 0xa5 /* Port A Mode Register */
	47	#define PADR 0xa9 /* Port A Data Register */
	48	#define PBMR 0xa4 /* Port B Mode Register */
	49	#define PBDR 0xa8 /* Port B Data Register */
	50	#define PCMR 0xa3 /* Port C Mode Register */
	51	#define PCDR 0xa7 /* Port C Data Register */
	52
	53	/* This data structure holds information about the supported boards -------- */
	54
c0d14822	55	struct dnp_board {
18222f98 RS	56	const char *name;
	57	int ai_chans;
	58	int ai_bits;
	59	int have_dio;
c0d14822	60	};
18222f98	61
c0d14822	62	static const struct dnp_board dnp_boards[] = { /* we only support one DNP 'board' */
18222f98 RS	63	{ /* variant at the moment */
	64	name: "dnp-1486",
	65	ai_chans:16,
	66	ai_bits: 12,
	67	have_dio:1,
	68	},
	69	};
	70
	71	/* Useful for shorthand access to the particular board structure ----------- */
c0d14822	72	#define thisboard ((const struct dnp_board *)dev->board_ptr)
18222f98 RS	73
18222f98 RS	74	/* This structure is for data unique to the DNP driver --------------------- */
85325300 BP	75	struct dnp_private_data {
85325300 BP	76
85325300 BP	77	};
85325300 BP	78
18222f98 RS	79
	80	/* Shorthand macro for faster access to the private data ------------------- */
	81	#define devpriv ((dnp_private *)dev->private)
	82
	83	/* ------------------------------------------------------------------------- */
139dfbdf	84	/* The struct comedi_driver structure tells the Comedi core module which functions */
18222f98 RS	85	/* to call to configure/deconfigure (attach/detach) the board, and also */
	86	/* about the kernel module that contains the device code. */
	87	/* */
	88	/* In the following section we define the API of this driver. */
	89	/* ------------------------------------------------------------------------- */
	90
0707bb04	91	static int dnp_attach(struct comedi_device * dev, struct comedi_devconfig * it);
71b5f4f1	92	static int dnp_detach(struct comedi_device * dev);
18222f98	93
139dfbdf	94	static struct comedi_driver driver_dnp = {
18222f98 RS	95	driver_name:"ssv_dnp",
	96	module:THIS_MODULE,
	97	attach:dnp_attach,
	98	detach:dnp_detach,
	99	board_name:&dnp_boards[0].name,
	100	/* only necessary for non-PnP devs */
c0d14822 BP	101	offset:sizeof(struct dnp_board),/* like ISA-PnP, PCI or PCMCIA. */
c0d14822 BP	102	num_names:sizeof(dnp_boards) / sizeof(struct dnp_board),
18222f98 RS	103	};
	104
	105	COMEDI_INITCLEANUP(driver_dnp);
	106
71b5f4f1	107	static int dnp_dio_insn_bits(struct comedi_device * dev,
90035c08	108	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data);
18222f98	109
71b5f4f1	110	static int dnp_dio_insn_config(struct comedi_device * dev,
90035c08	111	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data);
18222f98 RS	112
	113	/* ------------------------------------------------------------------------- */
	114	/* Attach is called by comedi core to configure the driver for a particular */
	115	/* board. If you specified a board_name array in the driver structure, */
	116	/* dev->board_ptr contains that address. */
	117	/* ------------------------------------------------------------------------- */
	118
0707bb04	119	static int dnp_attach(struct comedi_device * dev, struct comedi_devconfig * it)
18222f98 RS	120	{
18222f98 RS	121
34c43922	122	struct comedi_subdevice *s;
18222f98 RS	123
	124	printk("comedi%d: dnp: ", dev->minor);
	125
	126	/* Autoprobing: this should find out which board we have. Currently only */
	127	/* the 1486 board is supported and autoprobing is not implemented :-) */
2696fb57	128	/* dev->board_ptr = dnp_probe(dev); */
18222f98 RS	129
	130	/* Initialize the name of the board. We can use the "thisboard" macro now. */
	131	dev->board_name = thisboard->name;
	132
	133	/* Allocate the private structure area. alloc_private() is a convenient */
	134	/* macro defined in comedidev.h. */
85325300	135	if (alloc_private(dev, sizeof(struct dnp_private_data)) < 0)
18222f98 RS	136	return -ENOMEM;
	137
	138	/* Allocate the subdevice structures. alloc_subdevice() is a convenient */
	139	/* macro defined in comedidev.h. */
	140
	141	if (alloc_subdevices(dev, 1) < 0)
	142	return -ENOMEM;
	143
	144	s = dev->subdevices + 0;
	145	/* digital i/o subdevice */
	146	s->type = COMEDI_SUBD_DIO;
	147	s->subdev_flags = SDF_READABLE \| SDF_WRITABLE;
	148	s->n_chan = 20;
	149	s->maxdata = 1;
	150	s->range_table = &range_digital;
	151	s->insn_bits = dnp_dio_insn_bits;
	152	s->insn_config = dnp_dio_insn_config;
	153
	154	printk("attached\n");
	155
	156	/* We use the I/O ports 0x22,0x23 and 0xa3-0xa9, which are always
	157	* allocated for the primary 8259, so we don't need to allocate them
	158	* ourselves. */
	159
	160	/* configure all ports as input (default) */
	161	outb(PAMR, CSCIR);
	162	outb(0x00, CSCDR);
	163	outb(PBMR, CSCIR);
	164	outb(0x00, CSCDR);
	165	outb(PCMR, CSCIR);
	166	outb((inb(CSCDR) & 0xAA), CSCDR);
	167
	168	return 1;
	169
	170	}
	171
	172	/* ------------------------------------------------------------------------- */
	173	/* detach is called to deconfigure a device. It should deallocate the */
	174	/* resources. This function is also called when _attach() fails, so it */
	175	/* should be careful not to release resources that were not necessarily */
	176	/* allocated by _attach(). dev->private and dev->subdevices are */
	177	/* deallocated automatically by the core. */
	178	/* ------------------------------------------------------------------------- */
	179
71b5f4f1	180	static int dnp_detach(struct comedi_device * dev)
18222f98 RS	181	{
	182
	183	/* configure all ports as input (default) */
	184	outb(PAMR, CSCIR);
	185	outb(0x00, CSCDR);
	186	outb(PBMR, CSCIR);
	187	outb(0x00, CSCDR);
	188	outb(PCMR, CSCIR);
	189	outb((inb(CSCDR) & 0xAA), CSCDR);
	190
	191	/* announce that we are finished */
	192	printk("comedi%d: dnp: remove\n", dev->minor);
	193
	194	return 0;
	195
	196	}
	197
	198	/* ------------------------------------------------------------------------- */
	199	/* The insn_bits interface allows packed reading/writing of DIO channels. */
	200	/* The comedi core can convert between insn_bits and insn_read/write, so you */
	201	/* are able to use these instructions as well. */
	202	/* ------------------------------------------------------------------------- */
	203
71b5f4f1	204	static int dnp_dio_insn_bits(struct comedi_device * dev,
90035c08	205	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data)
18222f98 RS	206	{
	207
	208	if (insn->n != 2)
	209	return -EINVAL; /* insn uses data[0] and data[1] */
	210
	211	/* The insn data is a mask in data[0] and the new data in data[1], each */
	212	/* channel cooresponding to a bit. */
	213
	214	/* Ports A and B are straight forward: each bit corresponds to an output */
	215	/* pin with the same order. Port C is different: bits 0...3 correspond to */
	216	/* bits 4...7 of the output register (PCDR). */
	217
	218	if (data[0]) {
	219
	220	outb(PADR, CSCIR);
	221	outb((inb(CSCDR)
	222	& ~(u8) (data[0] & 0x0000FF))
	223	\| (u8) (data[1] & 0x0000FF), CSCDR);
	224
	225	outb(PBDR, CSCIR);
	226	outb((inb(CSCDR)
	227	& ~(u8) ((data[0] & 0x00FF00) >> 8))
	228	\| (u8) ((data[1] & 0x00FF00) >> 8), CSCDR);
	229
	230	outb(PCDR, CSCIR);
	231	outb((inb(CSCDR)
	232	& ~(u8) ((data[0] & 0x0F0000) >> 12))
	233	\| (u8) ((data[1] & 0x0F0000) >> 12), CSCDR);
	234	}
	235
	236	/* on return, data[1] contains the value of the digital input lines. */
	237	outb(PADR, CSCIR);
	238	data[0] = inb(CSCDR);
	239	outb(PBDR, CSCIR);
	240	data[0] += inb(CSCDR) << 8;
	241	outb(PCDR, CSCIR);
	242	data[0] += ((inb(CSCDR) & 0xF0) << 12);
	243
	244	return 2;
	245
	246	}
	247
	248	/* ------------------------------------------------------------------------- */
	249	/* Configure the direction of the bidirectional digital i/o pins. chanspec */
	250	/* contains the channel to be changed and data[0] contains either */
	251	/* COMEDI_INPUT or COMEDI_OUTPUT. */
	252	/* ------------------------------------------------------------------------- */
	253
71b5f4f1	254	static int dnp_dio_insn_config(struct comedi_device * dev,
90035c08	255	struct comedi_subdevice * s, struct comedi_insn * insn, unsigned int * data)
18222f98 RS	256	{
	257
	258	u8 register_buffer;
	259
	260	int chan = CR_CHAN(insn->chanspec); /* reduces chanspec to lower 16 bits */
	261
	262	switch (data[0]) {
	263	case INSN_CONFIG_DIO_OUTPUT:
	264	case INSN_CONFIG_DIO_INPUT:
	265	break;
	266	case INSN_CONFIG_DIO_QUERY:
	267	data[1] =
	268	(inb(CSCDR) & (1 << chan)) ? COMEDI_OUTPUT :
	269	COMEDI_INPUT;
	270	return insn->n;
	271	break;
	272	default:
	273	return -EINVAL;
	274	break;
	275	}
	276	/* Test: which port does the channel belong to? */
	277
	278	/* We have to pay attention with port C: this is the meaning of PCMR: */
	279	/* Bit in PCMR: 7 6 5 4 3 2 1 0 */
	280	/* Corresponding port C pin: d 3 d 2 d 1 d 0 d= don't touch */
	281
	282	if ((chan >= 0) && (chan <= 7)) {
	283	/* this is port A */
	284	outb(PAMR, CSCIR);
	285	} else if ((chan >= 8) && (chan <= 15)) {
	286	/* this is port B */
	287	chan -= 8;
	288	outb(PBMR, CSCIR);
	289	} else if ((chan >= 16) && (chan <= 19)) {
	290	/* this is port C; multiplication with 2 brings bits into correct */
	291	/* position for PCMR! */
	292	chan -= 16;
	293	chan *= 2;
	294	outb(PCMR, CSCIR);
	295	} else {
	296	return -EINVAL;
	297	}
	298
	299	/* read 'old' direction of the port and set bits (out=1, in=0) */
	300	register_buffer = inb(CSCDR);
	301	if (data[0] == COMEDI_OUTPUT) {
	302	register_buffer \|= (1 << chan);
	303	} else {
	304	register_buffer &= ~(1 << chan);
	305	}
	306	outb(register_buffer, CSCDR);
	307
	308	return 1;
	309
	310	}