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