]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/staging/comedi/drivers/dt2811.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: comedi: fix return value for insn_bits functions
[mirror_ubuntu-hirsute-kernel.git] / drivers / staging / comedi / drivers / dt2811.c
1 /*
2 comedi/drivers/dt2811.c
3 Hardware driver for Data Translation DT2811
4
5 COMEDI - Linux Control and Measurement Device Interface
6 History:
7 Base Version - David A. Schleef <ds@schleef.org>
8 December 1998 - Updated to work. David does not have a DT2811
9 board any longer so this was suffering from bitrot.
10 Updated performed by ...
11
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
16
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
21
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26 /*
27 Driver: dt2811
28 Description: Data Translation DT2811
29 Author: ds
30 Devices: [Data Translation] DT2811-PGL (dt2811-pgl), DT2811-PGH (dt2811-pgh)
31 Status: works
32
33 Configuration options:
34 [0] - I/O port base address
35 [1] - IRQ, although this is currently unused
36 [2] - A/D reference
37 0 = signle-ended
38 1 = differential
39 2 = pseudo-differential (common reference)
40 [3] - A/D range
41 0 = [-5, 5]
42 1 = [-2.5, 2.5]
43 2 = [0, 5]
44 [4] - D/A 0 range (same choices)
45 [4] - D/A 1 range (same choices)
46 */
47
48 #include <linux/interrupt.h>
49 #include "../comedidev.h"
50
51 #include <linux/ioport.h>
52
53 static const char *driver_name = "dt2811";
54
55 static const struct comedi_lrange range_dt2811_pgh_ai_5_unipolar = {
56 4, {
57 RANGE(0, 5),
58 RANGE(0, 2.5),
59 RANGE(0, 1.25),
60 RANGE(0, 0.625)
61 }
62 };
63
64 static const struct comedi_lrange range_dt2811_pgh_ai_2_5_bipolar = {
65 4, {
66 RANGE(-2.5, 2.5),
67 RANGE(-1.25, 1.25),
68 RANGE(-0.625, 0.625),
69 RANGE(-0.3125, 0.3125)
70 }
71 };
72
73 static const struct comedi_lrange range_dt2811_pgh_ai_5_bipolar = {
74 4, {
75 RANGE(-5, 5),
76 RANGE(-2.5, 2.5),
77 RANGE(-1.25, 1.25),
78 RANGE(-0.625, 0.625)
79 }
80 };
81
82 static const struct comedi_lrange range_dt2811_pgl_ai_5_unipolar = {
83 4, {
84 RANGE(0, 5),
85 RANGE(0, 0.5),
86 RANGE(0, 0.05),
87 RANGE(0, 0.01)
88 }
89 };
90
91 static const struct comedi_lrange range_dt2811_pgl_ai_2_5_bipolar = {
92 4, {
93 RANGE(-2.5, 2.5),
94 RANGE(-0.25, 0.25),
95 RANGE(-0.025, 0.025),
96 RANGE(-0.005, 0.005)
97 }
98 };
99
100 static const struct comedi_lrange range_dt2811_pgl_ai_5_bipolar = {
101 4, {
102 RANGE(-5, 5),
103 RANGE(-0.5, 0.5),
104 RANGE(-0.05, 0.05),
105 RANGE(-0.01, 0.01)
106 }
107 };
108
109 /*
110
111 0x00 ADCSR R/W A/D Control/Status Register
112 bit 7 - (R) 1 indicates A/D conversion done
113 reading ADDAT clears bit
114 (W) ignored
115 bit 6 - (R) 1 indicates A/D error
116 (W) ignored
117 bit 5 - (R) 1 indicates A/D busy, cleared at end
118 of conversion
119 (W) ignored
120 bit 4 - (R) 0
121 (W)
122 bit 3 - (R) 0
123 bit 2 - (R/W) 1 indicates interrupts enabled
124 bits 1,0 - (R/W) mode bits
125 00 single conversion on ADGCR load
126 01 continuous conversion, internal clock,
127 (clock enabled on ADGCR load)
128 10 continuous conversion, internal clock,
129 external trigger
130 11 continuous conversion, external clock,
131 external trigger
132
133 0x01 ADGCR R/W A/D Gain/Channel Register
134 bit 6,7 - (R/W) gain select
135 00 gain=1, both PGH, PGL models
136 01 gain=2 PGH, 10 PGL
137 10 gain=4 PGH, 100 PGL
138 11 gain=8 PGH, 500 PGL
139 bit 4,5 - reserved
140 bit 3-0 - (R/W) channel select
141 channel number from 0-15
142
143 0x02,0x03 (R) ADDAT A/D Data Register
144 (W) DADAT0 D/A Data Register 0
145 0x02 low byte
146 0x03 high byte
147
148 0x04,0x05 (W) DADAT0 D/A Data Register 1
149
150 0x06 (R) DIO0 Digital Input Port 0
151 (W) DIO1 Digital Output Port 1
152
153 0x07 TMRCTR (R/W) Timer/Counter Register
154 bits 6,7 - reserved
155 bits 5-3 - Timer frequency control (mantissa)
156 543 divisor freqency (kHz)
157 000 1 600
158 001 10 60
159 010 2 300
160 011 3 200
161 100 4 150
162 101 5 120
163 110 6 100
164 111 12 50
165 bits 2-0 - Timer frequency control (exponent)
166 210 multiply divisor/divide frequency by
167 000 1
168 001 10
169 010 100
170 011 1000
171 100 10000
172 101 100000
173 110 1000000
174 111 10000000
175
176 */
177
178 #define TIMEOUT 10000
179
180 #define DT2811_SIZE 8
181
182 #define DT2811_ADCSR 0
183 #define DT2811_ADGCR 1
184 #define DT2811_ADDATLO 2
185 #define DT2811_ADDATHI 3
186 #define DT2811_DADAT0LO 2
187 #define DT2811_DADAT0HI 3
188 #define DT2811_DADAT1LO 4
189 #define DT2811_DADAT1HI 5
190 #define DT2811_DIO 6
191 #define DT2811_TMRCTR 7
192
193 /*
194 * flags
195 */
196
197 /* ADCSR */
198
199 #define DT2811_ADDONE 0x80
200 #define DT2811_ADERROR 0x40
201 #define DT2811_ADBUSY 0x20
202 #define DT2811_CLRERROR 0x10
203 #define DT2811_INTENB 0x04
204 #define DT2811_ADMODE 0x03
205
206 struct dt2811_board {
207
208 const char *name;
209 const struct comedi_lrange *bip_5;
210 const struct comedi_lrange *bip_2_5;
211 const struct comedi_lrange *unip_5;
212 };
213
214 enum { card_2811_pgh, card_2811_pgl };
215
216 struct dt2811_private {
217 int ntrig;
218 int curadchan;
219 enum {
220 adc_singleended, adc_diff, adc_pseudo_diff
221 } adc_mux;
222 enum {
223 dac_bipolar_5, dac_bipolar_2_5, dac_unipolar_5
224 } dac_range[2];
225 const struct comedi_lrange *range_type_list[2];
226 unsigned int ao_readback[2];
227 };
228
229 #define devpriv ((struct dt2811_private *)dev->private)
230
231 static const struct comedi_lrange *dac_range_types[] = {
232 &range_bipolar5,
233 &range_bipolar2_5,
234 &range_unipolar5
235 };
236
237 #define DT2811_TIMEOUT 5
238
239 #if 0
240 static irqreturn_t dt2811_interrupt(int irq, void *d)
241 {
242 int lo, hi;
243 int data;
244 struct comedi_device *dev = d;
245
246 if (!dev->attached) {
247 comedi_error(dev, "spurious interrupt");
248 return IRQ_HANDLED;
249 }
250
251 lo = inb(dev->iobase + DT2811_ADDATLO);
252 hi = inb(dev->iobase + DT2811_ADDATHI);
253
254 data = lo + (hi << 8);
255
256 if (!(--devpriv->ntrig)) {
257 /* how to turn off acquisition */
258 s->async->events |= COMEDI_SB_EOA;
259 }
260 comedi_event(dev, s);
261 return IRQ_HANDLED;
262 }
263 #endif
264
265 static int dt2811_ai_insn(struct comedi_device *dev, struct comedi_subdevice *s,
266 struct comedi_insn *insn, unsigned int *data)
267 {
268 int chan = CR_CHAN(insn->chanspec);
269 int timeout = DT2811_TIMEOUT;
270 int i;
271
272 for (i = 0; i < insn->n; i++) {
273 outb(chan, dev->iobase + DT2811_ADGCR);
274
275 while (timeout
276 && inb(dev->iobase + DT2811_ADCSR) & DT2811_ADBUSY)
277 timeout--;
278 if (!timeout)
279 return -ETIME;
280
281 data[i] = inb(dev->iobase + DT2811_ADDATLO);
282 data[i] |= inb(dev->iobase + DT2811_ADDATHI) << 8;
283 data[i] &= 0xfff;
284 }
285
286 return i;
287 }
288
289 #if 0
290 /* Wow. This is code from the Comedi stone age. But it hasn't been
291 * replaced, so I'll let it stay. */
292 int dt2811_adtrig(kdev_t minor, comedi_adtrig *adtrig)
293 {
294 struct comedi_device *dev = comedi_devices + minor;
295
296 if (adtrig->n < 1)
297 return 0;
298 dev->curadchan = adtrig->chan;
299 switch (dev->i_admode) {
300 case COMEDI_MDEMAND:
301 dev->ntrig = adtrig->n - 1;
302 /* not necessary */
303 /*printk("dt2811: AD soft trigger\n"); */
304 /*outb(DT2811_CLRERROR|DT2811_INTENB,
305 dev->iobase+DT2811_ADCSR); */
306 outb(dev->curadchan, dev->iobase + DT2811_ADGCR);
307 do_gettimeofday(&trigtime);
308 break;
309 case COMEDI_MCONTS:
310 dev->ntrig = adtrig->n;
311 break;
312 }
313
314 return 0;
315 }
316 #endif
317
318 static int dt2811_ao_insn(struct comedi_device *dev, struct comedi_subdevice *s,
319 struct comedi_insn *insn, unsigned int *data)
320 {
321 int i;
322 int chan;
323
324 chan = CR_CHAN(insn->chanspec);
325
326 for (i = 0; i < insn->n; i++) {
327 outb(data[i] & 0xff, dev->iobase + DT2811_DADAT0LO + 2 * chan);
328 outb((data[i] >> 8) & 0xff,
329 dev->iobase + DT2811_DADAT0HI + 2 * chan);
330 devpriv->ao_readback[chan] = data[i];
331 }
332
333 return i;
334 }
335
336 static int dt2811_ao_insn_read(struct comedi_device *dev,
337 struct comedi_subdevice *s,
338 struct comedi_insn *insn, unsigned int *data)
339 {
340 int i;
341 int chan;
342
343 chan = CR_CHAN(insn->chanspec);
344
345 for (i = 0; i < insn->n; i++)
346 data[i] = devpriv->ao_readback[chan];
347
348 return i;
349 }
350
351 static int dt2811_di_insn_bits(struct comedi_device *dev,
352 struct comedi_subdevice *s,
353 struct comedi_insn *insn, unsigned int *data)
354 {
355 data[1] = inb(dev->iobase + DT2811_DIO);
356
357 return insn->n;
358 }
359
360 static int dt2811_do_insn_bits(struct comedi_device *dev,
361 struct comedi_subdevice *s,
362 struct comedi_insn *insn, unsigned int *data)
363 {
364 s->state &= ~data[0];
365 s->state |= data[0] & data[1];
366 outb(s->state, dev->iobase + DT2811_DIO);
367
368 data[1] = s->state;
369
370 return insn->n;
371 }
372
373 /*
374 options[0] Board base address
375 options[1] IRQ
376 options[2] Input configuration
377 0 == single-ended
378 1 == differential
379 2 == pseudo-differential
380 options[3] Analog input range configuration
381 0 == bipolar 5 (-5V -- +5V)
382 1 == bipolar 2.5V (-2.5V -- +2.5V)
383 2 == unipolar 5V (0V -- +5V)
384 options[4] Analog output 0 range configuration
385 0 == bipolar 5 (-5V -- +5V)
386 1 == bipolar 2.5V (-2.5V -- +2.5V)
387 2 == unipolar 5V (0V -- +5V)
388 options[5] Analog output 1 range configuration
389 0 == bipolar 5 (-5V -- +5V)
390 1 == bipolar 2.5V (-2.5V -- +2.5V)
391 2 == unipolar 5V (0V -- +5V)
392 */
393 static int dt2811_attach(struct comedi_device *dev, struct comedi_devconfig *it)
394 {
395 /* int i, irq; */
396 /* unsigned long irqs; */
397 /* long flags; */
398
399 const struct dt2811_board *board = comedi_board(dev);
400 int ret;
401 struct comedi_subdevice *s;
402 unsigned long iobase;
403
404 iobase = it->options[0];
405
406 printk(KERN_INFO "comedi%d: dt2811:base=0x%04lx\n", dev->minor, iobase);
407
408 if (!request_region(iobase, DT2811_SIZE, driver_name)) {
409 printk(KERN_ERR "I/O port conflict\n");
410 return -EIO;
411 }
412
413 dev->iobase = iobase;
414 dev->board_name = board->name;
415
416 #if 0
417 outb(0, dev->iobase + DT2811_ADCSR);
418 udelay(100);
419 i = inb(dev->iobase + DT2811_ADDATLO);
420 i = inb(dev->iobase + DT2811_ADDATHI);
421 #endif
422
423 #if 0
424 irq = it->options[1];
425 if (irq < 0) {
426 save_flags(flags);
427 sti();
428 irqs = probe_irq_on();
429
430 outb(DT2811_CLRERROR | DT2811_INTENB,
431 dev->iobase + DT2811_ADCSR);
432 outb(0, dev->iobase + DT2811_ADGCR);
433
434 udelay(100);
435
436 irq = probe_irq_off(irqs);
437 restore_flags(flags);
438
439 /*outb(DT2811_CLRERROR|DT2811_INTENB,
440 dev->iobase+DT2811_ADCSR);*/
441
442 if (inb(dev->iobase + DT2811_ADCSR) & DT2811_ADERROR)
443 printk(KERN_ERR "error probing irq (bad)\n");
444 dev->irq = 0;
445 if (irq > 0) {
446 i = inb(dev->iobase + DT2811_ADDATLO);
447 i = inb(dev->iobase + DT2811_ADDATHI);
448 printk(KERN_INFO "(irq = %d)\n", irq);
449 ret = request_irq(irq, dt2811_interrupt, 0,
450 driver_name, dev);
451 if (ret < 0)
452 return -EIO;
453 dev->irq = irq;
454 } else if (irq == 0) {
455 printk(KERN_INFO "(no irq)\n");
456 } else {
457 printk(KERN_ERR "( multiple irq's -- this is bad! )\n");
458 }
459 }
460 #endif
461
462 ret = comedi_alloc_subdevices(dev, 4);
463 if (ret)
464 return ret;
465
466 ret = alloc_private(dev, sizeof(struct dt2811_private));
467 if (ret < 0)
468 return ret;
469
470 switch (it->options[2]) {
471 case 0:
472 devpriv->adc_mux = adc_singleended;
473 break;
474 case 1:
475 devpriv->adc_mux = adc_diff;
476 break;
477 case 2:
478 devpriv->adc_mux = adc_pseudo_diff;
479 break;
480 default:
481 devpriv->adc_mux = adc_singleended;
482 break;
483 }
484 switch (it->options[4]) {
485 case 0:
486 devpriv->dac_range[0] = dac_bipolar_5;
487 break;
488 case 1:
489 devpriv->dac_range[0] = dac_bipolar_2_5;
490 break;
491 case 2:
492 devpriv->dac_range[0] = dac_unipolar_5;
493 break;
494 default:
495 devpriv->dac_range[0] = dac_bipolar_5;
496 break;
497 }
498 switch (it->options[5]) {
499 case 0:
500 devpriv->dac_range[1] = dac_bipolar_5;
501 break;
502 case 1:
503 devpriv->dac_range[1] = dac_bipolar_2_5;
504 break;
505 case 2:
506 devpriv->dac_range[1] = dac_unipolar_5;
507 break;
508 default:
509 devpriv->dac_range[1] = dac_bipolar_5;
510 break;
511 }
512
513 s = dev->subdevices + 0;
514 /* initialize the ADC subdevice */
515 s->type = COMEDI_SUBD_AI;
516 s->subdev_flags = SDF_READABLE | SDF_GROUND;
517 s->n_chan = devpriv->adc_mux == adc_diff ? 8 : 16;
518 s->insn_read = dt2811_ai_insn;
519 s->maxdata = 0xfff;
520 switch (it->options[3]) {
521 case 0:
522 default:
523 s->range_table = board->bip_5;
524 break;
525 case 1:
526 s->range_table = board->bip_2_5;
527 break;
528 case 2:
529 s->range_table = board->unip_5;
530 break;
531 }
532
533 s = dev->subdevices + 1;
534 /* ao subdevice */
535 s->type = COMEDI_SUBD_AO;
536 s->subdev_flags = SDF_WRITABLE;
537 s->n_chan = 2;
538 s->insn_write = dt2811_ao_insn;
539 s->insn_read = dt2811_ao_insn_read;
540 s->maxdata = 0xfff;
541 s->range_table_list = devpriv->range_type_list;
542 devpriv->range_type_list[0] = dac_range_types[devpriv->dac_range[0]];
543 devpriv->range_type_list[1] = dac_range_types[devpriv->dac_range[1]];
544
545 s = dev->subdevices + 2;
546 /* di subdevice */
547 s->type = COMEDI_SUBD_DI;
548 s->subdev_flags = SDF_READABLE;
549 s->n_chan = 8;
550 s->insn_bits = dt2811_di_insn_bits;
551 s->maxdata = 1;
552 s->range_table = &range_digital;
553
554 s = dev->subdevices + 3;
555 /* do subdevice */
556 s->type = COMEDI_SUBD_DO;
557 s->subdev_flags = SDF_WRITABLE;
558 s->n_chan = 8;
559 s->insn_bits = dt2811_do_insn_bits;
560 s->maxdata = 1;
561 s->state = 0;
562 s->range_table = &range_digital;
563
564 return 0;
565 }
566
567 static void dt2811_detach(struct comedi_device *dev)
568 {
569 if (dev->irq)
570 free_irq(dev->irq, dev);
571 if (dev->iobase)
572 release_region(dev->iobase, DT2811_SIZE);
573 }
574
575 static const struct dt2811_board boardtypes[] = {
576 {
577 .name = "dt2811-pgh",
578 .bip_5 = &range_dt2811_pgh_ai_5_bipolar,
579 .bip_2_5 = &range_dt2811_pgh_ai_2_5_bipolar,
580 .unip_5 = &range_dt2811_pgh_ai_5_unipolar,
581 }, {
582 .name = "dt2811-pgl",
583 .bip_5 = &range_dt2811_pgl_ai_5_bipolar,
584 .bip_2_5 = &range_dt2811_pgl_ai_2_5_bipolar,
585 .unip_5 = &range_dt2811_pgl_ai_5_unipolar,
586 },
587 };
588
589 static struct comedi_driver dt2811_driver = {
590 .driver_name = "dt2811",
591 .module = THIS_MODULE,
592 .attach = dt2811_attach,
593 .detach = dt2811_detach,
594 .board_name = &boardtypes[0].name,
595 .num_names = ARRAY_SIZE(boardtypes),
596 .offset = sizeof(struct dt2811_board),
597 };
598 module_comedi_driver(dt2811_driver);
599
600 MODULE_AUTHOR("Comedi http://www.comedi.org");
601 MODULE_DESCRIPTION("Comedi low-level driver");
602 MODULE_LICENSE("GPL");
Ubuntu Hirsute Linux kernel mirror