projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Staging: comedi: remove comedi-specific wrappers
[deliverable/linux.git] / drivers / staging / comedi / drivers / das08.c
1 /*
2 comedi/drivers/das08.c
3 DAS08 driver
4
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2000 David A. Schleef <ds@schleef.org>
7 Copyright (C) 2001,2002,2003 Frank Mori Hess <fmhess@users.sourceforge.net>
8 Copyright (C) 2004 Salvador E. Tropea <set@users.sf.net> <set@ieee.org>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23
24 *****************************************************************
25
26 */
27 /*
28 Driver: das08
29 Description: DAS-08 compatible boards
30 Author: Warren Jasper, ds, Frank Hess
31 Devices: [Keithley Metrabyte] DAS08 (isa-das08), [ComputerBoards] DAS08 (isa-das08),
32 DAS08-PGM (das08-pgm),
33 DAS08-PGH (das08-pgh), DAS08-PGL (das08-pgl), DAS08-AOH (das08-aoh),
34 DAS08-AOL (das08-aol), DAS08-AOM (das08-aom), DAS08/JR-AO (das08/jr-ao),
35 DAS08/JR-16-AO (das08jr-16-ao), PCI-DAS08 (das08),
36 PC104-DAS08 (pc104-das08), DAS08/JR/16 (das08jr/16)
37 Status: works
38
39 This is a rewrite of the das08 and das08jr drivers.
40
41 Options (for ISA cards):
42 [0] - base io address
43
44 Options (for pci-das08):
45 [0] - bus (optional)
46 [1] = slot (optional)
47
48 The das08 driver doesn't support asynchronous commands, since
49 the cheap das08 hardware doesn't really support them. The
50 comedi_rt_timer driver can be used to emulate commands for this
51 driver.
52 */
53
54 #include "../comedidev.h"
55
56 #include <linux/delay.h>
57
58 #include "comedi_pci.h"
59 #include "8255.h"
60 #include "das08.h"
61
62 #define DRV_NAME "das08"
63
64 #define PCI_VENDOR_ID_COMPUTERBOARDS 0x1307
65 #define PCI_DEVICE_ID_PCIDAS08 0x29
66 #define PCIDAS08_SIZE 0x54
67
68 /* pci configuration registers */
69 #define INTCSR 0x4c
70 #define INTR1_ENABLE 0x1
71 #define INTR1_HIGH_POLARITY 0x2
72 #define PCI_INTR_ENABLE 0x40
73 #define INTR1_EDGE_TRIG 0x100 /* requires high polarity */
74 #define CNTRL 0x50
75 #define CNTRL_DIR 0x2
76 #define CNTRL_INTR 0x4
77
78 /*
79 cio-das08.pdf
80
81 "isa-das08"
82
83 0 a/d bits 0-3 start 8 bit
84 1 a/d bits 4-11 start 12 bit
85 2 eoc, ip1-3, irq, mux op1-4, inte, mux
86 3 unused unused
87 4567 8254
88 89ab 8255
89
90 requires hard-wiring for async ai
91
92 */
93
94 #define DAS08_LSB 0
95 #define DAS08_MSB 1
96 #define DAS08_TRIG_12BIT 1
97 #define DAS08_STATUS 2
98 #define DAS08_EOC (1<<7)
99 #define DAS08_IRQ (1<<3)
100 #define DAS08_IP(x) (((x)>>4)&0x7)
101 #define DAS08_CONTROL 2
102 #define DAS08_MUX_MASK 0x7
103 #define DAS08_MUX(x) ((x) & DAS08_MUX_MASK)
104 #define DAS08_INTE (1<<3)
105 #define DAS08_DO_MASK 0xf0
106 #define DAS08_OP(x) (((x) << 4) & DAS08_DO_MASK)
107
108 /*
109 cio-das08jr.pdf
110
111 "das08/jr-ao"
112
113 0 a/d bits 0-3 unused
114 1 a/d bits 4-11 start 12 bit
115 2 eoc, mux mux
116 3 di do
117 4 unused ao0_lsb
118 5 unused ao0_msb
119 6 unused ao1_lsb
120 7 unused ao1_msb
121
122 */
123
124 #define DAS08JR_DIO 3
125 #define DAS08JR_AO_LSB(x) ((x)?6:4)
126 #define DAS08JR_AO_MSB(x) ((x)?7:5)
127
128 /*
129 cio-das08_aox.pdf
130
131 "das08-aoh"
132 "das08-aol"
133 "das08-aom"
134
135 0 a/d bits 0-3 start 8 bit
136 1 a/d bits 4-11 start 12 bit
137 2 eoc, ip1-3, irq, mux op1-4, inte, mux
138 3 mux, gain status gain control
139 4567 8254
140 8 unused ao0_lsb
141 9 unused ao0_msb
142 a unused ao1_lsb
143 b unused ao1_msb
144 89ab
145 cdef 8255
146 */
147
148 #define DAS08AO_GAIN_CONTROL 3
149 #define DAS08AO_GAIN_STATUS 3
150
151 #define DAS08AO_AO_LSB(x) ((x)?0xa:8)
152 #define DAS08AO_AO_MSB(x) ((x)?0xb:9)
153 #define DAS08AO_AO_UPDATE 8
154
155 /* gainlist same as _pgx_ below */
156
157 static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
158 struct comedi_insn *insn, unsigned int *data);
159 static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
160 struct comedi_insn *insn, unsigned int *data);
161 static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
162 struct comedi_insn *insn, unsigned int *data);
163 static int das08jr_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
164 struct comedi_insn *insn, unsigned int *data);
165 static int das08jr_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
166 struct comedi_insn *insn, unsigned int *data);
167 static int das08jr_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
168 struct comedi_insn *insn, unsigned int *data);
169 static int das08ao_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
170 struct comedi_insn *insn, unsigned int *data);
171 static void i8254_set_mode_low(unsigned int base, int channel,
172 unsigned int mode);
173
174 static const struct comedi_lrange range_das08_pgl = { 9, {
175 BIP_RANGE(10),
176 BIP_RANGE(5),
177 BIP_RANGE(2.5),
178 BIP_RANGE(1.25),
179 BIP_RANGE(0.625),
180 UNI_RANGE(10),
181 UNI_RANGE(5),
182 UNI_RANGE(2.5),
183 UNI_RANGE(1.25)
184 }
185 };
186 static const struct comedi_lrange range_das08_pgh = { 12, {
187 BIP_RANGE(10),
188 BIP_RANGE(5),
189 BIP_RANGE(1),
190 BIP_RANGE(0.5),
191 BIP_RANGE(0.1),
192 BIP_RANGE(0.05),
193 BIP_RANGE(0.01),
194 BIP_RANGE(0.005),
195 UNI_RANGE(10),
196 UNI_RANGE(1),
197 UNI_RANGE(0.1),
198 UNI_RANGE(0.01),
199 }
200 };
201 static const struct comedi_lrange range_das08_pgm = { 9, {
202 BIP_RANGE(10),
203 BIP_RANGE(5),
204 BIP_RANGE(0.5),
205 BIP_RANGE(0.05),
206 BIP_RANGE(0.01),
207 UNI_RANGE(10),
208 UNI_RANGE(1),
209 UNI_RANGE(0.1),
210 UNI_RANGE(0.01)
211 }
212 }; /*
213 cio-das08jr.pdf
214
215 "das08/jr-ao"
216
217 0 a/d bits 0-3 unused
218 1 a/d bits 4-11 start 12 bit
219 2 eoc, mux mux
220 3 di do
221 4 unused ao0_lsb
222 5 unused ao0_msb
223 6 unused ao1_lsb
224 7 unused ao1_msb
225
226 */
227
228 static const struct comedi_lrange *const das08_ai_lranges[] = {
229 &range_unknown,
230 &range_bipolar5,
231 &range_das08_pgh,
232 &range_das08_pgl,
233 &range_das08_pgm,
234 };
235
236 static const int das08_pgh_gainlist[] =
237 { 8, 0, 10, 2, 12, 4, 14, 6, 1, 3, 5, 7 };
238 static const int das08_pgl_gainlist[] = { 8, 0, 2, 4, 6, 1, 3, 5, 7 };
239 static const int das08_pgm_gainlist[] = { 8, 0, 10, 12, 14, 9, 11, 13, 15 };
240
241 static const int *const das08_gainlists[] = {
242 NULL,
243 NULL,
244 das08_pgh_gainlist,
245 das08_pgl_gainlist,
246 das08_pgm_gainlist,
247 };
248
249 static const struct das08_board_struct das08_boards[] = {
250 {
251 .name = "isa-das08", /* cio-das08.pdf */
252 .bustype = isa,
253 .ai = das08_ai_rinsn,
254 .ai_nbits = 12,
255 .ai_pg = das08_pg_none,
256 .ai_encoding = das08_encode12,
257 .ao = NULL,
258 .ao_nbits = 12,
259 .di = das08_di_rbits,
260 .do_ = das08_do_wbits,
261 .do_nchan = 4,
262 .i8255_offset = 8,
263 .i8254_offset = 4,
264 .iosize = 16, /* unchecked */
265 },
266 {
267 .name = "das08-pgm", /* cio-das08pgx.pdf */
268 .bustype = isa,
269 .ai = das08_ai_rinsn,
270 .ai_nbits = 12,
271 .ai_pg = das08_pgm,
272 .ai_encoding = das08_encode12,
273 .ao = NULL,
274 .di = das08_di_rbits,
275 .do_ = das08_do_wbits,
276 .do_nchan = 4,
277 .i8255_offset = 0,
278 .i8254_offset = 0x04,
279 .iosize = 16, /* unchecked */
280 },
281 {
282 .name = "das08-pgh", /* cio-das08pgx.pdf */
283 .bustype = isa,
284 .ai = das08_ai_rinsn,
285 .ai_nbits = 12,
286 .ai_pg = das08_pgh,
287 .ai_encoding = das08_encode12,
288 .ao = NULL,
289 .di = das08_di_rbits,
290 .do_ = das08_do_wbits,
291 .do_nchan = 4,
292 .i8255_offset = 0,
293 .i8254_offset = 0x04,
294 .iosize = 16, /* unchecked */
295 },
296 {
297 .name = "das08-pgl", /* cio-das08pgx.pdf */
298 .bustype = isa,
299 .ai = das08_ai_rinsn,
300 .ai_nbits = 12,
301 .ai_pg = das08_pgl,
302 .ai_encoding = das08_encode12,
303 .ao = NULL,
304 .di = das08_di_rbits,
305 .do_ = das08_do_wbits,
306 .do_nchan = 4,
307 .i8255_offset = 0,
308 .i8254_offset = 0x04,
309 .iosize = 16, /* unchecked */
310 },
311 {
312 .name = "das08-aoh", /* cio-das08_aox.pdf */
313 .bustype = isa,
314 .ai = das08_ai_rinsn,
315 .ai_nbits = 12,
316 .ai_pg = das08_pgh,
317 .ai_encoding = das08_encode12,
318 .ao = das08ao_ao_winsn, /* 8 */
319 .ao_nbits = 12,
320 .di = das08_di_rbits,
321 .do_ = das08_do_wbits,
322 .do_nchan = 4,
323 .i8255_offset = 0x0c,
324 .i8254_offset = 0x04,
325 .iosize = 16, /* unchecked */
326 },
327 {
328 .name = "das08-aol", /* cio-das08_aox.pdf */
329 .bustype = isa,
330 .ai = das08_ai_rinsn,
331 .ai_nbits = 12,
332 .ai_pg = das08_pgl,
333 .ai_encoding = das08_encode12,
334 .ao = das08ao_ao_winsn, /* 8 */
335 .ao_nbits = 12,
336 .di = das08_di_rbits,
337 .do_ = das08_do_wbits,
338 .do_nchan = 4,
339 .i8255_offset = 0x0c,
340 .i8254_offset = 0x04,
341 .iosize = 16, /* unchecked */
342 },
343 {
344 .name = "das08-aom", /* cio-das08_aox.pdf */
345 .bustype = isa,
346 .ai = das08_ai_rinsn,
347 .ai_nbits = 12,
348 .ai_pg = das08_pgm,
349 .ai_encoding = das08_encode12,
350 .ao = das08ao_ao_winsn, /* 8 */
351 .ao_nbits = 12,
352 .di = das08_di_rbits,
353 .do_ = das08_do_wbits,
354 .do_nchan = 4,
355 .i8255_offset = 0x0c,
356 .i8254_offset = 0x04,
357 .iosize = 16, /* unchecked */
358 },
359 {
360 .name = "das08/jr-ao", /* cio-das08-jr-ao.pdf */
361 .bustype = isa,
362 .ai = das08_ai_rinsn,
363 .ai_nbits = 12,
364 .ai_pg = das08_pg_none,
365 .ai_encoding = das08_encode12,
366 .ao = das08jr_ao_winsn,
367 .ao_nbits = 12,
368 .di = das08jr_di_rbits,
369 .do_ = das08jr_do_wbits,
370 .do_nchan = 8,
371 .i8255_offset = 0,
372 .i8254_offset = 0,
373 .iosize = 16, /* unchecked */
374 },
375 {
376 .name = "das08jr-16-ao", /* cio-das08jr-16-ao.pdf */
377 .bustype = isa,
378 .ai = das08_ai_rinsn,
379 .ai_nbits = 16,
380 .ai_pg = das08_pg_none,
381 .ai_encoding = das08_encode12,
382 .ao = das08jr_ao_winsn,
383 .ao_nbits = 16,
384 .di = das08jr_di_rbits,
385 .do_ = das08jr_do_wbits,
386 .do_nchan = 8,
387 .i8255_offset = 0,
388 .i8254_offset = 0x04,
389 .iosize = 16, /* unchecked */
390 },
391 #ifdef CONFIG_COMEDI_PCI
392 {
393 .name = "das08", /* pci-das08 */
394 .id = PCI_DEVICE_ID_PCIDAS08,
395 .bustype = pci,
396 .ai = das08_ai_rinsn,
397 .ai_nbits = 12,
398 .ai_pg = das08_bipolar5,
399 .ai_encoding = das08_encode12,
400 .ao = NULL,
401 .ao_nbits = 0,
402 .di = das08_di_rbits,
403 .do_ = das08_do_wbits,
404 .do_nchan = 4,
405 .i8255_offset = 0,
406 .i8254_offset = 4,
407 .iosize = 8,
408 },
409 #endif
410 {
411 .name = "pc104-das08",
412 .bustype = pc104,
413 .ai = das08_ai_rinsn,
414 .ai_nbits = 12,
415 .ai_pg = das08_pg_none,
416 .ai_encoding = das08_encode12,
417 .ao = NULL,
418 .ao_nbits = 0,
419 .di = das08_di_rbits,
420 .do_ = das08_do_wbits,
421 .do_nchan = 4,
422 .i8255_offset = 0,
423 .i8254_offset = 4,
424 .iosize = 16, /* unchecked */
425 },
426 #if 0
427 {
428 .name = "das08/f",
429 },
430 {
431 .name = "das08jr",
432 },
433 #endif
434 {
435 .name = "das08jr/16",
436 .bustype = isa,
437 .ai = das08_ai_rinsn,
438 .ai_nbits = 16,
439 .ai_pg = das08_pg_none,
440 .ai_encoding = das08_encode16,
441 .ao = NULL,
442 .ao_nbits = 0,
443 .di = das08jr_di_rbits,
444 .do_ = das08jr_do_wbits,
445 .do_nchan = 8,
446 .i8255_offset = 0,
447 .i8254_offset = 0,
448 .iosize = 16, /* unchecked */
449 },
450 #if 0
451 {
452 .name = "das48-pga", /* cio-das48-pga.pdf */
453 },
454 {
455 .name = "das08-pga-g2", /* a KM board */
456 },
457 #endif
458 };
459
460 #ifdef CONFIG_COMEDI_PCMCIA
461 struct das08_board_struct das08_cs_boards[NUM_DAS08_CS_BOARDS] = {
462 {
463 .name = "pcm-das08",
464 .id = 0x0, /* XXX */
465 .bustype = pcmcia,
466 .ai = das08_ai_rinsn,
467 .ai_nbits = 12,
468 .ai_pg = das08_bipolar5,
469 .ai_encoding = das08_pcm_encode12,
470 .ao = NULL,
471 .ao_nbits = 0,
472 .di = das08_di_rbits,
473 .do_ = das08_do_wbits,
474 .do_nchan = 3,
475 .i8255_offset = 0,
476 .i8254_offset = 0,
477 .iosize = 16,
478 },
479 /* duplicate so driver name can be used also */
480 {
481 .name = "das08_cs",
482 .id = 0x0, /* XXX */
483 .bustype = pcmcia,
484 .ai = das08_ai_rinsn,
485 .ai_nbits = 12,
486 .ai_pg = das08_bipolar5,
487 .ai_encoding = das08_pcm_encode12,
488 .ao = NULL,
489 .ao_nbits = 0,
490 .di = das08_di_rbits,
491 .do_ = das08_do_wbits,
492 .do_nchan = 3,
493 .i8255_offset = 0,
494 .i8254_offset = 0,
495 .iosize = 16,
496 },
497 };
498 #endif
499
500 #ifdef CONFIG_COMEDI_PCI
501 static DEFINE_PCI_DEVICE_TABLE(das08_pci_table) = {
502 {PCI_VENDOR_ID_COMPUTERBOARDS, PCI_DEVICE_ID_PCIDAS08, PCI_ANY_ID,
503 PCI_ANY_ID, 0, 0, 0},
504 {0}
505 };
506
507 MODULE_DEVICE_TABLE(pci, das08_pci_table);
508 #endif
509
510 #define devpriv ((struct das08_private_struct *)dev->private)
511 #define thisboard ((const struct das08_board_struct *)dev->board_ptr)
512
513 #define TIMEOUT 100000
514
515 static int das08_ai_rinsn(struct comedi_device *dev, struct comedi_subdevice *s,
516 struct comedi_insn *insn, unsigned int *data)
517 {
518 int i, n;
519 int chan;
520 int range;
521 int lsb, msb;
522
523 chan = CR_CHAN(insn->chanspec);
524 range = CR_RANGE(insn->chanspec);
525
526 /* clear crap */
527 inb(dev->iobase + DAS08_LSB);
528 inb(dev->iobase + DAS08_MSB);
529
530 /* set multiplexer */
531 spin_lock(&dev->spinlock); /* lock to prevent race with digital output */
532 devpriv->do_mux_bits &= ~DAS08_MUX_MASK;
533 devpriv->do_mux_bits |= DAS08_MUX(chan);
534 outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL);
535 spin_unlock(&dev->spinlock);
536
537 if (s->range_table->length > 1) {
538 /* set gain/range */
539 range = CR_RANGE(insn->chanspec);
540 outb(devpriv->pg_gainlist[range],
541 dev->iobase + DAS08AO_GAIN_CONTROL);
542 }
543
544 for (n = 0; n < insn->n; n++) {
545 /* clear over-range bits for 16-bit boards */
546 if (thisboard->ai_nbits == 16)
547 if (inb(dev->iobase + DAS08_MSB) & 0x80)
548 printk("das08: over-range\n");
549
550 /* trigger conversion */
551 outb_p(0, dev->iobase + DAS08_TRIG_12BIT);
552
553 for (i = 0; i < TIMEOUT; i++) {
554 if (!(inb(dev->iobase + DAS08_STATUS) & DAS08_EOC))
555 break;
556 }
557 if (i == TIMEOUT) {
558 printk("das08: timeout\n");
559 return -ETIME;
560 }
561 msb = inb(dev->iobase + DAS08_MSB);
562 lsb = inb(dev->iobase + DAS08_LSB);
563 if (thisboard->ai_encoding == das08_encode12) {
564 data[n] = (lsb >> 4) | (msb << 4);
565 } else if (thisboard->ai_encoding == das08_pcm_encode12) {
566 data[n] = (msb << 8) + lsb;
567 } else if (thisboard->ai_encoding == das08_encode16) {
568 /* FPOS 16-bit boards are sign-magnitude */
569 if (msb & 0x80)
570 data[n] = (1 << 15) | lsb | ((msb & 0x7f) << 8);
571 else
572 data[n] = (1 << 15) - (lsb | (msb & 0x7f) << 8);
573 } else {
574 comedi_error(dev, "bug! unknown ai encoding");
575 return -1;
576 }
577 }
578
579 return n;
580 }
581
582 static int das08_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
583 struct comedi_insn *insn, unsigned int *data)
584 {
585 data[0] = 0;
586 data[1] = DAS08_IP(inb(dev->iobase + DAS08_STATUS));
587
588 return 2;
589 }
590
591 static int das08_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
592 struct comedi_insn *insn, unsigned int *data)
593 {
594 int wbits;
595
596 /* get current settings of digital output lines */
597 wbits = (devpriv->do_mux_bits >> 4) & 0xf;
598 /* null bits we are going to set */
599 wbits &= ~data[0];
600 /* set new bit values */
601 wbits |= data[0] & data[1];
602 /* remember digital output bits */
603 spin_lock(&dev->spinlock); /* prevent race with setting of analog input mux */
604 devpriv->do_mux_bits &= ~DAS08_DO_MASK;
605 devpriv->do_mux_bits |= DAS08_OP(wbits);
606 outb(devpriv->do_mux_bits, dev->iobase + DAS08_CONTROL);
607 spin_unlock(&dev->spinlock);
608
609 data[1] = wbits;
610
611 return 2;
612 }
613
614 static int das08jr_di_rbits(struct comedi_device *dev, struct comedi_subdevice *s,
615 struct comedi_insn *insn, unsigned int *data)
616 {
617 data[0] = 0;
618 data[1] = inb(dev->iobase + DAS08JR_DIO);
619
620 return 2;
621 }
622
623 static int das08jr_do_wbits(struct comedi_device *dev, struct comedi_subdevice *s,
624 struct comedi_insn *insn, unsigned int *data)
625 {
626 /* null bits we are going to set */
627 devpriv->do_bits &= ~data[0];
628 /* set new bit values */
629 devpriv->do_bits |= data[0] & data[1];
630 outb(devpriv->do_bits, dev->iobase + DAS08JR_DIO);
631
632 data[1] = devpriv->do_bits;
633
634 return 2;
635 }
636
637 static int das08jr_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
638 struct comedi_insn *insn, unsigned int *data)
639 {
640 int n;
641 int lsb, msb;
642 int chan;
643
644 lsb = data[0] & 0xff;
645 msb = (data[0] >> 8) & 0xf;
646
647 chan = CR_CHAN(insn->chanspec);
648
649 for (n = 0; n < insn->n; n++) {
650 #if 0
651 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]);
652 outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]);
653 #else
654 outb(lsb, dev->iobase + DAS08JR_AO_LSB(chan));
655 outb(msb, dev->iobase + DAS08JR_AO_MSB(chan));
656 #endif
657
658 /* load DACs */
659 inb(dev->iobase + DAS08JR_DIO);
660 }
661
662 return n;
663 }
664
665 /*
666 *
667 * The -aox boards have the DACs at a different offset and use
668 * a different method to force an update.
669 *
670 */
671 static int das08ao_ao_winsn(struct comedi_device *dev, struct comedi_subdevice *s,
672 struct comedi_insn *insn, unsigned int *data)
673 {
674 int n;
675 int lsb, msb;
676 int chan;
677
678 lsb = data[0] & 0xff;
679 msb = (data[0] >> 8) & 0xf;
680
681 chan = CR_CHAN(insn->chanspec);
682
683 for (n = 0; n < insn->n; n++) {
684 #if 0
685 outb(lsb, dev->iobase + devpriv->ao_offset_lsb[chan]);
686 outb(msb, dev->iobase + devpriv->ao_offset_msb[chan]);
687 #else
688 outb(lsb, dev->iobase + DAS08AO_AO_LSB(chan));
689 outb(msb, dev->iobase + DAS08AO_AO_MSB(chan));
690 #endif
691
692 /* load DACs */
693 inb(dev->iobase + DAS08AO_AO_UPDATE);
694 }
695
696 return n;
697 }
698
699 static unsigned int i8254_read_channel_low(unsigned int base, int chan)
700 {
701 unsigned int msb, lsb;
702
703 /* The following instructions must be in order.
704 We must avoid other process reading the counter's value in the
705 middle.
706 The spin_lock isn't needed since ioctl calls grab the big kernel
707 lock automatically */
708 /*spin_lock(sp); */
709 outb(chan << 6, base + I8254_CTRL);
710 base += chan;
711 lsb = inb(base);
712 msb = inb(base);
713 /*spin_unlock(sp); */
714
715 return lsb | (msb << 8);
716 }
717
718 static void i8254_write_channel_low(unsigned int base, int chan,
719 unsigned int value)
720 {
721 unsigned int msb, lsb;
722
723 lsb = value & 0xFF;
724 msb = value >> 8;
725
726 /* write lsb, then msb */
727 base += chan;
728 /* See comments in i8254_read_channel_low */
729 /*spin_lock(sp); */
730 outb(lsb, base);
731 outb(msb, base);
732 /*spin_unlock(sp); */
733 }
734
735 static unsigned int i8254_read_channel(struct i8254_struct *st, int channel)
736 {
737 int chan = st->logic2phys[channel];
738
739 return i8254_read_channel_low(st->iobase, chan);
740 }
741
742 static void i8254_write_channel(struct i8254_struct *st, int channel,
743 unsigned int value)
744 {
745 int chan = st->logic2phys[channel];
746
747 i8254_write_channel_low(st->iobase, chan, value);
748 }
749
750 static void i8254_initialize(struct i8254_struct *st)
751 {
752 int i;
753 for (i = 0; i < 3; ++i)
754 i8254_set_mode_low(st->iobase, i, st->mode[i]);
755 }
756
757 static void i8254_set_mode_low(unsigned int base, int channel,
758 unsigned int mode)
759 {
760 outb((channel << 6) | 0x30 | (mode & 0x0F), base + I8254_CTRL);
761 }
762
763 static void i8254_set_mode(struct i8254_struct *st, int channel,
764 unsigned int mode)
765 {
766 int chan = st->logic2phys[channel];
767
768 st->mode[chan] = mode;
769 return i8254_set_mode_low(st->iobase, chan, mode);
770 }
771
772 static unsigned int i8254_read_status_low(unsigned int base, int channel)
773 {
774 outb(0xE0 | (2 << channel), base + I8254_CTRL);
775 return inb(base + channel);
776 }
777
778 static unsigned int i8254_read_status(struct i8254_struct *st, int channel)
779 {
780 int chan = st->logic2phys[channel];
781
782 return i8254_read_status_low(st->iobase, chan);
783 }
784
785 static int das08_counter_read(struct comedi_device *dev, struct comedi_subdevice *s,
786 struct comedi_insn *insn, unsigned int *data)
787 {
788 int chan = insn->chanspec;
789
790 /* printk("Reading counter channel %d ",chan); */
791 data[0] = i8254_read_channel(&devpriv->i8254, chan);
792 /* printk("=> 0x%08X\n",data[0]); */
793
794 return 1;
795 }
796
797 static int das08_counter_write(struct comedi_device *dev, struct comedi_subdevice *s,
798 struct comedi_insn *insn, unsigned int *data)
799 {
800 int chan = insn->chanspec;
801
802 /* printk("Writing counter channel %d with 0x%04X\n",chan,data[0]); */
803 i8254_write_channel(&devpriv->i8254, chan, data[0]);
804
805 return 1;
806 }
807
808 static int das08_counter_config(struct comedi_device *dev, struct comedi_subdevice *s,
809 struct comedi_insn *insn, unsigned int *data)
810 {
811 int chan = insn->chanspec;
812
813 if (insn->n != 2)
814 return -EINVAL;
815
816 switch (data[0]) {
817 case INSN_CONFIG_SET_COUNTER_MODE:
818 i8254_set_mode(&devpriv->i8254, chan, data[1]);
819 break;
820 case INSN_CONFIG_8254_READ_STATUS:
821 data[1] = i8254_read_status(&devpriv->i8254, chan);
822 break;
823 default:
824 return -EINVAL;
825 break;
826 }
827 return 2;
828 }
829
830 static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it);
831
832 static struct comedi_driver driver_das08 = {
833 .driver_name = DRV_NAME,
834 .module = THIS_MODULE,
835 .attach = das08_attach,
836 .detach = das08_common_detach,
837 .board_name = &das08_boards[0].name,
838 .num_names = sizeof(das08_boards) /
839 sizeof(struct das08_board_struct),
840 .offset = sizeof(struct das08_board_struct),
841 };
842
843 int das08_common_attach(struct comedi_device *dev, unsigned long iobase)
844 {
845 struct comedi_subdevice *s;
846 int ret;
847
848 /* allocate ioports for non-pcmcia, non-pci boards */
849 if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
850 printk(" iobase 0x%lx\n", iobase);
851 if (!request_region(iobase, thisboard->iosize, DRV_NAME)) {
852 printk(" I/O port conflict\n");
853 return -EIO;
854 }
855 }
856 dev->iobase = iobase;
857
858 dev->board_name = thisboard->name;
859
860 ret = alloc_subdevices(dev, 6);
861 if (ret < 0)
862 return ret;
863
864 s = dev->subdevices + 0;
865 /* ai */
866 if (thisboard->ai) {
867 s->type = COMEDI_SUBD_AI;
868 /* XXX some boards actually have differential inputs instead of single ended.
869 * The driver does nothing with arefs though, so it's no big deal. */
870 s->subdev_flags = SDF_READABLE | SDF_GROUND;
871 s->n_chan = 8;
872 s->maxdata = (1 << thisboard->ai_nbits) - 1;
873 s->range_table = das08_ai_lranges[thisboard->ai_pg];
874 s->insn_read = thisboard->ai;
875 devpriv->pg_gainlist = das08_gainlists[thisboard->ai_pg];
876 } else {
877 s->type = COMEDI_SUBD_UNUSED;
878 }
879
880 s = dev->subdevices + 1;
881 /* ao */
882 if (thisboard->ao) {
883 s->type = COMEDI_SUBD_AO;
884 /* XXX lacks read-back insn */
885 s->subdev_flags = SDF_WRITABLE;
886 s->n_chan = 2;
887 s->maxdata = (1 << thisboard->ao_nbits) - 1;
888 s->range_table = &range_bipolar5;
889 s->insn_write = thisboard->ao;
890 } else {
891 s->type = COMEDI_SUBD_UNUSED;
892 }
893
894 s = dev->subdevices + 2;
895 /* di */
896 if (thisboard->di) {
897 s->type = COMEDI_SUBD_DI;
898 s->subdev_flags = SDF_READABLE;
899 s->n_chan = (thisboard->di == das08_di_rbits) ? 3 : 8;
900 s->maxdata = 1;
901 s->range_table = &range_digital;
902 s->insn_bits = thisboard->di;
903 } else {
904 s->type = COMEDI_SUBD_UNUSED;
905 }
906
907 s = dev->subdevices + 3;
908 /* do */
909 if (thisboard->do_) {
910 s->type = COMEDI_SUBD_DO;
911 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
912 s->n_chan = thisboard->do_nchan;
913 s->maxdata = 1;
914 s->range_table = &range_digital;
915 s->insn_bits = thisboard->do_;
916 } else {
917 s->type = COMEDI_SUBD_UNUSED;
918 }
919
920 s = dev->subdevices + 4;
921 /* 8255 */
922 if (thisboard->i8255_offset != 0) {
923 subdev_8255_init(dev, s, NULL, (unsigned long)(dev->iobase +
924 thisboard->i8255_offset));
925 } else {
926 s->type = COMEDI_SUBD_UNUSED;
927 }
928
929 s = dev->subdevices + 5;
930 /* 8254 */
931 if (thisboard->i8254_offset != 0) {
932 s->type = COMEDI_SUBD_COUNTER;
933 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
934 s->n_chan = 3;
935 s->maxdata = 0xFFFF;
936 s->insn_read = das08_counter_read;
937 s->insn_write = das08_counter_write;
938 s->insn_config = das08_counter_config;
939 /* Set-up the 8254 structure */
940 devpriv->i8254.channels = 3;
941 devpriv->i8254.logic2phys[0] = 0;
942 devpriv->i8254.logic2phys[1] = 1;
943 devpriv->i8254.logic2phys[2] = 2;
944 devpriv->i8254.iobase = iobase + thisboard->i8254_offset;
945 devpriv->i8254.mode[0] =
946 devpriv->i8254.mode[1] =
947 devpriv->i8254.mode[2] = I8254_MODE0 | I8254_BINARY;
948 i8254_initialize(&devpriv->i8254);
949 } else {
950 s->type = COMEDI_SUBD_UNUSED;
951 }
952
953 return 0;
954 }
955
956 static int das08_attach(struct comedi_device *dev, struct comedi_devconfig *it)
957 {
958 int ret;
959 unsigned long iobase;
960 #ifdef CONFIG_COMEDI_PCI
961 unsigned long pci_iobase = 0;
962 struct pci_dev *pdev;
963 #endif
964
965 ret = alloc_private(dev, sizeof(struct das08_private_struct));
966 if (ret < 0)
967 return ret;
968
969 printk("comedi%d: das08: ", dev->minor);
970 /* deal with a pci board */
971 if (thisboard->bustype == pci) {
972 #ifdef CONFIG_COMEDI_PCI
973 if (it->options[0] || it->options[1]) {
974 printk("bus %i slot %i ",
975 it->options[0], it->options[1]);
976 }
977 printk("\n");
978 /* find card */
979 for (pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
980 pdev != NULL;
981 pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) {
982 if (pdev->vendor == PCI_VENDOR_ID_COMPUTERBOARDS
983 && pdev->device == PCI_DEVICE_ID_PCIDAS08) {
984 if (it->options[0] || it->options[1]) {
985 if (pdev->bus->number == it->options[0]
986 && PCI_SLOT(pdev->devfn) ==
987 it->options[1]) {
988 break;
989 }
990 } else {
991 break;
992 }
993 }
994 }
995 if (!pdev) {
996 printk("No pci das08 cards found\n");
997 return -EIO;
998 }
999 devpriv->pdev = pdev;
1000 /* enable PCI device and reserve I/O spaces */
1001 if (comedi_pci_enable(pdev, DRV_NAME)) {
1002 printk(" Error enabling PCI device and requesting regions\n");
1003 return -EIO;
1004 }
1005 /* read base addresses */
1006 pci_iobase = pci_resource_start(pdev, 1);
1007 iobase = pci_resource_start(pdev, 2);
1008 printk("pcibase 0x%lx iobase 0x%lx\n", pci_iobase, iobase);
1009 devpriv->pci_iobase = pci_iobase;
1010 #if 0
1011 /* We could enable to pci-das08's interrupt here to make it possible
1012 * to do timed input in this driver, but there is little point since
1013 * conversions would have to be started by the interrupt handler
1014 * so you might as well use comedi_rt_timer to emulate commands
1015 */
1016 /* set source of interrupt trigger to counter2 output */
1017 outb(CNTRL_INTR | CNTRL_DIR, pci_iobase + CNTRL);
1018 /* Enable local interrupt 1 and pci interrupt */
1019 outw(INTR1_ENABLE | PCI_INTR_ENABLE, pci_iobase + INTCSR);
1020 #endif
1021 #else /* CONFIG_COMEDI_PCI */
1022 printk("this driver has not been built with PCI support.\n");
1023 return -EINVAL;
1024 #endif /* CONFIG_COMEDI_PCI */
1025 } else {
1026 iobase = it->options[0];
1027 }
1028 printk("\n");
1029
1030 return das08_common_attach(dev, iobase);
1031 }
1032
1033 int das08_common_detach(struct comedi_device *dev)
1034 {
1035 printk(KERN_INFO "comedi%d: das08: remove\n", dev->minor);
1036
1037 if (dev->subdevices)
1038 subdev_8255_cleanup(dev, dev->subdevices + 4);
1039
1040 /* deallocate ioports for non-pcmcia, non-pci boards */
1041 if ((thisboard->bustype != pcmcia) && (thisboard->bustype != pci)) {
1042 if (dev->iobase)
1043 release_region(dev->iobase, thisboard->iosize);
1044 }
1045
1046 #ifdef CONFIG_COMEDI_PCI
1047 if (devpriv) {
1048 if (devpriv->pdev) {
1049 if (devpriv->pci_iobase) {
1050 comedi_pci_disable(devpriv->pdev);
1051 }
1052 pci_dev_put(devpriv->pdev);
1053 }
1054 }
1055 #endif
1056
1057 return 0;
1058 }
1059
1060 #ifdef CONFIG_COMEDI_PCI
1061 COMEDI_PCI_INITCLEANUP(driver_das08, das08_pci_table);
1062 #else
1063 COMEDI_INITCLEANUP(driver_das08);
1064 #endif
1065
1066 EXPORT_SYMBOL_GPL(das08_common_attach);
1067 EXPORT_SYMBOL_GPL(das08_common_detach);
1068 #ifdef CONFIG_COMEDI_PCMCIA
1069 EXPORT_SYMBOL_GPL(das08_cs_boards);
1070 #endif
Linux kernel - Deliverables
This page took 0.052361 seconds and 5 git commands to generate.