rti800.c revision 0a85b6f0ab0d2edb0d41b32697111ce0e4f43496 
1/*
2   comedi/drivers/rti800.c
3   Hardware driver for Analog Devices RTI-800/815 board
4
5   COMEDI - Linux Control and Measurement Device Interface
6   Copyright (C) 1998 David A. Schleef <ds@schleef.org>
7
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2 of the License, or
11   (at your option) any later version.
12
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
22 */
23/*
24Driver: rti800
25Description: Analog Devices RTI-800/815
26Author: ds
27Status: unknown
28Updated: Fri, 05 Sep 2008 14:50:44 +0100
29Devices: [Analog Devices] RTI-800 (rti800), RTI-815 (rti815)
30
31Configuration options:
32  [0] - I/O port base address
33  [1] - IRQ
34  [2] - A/D reference
35          0 = differential
36          1 = pseudodifferential (common)
37          2 = single-ended
38  [3] - A/D range
39          0 = [-10,10]
40          1 = [-5,5]
41          2 = [0,10]
42  [4] - A/D encoding
43          0 = two's complement
44          1 = straight binary
45  [5] - DAC 0 range
46          0 = [-10,10]
47          1 = [0,10]
48  [6] - DAC 0 encoding
49          0 = two's complement
50          1 = straight binary
51  [7] - DAC 1 range (same as DAC 0)
52  [8] - DAC 1 encoding (same as DAC 0)
53*/
54
55#include <linux/interrupt.h>
56#include "../comedidev.h"
57
58#include <linux/ioport.h>
59
60#define RTI800_SIZE 16
61
62#define RTI800_CSR 0
63#define RTI800_MUXGAIN 1
64#define RTI800_CONVERT 2
65#define RTI800_ADCLO 3
66#define RTI800_ADCHI 4
67#define RTI800_DAC0LO 5
68#define RTI800_DAC0HI 6
69#define RTI800_DAC1LO 7
70#define RTI800_DAC1HI 8
71#define RTI800_CLRFLAGS 9
72#define RTI800_DI 10
73#define RTI800_DO 11
74#define RTI800_9513A_DATA 12
75#define RTI800_9513A_CNTRL 13
76#define RTI800_9513A_STATUS 13
77
78/*
79 * flags for CSR register
80 */
81
82#define RTI800_BUSY		0x80
83#define RTI800_DONE		0x40
84#define RTI800_OVERRUN		0x20
85#define RTI800_TCR		0x10
86#define RTI800_DMA_ENAB		0x08
87#define RTI800_INTR_TC		0x04
88#define RTI800_INTR_EC		0x02
89#define RTI800_INTR_OVRN	0x01
90
91#define Am9513_8BITBUS
92
93#define Am9513_output_control(a)	outb(a, dev->iobase+RTI800_9513A_CNTRL)
94#define Am9513_output_data(a)		outb(a, dev->iobase+RTI800_9513A_DATA)
95#define Am9513_input_data()		inb(dev->iobase+RTI800_9513A_DATA)
96#define Am9513_input_status()		inb(dev->iobase+RTI800_9513A_STATUS)
97
98#include "am9513.h"
99
100static const struct comedi_lrange range_rti800_ai_10_bipolar = { 4, {
101								     BIP_RANGE
102								     (10),
103								     BIP_RANGE
104								     (1),
105								     BIP_RANGE
106								     (0.1),
107								     BIP_RANGE
108								     (0.02)
109								     }
110};
111
112static const struct comedi_lrange range_rti800_ai_5_bipolar = { 4, {
113								    BIP_RANGE
114								    (5),
115								    BIP_RANGE
116								    (0.5),
117								    BIP_RANGE
118								    (0.05),
119								    BIP_RANGE
120								    (0.01)
121								    }
122};
123
124static const struct comedi_lrange range_rti800_ai_unipolar = { 4, {
125								   UNI_RANGE
126								   (10),
127								   UNI_RANGE(1),
128								   UNI_RANGE
129								   (0.1),
130								   UNI_RANGE
131								   (0.02)
132								   }
133};
134
135struct rti800_board {
136
137	const char *name;
138	int has_ao;
139};
140
141static const struct rti800_board boardtypes[] = {
142	{"rti800", 0},
143	{"rti815", 1},
144};
145
146#define this_board ((const struct rti800_board *)dev->board_ptr)
147
148static int rti800_attach(struct comedi_device *dev,
149			 struct comedi_devconfig *it);
150static int rti800_detach(struct comedi_device *dev);
151static struct comedi_driver driver_rti800 = {
152	.driver_name = "rti800",
153	.module = THIS_MODULE,
154	.attach = rti800_attach,
155	.detach = rti800_detach,
156	.num_names = ARRAY_SIZE(boardtypes),
157	.board_name = &boardtypes[0].name,
158	.offset = sizeof(struct rti800_board),
159};
160
161COMEDI_INITCLEANUP(driver_rti800);
162
163static irqreturn_t rti800_interrupt(int irq, void *dev);
164
165struct rti800_private {
166	enum {
167		adc_diff, adc_pseudodiff, adc_singleended
168	} adc_mux;
169	enum {
170		adc_bipolar10, adc_bipolar5, adc_unipolar10
171	} adc_range;
172	enum {
173		adc_2comp, adc_straight
174	} adc_coding;
175	enum {
176		dac_bipolar10, dac_unipolar10
177	} dac0_range, dac1_range;
178	enum {
179		dac_2comp, dac_straight
180	} dac0_coding, dac1_coding;
181	const struct comedi_lrange *ao_range_type_list[2];
182	unsigned int ao_readback[2];
183	int muxgain_bits;
184};
185
186#define devpriv ((struct rti800_private *)dev->private)
187
188#define RTI800_TIMEOUT 100
189
190static irqreturn_t rti800_interrupt(int irq, void *dev)
191{
192	return IRQ_HANDLED;
193}
194
195/* settling delay times in usec for different gains */
196static const int gaindelay[] = { 10, 20, 40, 80 };
197
198static int rti800_ai_insn_read(struct comedi_device *dev,
199			       struct comedi_subdevice *s,
200			       struct comedi_insn *insn, unsigned int *data)
201{
202	int i, t;
203	int status;
204	int chan = CR_CHAN(insn->chanspec);
205	unsigned gain = CR_RANGE(insn->chanspec);
206	unsigned muxgain_bits;
207
208	inb(dev->iobase + RTI800_ADCHI);
209	outb(0, dev->iobase + RTI800_CLRFLAGS);
210
211	muxgain_bits = chan | (gain << 5);
212	if (muxgain_bits != devpriv->muxgain_bits) {
213		devpriv->muxgain_bits = muxgain_bits;
214		outb(devpriv->muxgain_bits, dev->iobase + RTI800_MUXGAIN);
215		/* without a delay here, the RTI_OVERRUN bit
216		 * gets set, and you will have an error. */
217		if (insn->n > 0) {
218			BUG_ON(gain >= ARRAY_SIZE(gaindelay));
219			udelay(gaindelay[gain]);
220		}
221	}
222
223	for (i = 0; i < insn->n; i++) {
224		outb(0, dev->iobase + RTI800_CONVERT);
225		for (t = RTI800_TIMEOUT; t; t--) {
226			status = inb(dev->iobase + RTI800_CSR);
227			if (status & RTI800_OVERRUN) {
228				printk("rti800: a/d overrun\n");
229				outb(0, dev->iobase + RTI800_CLRFLAGS);
230				return -EIO;
231			}
232			if (status & RTI800_DONE)
233				break;
234			udelay(1);
235		}
236		if (t == 0) {
237			printk("rti800: timeout\n");
238			return -ETIME;
239		}
240		data[i] = inb(dev->iobase + RTI800_ADCLO);
241		data[i] |= (0xf & inb(dev->iobase + RTI800_ADCHI)) << 8;
242
243		if (devpriv->adc_coding == adc_2comp) {
244			data[i] ^= 0x800;
245		}
246	}
247
248	return i;
249}
250
251static int rti800_ao_insn_read(struct comedi_device *dev,
252			       struct comedi_subdevice *s,
253			       struct comedi_insn *insn, unsigned int *data)
254{
255	int i;
256	int chan = CR_CHAN(insn->chanspec);
257
258	for (i = 0; i < insn->n; i++)
259		data[i] = devpriv->ao_readback[chan];
260
261	return i;
262}
263
264static int rti800_ao_insn_write(struct comedi_device *dev,
265				struct comedi_subdevice *s,
266				struct comedi_insn *insn, unsigned int *data)
267{
268	int chan = CR_CHAN(insn->chanspec);
269	int d;
270	int i;
271
272	for (i = 0; i < insn->n; i++) {
273		devpriv->ao_readback[chan] = d = data[i];
274		if (devpriv->dac0_coding == dac_2comp) {
275			d ^= 0x800;
276		}
277		outb(d & 0xff,
278		     dev->iobase + (chan ? RTI800_DAC1LO : RTI800_DAC0LO));
279		outb(d >> 8,
280		     dev->iobase + (chan ? RTI800_DAC1HI : RTI800_DAC0HI));
281	}
282	return i;
283}
284
285static int rti800_di_insn_bits(struct comedi_device *dev,
286			       struct comedi_subdevice *s,
287			       struct comedi_insn *insn, unsigned int *data)
288{
289	if (insn->n != 2)
290		return -EINVAL;
291	data[1] = inb(dev->iobase + RTI800_DI);
292	return 2;
293}
294
295static int rti800_do_insn_bits(struct comedi_device *dev,
296			       struct comedi_subdevice *s,
297			       struct comedi_insn *insn, unsigned int *data)
298{
299	if (insn->n != 2)
300		return -EINVAL;
301
302	if (data[0]) {
303		s->state &= ~data[0];
304		s->state |= data[0] & data[1];
305		/* Outputs are inverted... */
306		outb(s->state ^ 0xff, dev->iobase + RTI800_DO);
307	}
308
309	data[1] = s->state;
310
311	return 2;
312}
313
314/*
315   options[0] - I/O port
316   options[1] - irq
317   options[2] - a/d mux
318   	0=differential, 1=pseudodiff, 2=single
319   options[3] - a/d range
320   	0=bipolar10, 1=bipolar5, 2=unipolar10
321   options[4] - a/d coding
322   	0=2's comp, 1=straight binary
323   options[5] - dac0 range
324   	0=bipolar10, 1=unipolar10
325   options[6] - dac0 coding
326   	0=2's comp, 1=straight binary
327   options[7] - dac1 range
328   options[8] - dac1 coding
329 */
330
331static int rti800_attach(struct comedi_device *dev, struct comedi_devconfig *it)
332{
333	unsigned int irq;
334	unsigned long iobase;
335	int ret;
336	struct comedi_subdevice *s;
337
338	iobase = it->options[0];
339	printk("comedi%d: rti800: 0x%04lx ", dev->minor, iobase);
340	if (!request_region(iobase, RTI800_SIZE, "rti800")) {
341		printk("I/O port conflict\n");
342		return -EIO;
343	}
344	dev->iobase = iobase;
345
346#ifdef DEBUG
347	printk("fingerprint=%x,%x,%x,%x,%x ",
348	       inb(dev->iobase + 0),
349	       inb(dev->iobase + 1),
350	       inb(dev->iobase + 2),
351	       inb(dev->iobase + 3), inb(dev->iobase + 4));
352#endif
353
354	outb(0, dev->iobase + RTI800_CSR);
355	inb(dev->iobase + RTI800_ADCHI);
356	outb(0, dev->iobase + RTI800_CLRFLAGS);
357
358	irq = it->options[1];
359	if (irq) {
360		printk("( irq = %u )", irq);
361		ret = request_irq(irq, rti800_interrupt, 0, "rti800", dev);
362		if (ret < 0) {
363			printk(" Failed to allocate IRQ\n");
364			return ret;
365		}
366		dev->irq = irq;
367	} else {
368		printk("( no irq )");
369	}
370
371	dev->board_name = this_board->name;
372
373	ret = alloc_subdevices(dev, 4);
374	if (ret < 0)
375		return ret;
376
377	ret = alloc_private(dev, sizeof(struct rti800_private));
378	if (ret < 0)
379		return ret;
380
381	devpriv->adc_mux = it->options[2];
382	devpriv->adc_range = it->options[3];
383	devpriv->adc_coding = it->options[4];
384	devpriv->dac0_range = it->options[5];
385	devpriv->dac0_coding = it->options[6];
386	devpriv->dac1_range = it->options[7];
387	devpriv->dac1_coding = it->options[8];
388	devpriv->muxgain_bits = -1;
389
390	s = dev->subdevices + 0;
391	/* ai subdevice */
392	s->type = COMEDI_SUBD_AI;
393	s->subdev_flags = SDF_READABLE | SDF_GROUND;
394	s->n_chan = (devpriv->adc_mux ? 16 : 8);
395	s->insn_read = rti800_ai_insn_read;
396	s->maxdata = 0xfff;
397	switch (devpriv->adc_range) {
398	case adc_bipolar10:
399		s->range_table = &range_rti800_ai_10_bipolar;
400		break;
401	case adc_bipolar5:
402		s->range_table = &range_rti800_ai_5_bipolar;
403		break;
404	case adc_unipolar10:
405		s->range_table = &range_rti800_ai_unipolar;
406		break;
407	}
408
409	s++;
410	if (this_board->has_ao) {
411		/* ao subdevice (only on rti815) */
412		s->type = COMEDI_SUBD_AO;
413		s->subdev_flags = SDF_WRITABLE;
414		s->n_chan = 2;
415		s->insn_read = rti800_ao_insn_read;
416		s->insn_write = rti800_ao_insn_write;
417		s->maxdata = 0xfff;
418		s->range_table_list = devpriv->ao_range_type_list;
419		switch (devpriv->dac0_range) {
420		case dac_bipolar10:
421			devpriv->ao_range_type_list[0] = &range_bipolar10;
422			break;
423		case dac_unipolar10:
424			devpriv->ao_range_type_list[0] = &range_unipolar10;
425			break;
426		}
427		switch (devpriv->dac1_range) {
428		case dac_bipolar10:
429			devpriv->ao_range_type_list[1] = &range_bipolar10;
430			break;
431		case dac_unipolar10:
432			devpriv->ao_range_type_list[1] = &range_unipolar10;
433			break;
434		}
435	} else {
436		s->type = COMEDI_SUBD_UNUSED;
437	}
438
439	s++;
440	/* di */
441	s->type = COMEDI_SUBD_DI;
442	s->subdev_flags = SDF_READABLE;
443	s->n_chan = 8;
444	s->insn_bits = rti800_di_insn_bits;
445	s->maxdata = 1;
446	s->range_table = &range_digital;
447
448	s++;
449	/* do */
450	s->type = COMEDI_SUBD_DO;
451	s->subdev_flags = SDF_WRITABLE;
452	s->n_chan = 8;
453	s->insn_bits = rti800_do_insn_bits;
454	s->maxdata = 1;
455	s->range_table = &range_digital;
456
457/* don't yet know how to deal with counter/timers */
458#if 0
459	s++;
460	/* do */
461	s->type = COMEDI_SUBD_TIMER;
462#endif
463
464	printk("\n");
465
466	return 0;
467}
468
469static int rti800_detach(struct comedi_device *dev)
470{
471	printk("comedi%d: rti800: remove\n", dev->minor);
472
473	if (dev->iobase)
474		release_region(dev->iobase, RTI800_SIZE);
475
476	if (dev->irq)
477		free_irq(dev->irq, dev);
478
479	return 0;
480}
481