?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / drivers / staging / comedi / drivers / me4000.c
blobb432aa7d7644041bf2ae9b37cbd38bf8b07081e3
1 /*
2 comedi/drivers/me4000.c
3 Source code for the Meilhaus ME-4000 board family.
4
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2000 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 /*
24 Driver: me4000
25 Description: Meilhaus ME-4000 series boards
26 Devices: [Meilhaus] ME-4650 (me4000), ME-4670i, ME-4680, ME-4680i, ME-4680is
27 Author: gg (Guenter Gebhardt <g.gebhardt@meilhaus.com>)
28 Updated: Mon, 18 Mar 2002 15:34:01 -0800
29 Status: broken (no support for loading firmware)
30
31 Supports:
32
33 - Analog Input
34 - Analog Output
35 - Digital I/O
36 - Counter
37
38 Configuration Options:
39
40 [0] - PCI bus number (optional)
41 [1] - PCI slot number (optional)
42
43 If bus/slot is not specified, the first available PCI
44 device will be used.
45
46 The firmware required by these boards is available in the
47 comedi_nonfree_firmware tarball available from
48 http://www.comedi.org. However, the driver's support for
49 loading the firmware through comedi_config is currently
50 broken.
51
52 */
53
54 #include "../comedidev.h"
55
56 #include <linux/delay.h>
57 #include <linux/list.h>
58 #include <linux/spinlock.h>
59
60 #include "comedi_pci.h"
61 #include "me4000.h"
62 #if 0
63 /* file removed due to GPL incompatibility */
64 #include "me4000_fw.h"
65 #endif
66
67 /*=============================================================================
68 PCI device table.
69 This is used by modprobe to translate PCI IDs to drivers.
70 ===========================================================================*/
71
72 static DEFINE_PCI_DEVICE_TABLE(me4000_pci_table) = {
73 {PCI_VENDOR_ID_MEILHAUS, 0x4650, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
74
75 {PCI_VENDOR_ID_MEILHAUS, 0x4660, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
76 {PCI_VENDOR_ID_MEILHAUS, 0x4661, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
77 {PCI_VENDOR_ID_MEILHAUS, 0x4662, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
78 {PCI_VENDOR_ID_MEILHAUS, 0x4663, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
79
80 {PCI_VENDOR_ID_MEILHAUS, 0x4670, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
81 {PCI_VENDOR_ID_MEILHAUS, 0x4671, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
82 {PCI_VENDOR_ID_MEILHAUS, 0x4672, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
83 {PCI_VENDOR_ID_MEILHAUS, 0x4673, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
84
85 {PCI_VENDOR_ID_MEILHAUS, 0x4680, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
86 {PCI_VENDOR_ID_MEILHAUS, 0x4681, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
87 {PCI_VENDOR_ID_MEILHAUS, 0x4682, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
88 {PCI_VENDOR_ID_MEILHAUS, 0x4683, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
89
90 {0}
91 };
92
93 MODULE_DEVICE_TABLE(pci, me4000_pci_table);
94
95 static const me4000_board_t me4000_boards[] = {
96 {"ME-4650", 0x4650, {0, 0}, {16, 0, 0, 0}, {4}, {0}},
97
98 {"ME-4660", 0x4660, {0, 0}, {32, 0, 16, 0}, {4}, {3}},
99 {"ME-4660i", 0x4661, {0, 0}, {32, 0, 16, 0}, {4}, {3}},
100 {"ME-4660s", 0x4662, {0, 0}, {32, 8, 16, 0}, {4}, {3}},
101 {"ME-4660is", 0x4663, {0, 0}, {32, 8, 16, 0}, {4}, {3}},
102
103 {"ME-4670", 0x4670, {4, 0}, {32, 0, 16, 1}, {4}, {3}},
104 {"ME-4670i", 0x4671, {4, 0}, {32, 0, 16, 1}, {4}, {3}},
105 {"ME-4670s", 0x4672, {4, 0}, {32, 8, 16, 1}, {4}, {3}},
106 {"ME-4670is", 0x4673, {4, 0}, {32, 8, 16, 1}, {4}, {3}},
107
108 {"ME-4680", 0x4680, {4, 4}, {32, 0, 16, 1}, {4}, {3}},
109 {"ME-4680i", 0x4681, {4, 4}, {32, 0, 16, 1}, {4}, {3}},
110 {"ME-4680s", 0x4682, {4, 4}, {32, 8, 16, 1}, {4}, {3}},
111 {"ME-4680is", 0x4683, {4, 4}, {32, 8, 16, 1}, {4}, {3}},
112
113 {0},
114 };
115
116 #define ME4000_BOARD_VERSIONS (sizeof(me4000_boards) / sizeof(me4000_board_t) - 1)
117
118 /*-----------------------------------------------------------------------------
119 Comedi function prototypes
120 ---------------------------------------------------------------------------*/
121 static int me4000_attach(comedi_device * dev, comedi_devconfig * it);
122 static int me4000_detach(comedi_device * dev);
123 static comedi_driver driver_me4000 = {
124 driver_name:"me4000",
125 module:THIS_MODULE,
126 attach:me4000_attach,
127 detach:me4000_detach,
128 };
129
130 /*-----------------------------------------------------------------------------
131 Meilhaus function prototypes
132 ---------------------------------------------------------------------------*/
133 static int me4000_probe(comedi_device * dev, comedi_devconfig * it);
134 static int get_registers(comedi_device * dev, struct pci_dev *pci_dev_p);
135 static int init_board_info(comedi_device * dev, struct pci_dev *pci_dev_p);
136 static int init_ao_context(comedi_device * dev);
137 static int init_ai_context(comedi_device * dev);
138 static int init_dio_context(comedi_device * dev);
139 static int init_cnt_context(comedi_device * dev);
140 static int xilinx_download(comedi_device * dev);
141 static int reset_board(comedi_device * dev);
142
143 static int me4000_dio_insn_bits(comedi_device * dev,
144 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
145
146 static int me4000_dio_insn_config(comedi_device * dev,
147 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
148
149 static int cnt_reset(comedi_device * dev, unsigned int channel);
150
151 static int cnt_config(comedi_device * dev,
152 unsigned int channel, unsigned int mode);
153
154 static int me4000_cnt_insn_config(comedi_device * dev,
155 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
156
157 static int me4000_cnt_insn_write(comedi_device * dev,
158 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
159
160 static int me4000_cnt_insn_read(comedi_device * dev,
161 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
162
163 static int me4000_ai_insn_read(comedi_device * dev,
164 comedi_subdevice * subdevice, comedi_insn * insn, lsampl_t * data);
165
166 static int me4000_ai_cancel(comedi_device * dev, comedi_subdevice * s);
167
168 static int ai_check_chanlist(comedi_device * dev,
169 comedi_subdevice * s, comedi_cmd * cmd);
170
171 static int ai_round_cmd_args(comedi_device * dev,
172 comedi_subdevice * s,
173 comedi_cmd * cmd,
174 unsigned int *init_ticks,
175 unsigned int *scan_ticks, unsigned int *chan_ticks);
176
177 static int ai_prepare(comedi_device * dev,
178 comedi_subdevice * s,
179 comedi_cmd * cmd,
180 unsigned int init_ticks,
181 unsigned int scan_ticks, unsigned int chan_ticks);
182
183 static int ai_write_chanlist(comedi_device * dev,
184 comedi_subdevice * s, comedi_cmd * cmd);
185
186 static irqreturn_t me4000_ai_isr(int irq, void *dev_id PT_REGS_ARG);
187
188 static int me4000_ai_do_cmd_test(comedi_device * dev,
189 comedi_subdevice * s, comedi_cmd * cmd);
190
191 static int me4000_ai_do_cmd(comedi_device * dev, comedi_subdevice * s);
192
193 static int me4000_ao_insn_write(comedi_device * dev,
194 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
195
196 static int me4000_ao_insn_read(comedi_device * dev,
197 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data);
198
199 /*-----------------------------------------------------------------------------
200 Meilhaus inline functions
201 ---------------------------------------------------------------------------*/
202
203 static inline void me4000_outb(comedi_device * dev, unsigned char value,
204 unsigned long port)
205 {
206 PORT_PDEBUG("--> 0x%02X port 0x%04lX\n", value, port);
207 outb(value, port);
208 }
209
210 static inline void me4000_outl(comedi_device * dev, unsigned long value,
211 unsigned long port)
212 {
213 PORT_PDEBUG("--> 0x%08lX port 0x%04lX\n", value, port);
214 outl(value, port);
215 }
216
217 static inline unsigned long me4000_inl(comedi_device * dev, unsigned long port)
218 {
219 unsigned long value;
220 value = inl(port);
221 PORT_PDEBUG("<-- 0x%08lX port 0x%04lX\n", value, port);
222 return value;
223 }
224
225 static inline unsigned char me4000_inb(comedi_device * dev, unsigned long port)
226 {
227 unsigned char value;
228 value = inb(port);
229 PORT_PDEBUG("<-- 0x%08X port 0x%04lX\n", value, port);
230 return value;
231 }
232
233 static const comedi_lrange me4000_ai_range = {
234 4,
235 {
236 UNI_RANGE(2.5),
237 UNI_RANGE(10),
238 BIP_RANGE(2.5),
239 BIP_RANGE(10),
240 }
241 };
242
243 static const comedi_lrange me4000_ao_range = {
244 1,
245 {
246 BIP_RANGE(10),
247 }
248 };
249
250 static int me4000_attach(comedi_device * dev, comedi_devconfig * it)
251 {
252 comedi_subdevice *s;
253 int result;
254
255 CALL_PDEBUG("In me4000_attach()\n");
256
257 result = me4000_probe(dev, it);
258 if (result)
259 return result;
260
261 /*
262 * Allocate the subdevice structures. alloc_subdevice() is a
263 * convenient macro defined in comedidev.h. It relies on
264 * n_subdevices being set correctly.
265 */
266 if (alloc_subdevices(dev, 4) < 0)
267 return -ENOMEM;
268
269 /*=========================================================================
270 Analog input subdevice
271 ========================================================================*/
272
273 s = dev->subdevices + 0;
274
275 if (thisboard->ai.count) {
276 s->type = COMEDI_SUBD_AI;
277 s->subdev_flags =
278 SDF_READABLE | SDF_COMMON | SDF_GROUND | SDF_DIFF;
279 s->n_chan = thisboard->ai.count;
280 s->maxdata = 0xFFFF; // 16 bit ADC
281 s->len_chanlist = ME4000_AI_CHANNEL_LIST_COUNT;
282 s->range_table = &me4000_ai_range;
283 s->insn_read = me4000_ai_insn_read;
284
285 if (info->irq > 0) {
286 if (comedi_request_irq(info->irq, me4000_ai_isr,
287 IRQF_SHARED, "ME-4000", dev)) {
288 printk("comedi%d: me4000: me4000_attach(): Unable to allocate irq\n", dev->minor);
289 } else {
290 dev->read_subdev = s;
291 s->subdev_flags |= SDF_CMD_READ;
292 s->cancel = me4000_ai_cancel;
293 s->do_cmdtest = me4000_ai_do_cmd_test;
294 s->do_cmd = me4000_ai_do_cmd;
295 }
296 } else {
297 printk(KERN_WARNING
298 "comedi%d: me4000: me4000_attach(): No interrupt available\n",
299 dev->minor);
300 }
301 } else {
302 s->type = COMEDI_SUBD_UNUSED;
303 }
304
305 /*=========================================================================
306 Analog output subdevice
307 ========================================================================*/
308
309 s = dev->subdevices + 1;
310
311 if (thisboard->ao.count) {
312 s->type = COMEDI_SUBD_AO;
313 s->subdev_flags = SDF_WRITEABLE | SDF_COMMON | SDF_GROUND;
314 s->n_chan = thisboard->ao.count;
315 s->maxdata = 0xFFFF; // 16 bit DAC
316 s->range_table = &me4000_ao_range;
317 s->insn_write = me4000_ao_insn_write;
318 s->insn_read = me4000_ao_insn_read;
319 } else {
320 s->type = COMEDI_SUBD_UNUSED;
321 }
322
323 /*=========================================================================
324 Digital I/O subdevice
325 ========================================================================*/
326
327 s = dev->subdevices + 2;
328
329 if (thisboard->dio.count) {
330 s->type = COMEDI_SUBD_DIO;
331 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
332 s->n_chan = thisboard->dio.count * 8;
333 s->maxdata = 1;
334 s->range_table = &range_digital;
335 s->insn_bits = me4000_dio_insn_bits;
336 s->insn_config = me4000_dio_insn_config;
337 } else {
338 s->type = COMEDI_SUBD_UNUSED;
339 }
340
341 /*
342 * Check for optoisolated ME-4000 version. If one the first
343 * port is a fixed output port and the second is a fixed input port.
344 */
345 if (!me4000_inl(dev, info->dio_context.dir_reg)) {
346 s->io_bits |= 0xFF;
347 me4000_outl(dev, ME4000_DIO_CTRL_BIT_MODE_0,
348 info->dio_context.dir_reg);
349 }
350
351 /*=========================================================================
352 Counter subdevice
353 ========================================================================*/
354
355 s = dev->subdevices + 3;
356
357 if (thisboard->cnt.count) {
358 s->type = COMEDI_SUBD_COUNTER;
359 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
360 s->n_chan = thisboard->cnt.count;
361 s->maxdata = 0xFFFF; // 16 bit counters
362 s->insn_read = me4000_cnt_insn_read;
363 s->insn_write = me4000_cnt_insn_write;
364 s->insn_config = me4000_cnt_insn_config;
365 } else {
366 s->type = COMEDI_SUBD_UNUSED;
367 }
368
369 return 0;
370 }
371
372 static int me4000_probe(comedi_device * dev, comedi_devconfig * it)
373 {
374 struct pci_dev *pci_device;
375 int result, i;
376 me4000_board_t *board;
377
378 CALL_PDEBUG("In me4000_probe()\n");
379
380 /* Allocate private memory */
381 if (alloc_private(dev, sizeof(me4000_info_t)) < 0) {
382 return -ENOMEM;
383 }
384 /*
385 * Probe the device to determine what device in the series it is.
386 */
387 for (pci_device = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
388 pci_device != NULL;
389 pci_device =
390 pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pci_device)) {
391 if (pci_device->vendor == PCI_VENDOR_ID_MEILHAUS) {
392 for (i = 0; i < ME4000_BOARD_VERSIONS; i++) {
393 if (me4000_boards[i].device_id ==
394 pci_device->device) {
395 /* Was a particular bus/slot requested? */
396 if ((it->options[0] != 0)
397 || (it->options[1] != 0)) {
398 /* Are we on the wrong bus/slot? */
399 if (pci_device->bus->number !=
400 it->options[0]
401 || PCI_SLOT(pci_device->
402 devfn) !=
403 it->options[1]) {
404 continue;
405 }
406 }
407 dev->board_ptr = me4000_boards + i;
408 board = (me4000_board_t *) dev->
409 board_ptr;
410 info->pci_dev_p = pci_device;
411 goto found;
412 }
413 }
414 }
415 }
416
417 printk(KERN_ERR
418 "comedi%d: me4000: me4000_probe(): No supported board found (req. bus/slot : %d/%d)\n",
419 dev->minor, it->options[0], it->options[1]);
420 return -ENODEV;
421
422 found:
423
424 printk(KERN_INFO
425 "comedi%d: me4000: me4000_probe(): Found %s at PCI bus %d, slot %d\n",
426 dev->minor, me4000_boards[i].name, pci_device->bus->number,
427 PCI_SLOT(pci_device->devfn));
428
429 /* Set data in device structure */
430 dev->board_name = board->name;
431
432 /* Enable PCI device and request regions */
433 result = comedi_pci_enable(pci_device, dev->board_name);
434 if (result) {
435 printk(KERN_ERR
436 "comedi%d: me4000: me4000_probe(): Cannot enable PCI device and request I/O regions\n",
437 dev->minor);
438 return result;
439 }
440
441 /* Get the PCI base registers */
442 result = get_registers(dev, pci_device);
443 if (result) {
444 printk(KERN_ERR
445 "comedi%d: me4000: me4000_probe(): Cannot get registers\n",
446 dev->minor);
447 return result;
448 }
449 /* Initialize board info */
450 result = init_board_info(dev, pci_device);
451 if (result) {
452 printk(KERN_ERR
453 "comedi%d: me4000: me4000_probe(): Cannot init baord info\n",
454 dev->minor);
455 return result;
456 }
457
458 /* Init analog output context */
459 result = init_ao_context(dev);
460 if (result) {
461 printk(KERN_ERR
462 "comedi%d: me4000: me4000_probe(): Cannot init ao context\n",
463 dev->minor);
464 return result;
465 }
466
467 /* Init analog input context */
468 result = init_ai_context(dev);
469 if (result) {
470 printk(KERN_ERR
471 "comedi%d: me4000: me4000_probe(): Cannot init ai context\n",
472 dev->minor);
473 return result;
474 }
475
476 /* Init digital I/O context */
477 result = init_dio_context(dev);
478 if (result) {
479 printk(KERN_ERR
480 "comedi%d: me4000: me4000_probe(): Cannot init dio context\n",
481 dev->minor);
482 return result;
483 }
484
485 /* Init counter context */
486 result = init_cnt_context(dev);
487 if (result) {
488 printk(KERN_ERR
489 "comedi%d: me4000: me4000_probe(): Cannot init cnt context\n",
490 dev->minor);
491 return result;
492 }
493
494 /* Download the xilinx firmware */
495 result = xilinx_download(dev);
496 if (result) {
497 printk(KERN_ERR
498 "comedi%d: me4000: me4000_probe(): Can't download firmware\n",
499 dev->minor);
500 return result;
501 }
502
503 /* Make a hardware reset */
504 result = reset_board(dev);
505 if (result) {
506 printk(KERN_ERR
507 "comedi%d: me4000: me4000_probe(): Can't reset board\n",
508 dev->minor);
509 return result;
510 }
511
512 return 0;
513 }
514
515 static int get_registers(comedi_device * dev, struct pci_dev *pci_dev_p)
516 {
517
518 CALL_PDEBUG("In get_registers()\n");
519
520 /*--------------------------- plx regbase ---------------------------------*/
521
522 info->plx_regbase = pci_resource_start(pci_dev_p, 1);
523 if (info->plx_regbase == 0) {
524 printk(KERN_ERR
525 "comedi%d: me4000: get_registers(): PCI base address 1 is not available\n",
526 dev->minor);
527 return -ENODEV;
528 }
529 info->plx_regbase_size = pci_resource_len(pci_dev_p, 1);
530
531 /*--------------------------- me4000 regbase ------------------------------*/
532
533 info->me4000_regbase = pci_resource_start(pci_dev_p, 2);
534 if (info->me4000_regbase == 0) {
535 printk(KERN_ERR
536 "comedi%d: me4000: get_registers(): PCI base address 2 is not available\n",
537 dev->minor);
538 return -ENODEV;
539 }
540 info->me4000_regbase_size = pci_resource_len(pci_dev_p, 2);
541
542 /*--------------------------- timer regbase ------------------------------*/
543
544 info->timer_regbase = pci_resource_start(pci_dev_p, 3);
545 if (info->timer_regbase == 0) {
546 printk(KERN_ERR
547 "comedi%d: me4000: get_registers(): PCI base address 3 is not available\n",
548 dev->minor);
549 return -ENODEV;
550 }
551 info->timer_regbase_size = pci_resource_len(pci_dev_p, 3);
552
553 /*--------------------------- program regbase ------------------------------*/
554
555 info->program_regbase = pci_resource_start(pci_dev_p, 5);
556 if (info->program_regbase == 0) {
557 printk(KERN_ERR
558 "comedi%d: me4000: get_registers(): PCI base address 5 is not available\n",
559 dev->minor);
560 return -ENODEV;
561 }
562 info->program_regbase_size = pci_resource_len(pci_dev_p, 5);
563
564 return 0;
565 }
566
567 static int init_board_info(comedi_device * dev, struct pci_dev *pci_dev_p)
568 {
569 int result;
570
571 CALL_PDEBUG("In init_board_info()\n");
572
573 /* Init spin locks */
574 //spin_lock_init(&info->preload_lock);
575 //spin_lock_init(&info->ai_ctrl_lock);
576
577 /* Get the serial number */
578 result = pci_read_config_dword(pci_dev_p, 0x2C, &info->serial_no);
579 if (result != PCIBIOS_SUCCESSFUL) {
580 return result;
581 }
582
583 /* Get the hardware revision */
584 result = pci_read_config_byte(pci_dev_p, 0x08, &info->hw_revision);
585 if (result != PCIBIOS_SUCCESSFUL) {
586 return result;
587 }
588
589 /* Get the vendor id */
590 info->vendor_id = pci_dev_p->vendor;
591
592 /* Get the device id */
593 info->device_id = pci_dev_p->device;
594
595 /* Get the irq assigned to the board */
596 info->irq = pci_dev_p->irq;
597
598 return 0;
599 }
600
601 static int init_ao_context(comedi_device * dev)
602 {
603 int i;
604
605 CALL_PDEBUG("In init_ao_context()\n");
606
607 for (i = 0; i < thisboard->ao.count; i++) {
608 //spin_lock_init(&info->ao_context[i].use_lock);
609 info->ao_context[i].irq = info->irq;
610
611 switch (i) {
612 case 0:
613 info->ao_context[i].ctrl_reg =
614 info->me4000_regbase + ME4000_AO_00_CTRL_REG;
615 info->ao_context[i].status_reg =
616 info->me4000_regbase + ME4000_AO_00_STATUS_REG;
617 info->ao_context[i].fifo_reg =
618 info->me4000_regbase + ME4000_AO_00_FIFO_REG;
619 info->ao_context[i].single_reg =
620 info->me4000_regbase + ME4000_AO_00_SINGLE_REG;
621 info->ao_context[i].timer_reg =
622 info->me4000_regbase + ME4000_AO_00_TIMER_REG;
623 info->ao_context[i].irq_status_reg =
624 info->me4000_regbase + ME4000_IRQ_STATUS_REG;
625 info->ao_context[i].preload_reg =
626 info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
627 break;
628 case 1:
629 info->ao_context[i].ctrl_reg =
630 info->me4000_regbase + ME4000_AO_01_CTRL_REG;
631 info->ao_context[i].status_reg =
632 info->me4000_regbase + ME4000_AO_01_STATUS_REG;
633 info->ao_context[i].fifo_reg =
634 info->me4000_regbase + ME4000_AO_01_FIFO_REG;
635 info->ao_context[i].single_reg =
636 info->me4000_regbase + ME4000_AO_01_SINGLE_REG;
637 info->ao_context[i].timer_reg =
638 info->me4000_regbase + ME4000_AO_01_TIMER_REG;
639 info->ao_context[i].irq_status_reg =
640 info->me4000_regbase + ME4000_IRQ_STATUS_REG;
641 info->ao_context[i].preload_reg =
642 info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
643 break;
644 case 2:
645 info->ao_context[i].ctrl_reg =
646 info->me4000_regbase + ME4000_AO_02_CTRL_REG;
647 info->ao_context[i].status_reg =
648 info->me4000_regbase + ME4000_AO_02_STATUS_REG;
649 info->ao_context[i].fifo_reg =
650 info->me4000_regbase + ME4000_AO_02_FIFO_REG;
651 info->ao_context[i].single_reg =
652 info->me4000_regbase + ME4000_AO_02_SINGLE_REG;
653 info->ao_context[i].timer_reg =
654 info->me4000_regbase + ME4000_AO_02_TIMER_REG;
655 info->ao_context[i].irq_status_reg =
656 info->me4000_regbase + ME4000_IRQ_STATUS_REG;
657 info->ao_context[i].preload_reg =
658 info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
659 break;
660 case 3:
661 info->ao_context[i].ctrl_reg =
662 info->me4000_regbase + ME4000_AO_03_CTRL_REG;
663 info->ao_context[i].status_reg =
664 info->me4000_regbase + ME4000_AO_03_STATUS_REG;
665 info->ao_context[i].fifo_reg =
666 info->me4000_regbase + ME4000_AO_03_FIFO_REG;
667 info->ao_context[i].single_reg =
668 info->me4000_regbase + ME4000_AO_03_SINGLE_REG;
669 info->ao_context[i].timer_reg =
670 info->me4000_regbase + ME4000_AO_03_TIMER_REG;
671 info->ao_context[i].irq_status_reg =
672 info->me4000_regbase + ME4000_IRQ_STATUS_REG;
673 info->ao_context[i].preload_reg =
674 info->me4000_regbase + ME4000_AO_LOADSETREG_XX;
675 break;
676 default:
677 break;
678 }
679 }
680
681 return 0;
682 }
683
684 static int init_ai_context(comedi_device * dev)
685 {
686
687 CALL_PDEBUG("In init_ai_context()\n");
688
689 info->ai_context.irq = info->irq;
690
691 info->ai_context.ctrl_reg = info->me4000_regbase + ME4000_AI_CTRL_REG;
692 info->ai_context.status_reg =
693 info->me4000_regbase + ME4000_AI_STATUS_REG;
694 info->ai_context.channel_list_reg =
695 info->me4000_regbase + ME4000_AI_CHANNEL_LIST_REG;
696 info->ai_context.data_reg = info->me4000_regbase + ME4000_AI_DATA_REG;
697 info->ai_context.chan_timer_reg =
698 info->me4000_regbase + ME4000_AI_CHAN_TIMER_REG;
699 info->ai_context.chan_pre_timer_reg =
700 info->me4000_regbase + ME4000_AI_CHAN_PRE_TIMER_REG;
701 info->ai_context.scan_timer_low_reg =
702 info->me4000_regbase + ME4000_AI_SCAN_TIMER_LOW_REG;
703 info->ai_context.scan_timer_high_reg =
704 info->me4000_regbase + ME4000_AI_SCAN_TIMER_HIGH_REG;
705 info->ai_context.scan_pre_timer_low_reg =
706 info->me4000_regbase + ME4000_AI_SCAN_PRE_TIMER_LOW_REG;
707 info->ai_context.scan_pre_timer_high_reg =
708 info->me4000_regbase + ME4000_AI_SCAN_PRE_TIMER_HIGH_REG;
709 info->ai_context.start_reg = info->me4000_regbase + ME4000_AI_START_REG;
710 info->ai_context.irq_status_reg =
711 info->me4000_regbase + ME4000_IRQ_STATUS_REG;
712 info->ai_context.sample_counter_reg =
713 info->me4000_regbase + ME4000_AI_SAMPLE_COUNTER_REG;
714
715 return 0;
716 }
717
718 static int init_dio_context(comedi_device * dev)
719 {
720
721 CALL_PDEBUG("In init_dio_context()\n");
722
723 info->dio_context.dir_reg = info->me4000_regbase + ME4000_DIO_DIR_REG;
724 info->dio_context.ctrl_reg = info->me4000_regbase + ME4000_DIO_CTRL_REG;
725 info->dio_context.port_0_reg =
726 info->me4000_regbase + ME4000_DIO_PORT_0_REG;
727 info->dio_context.port_1_reg =
728 info->me4000_regbase + ME4000_DIO_PORT_1_REG;
729 info->dio_context.port_2_reg =
730 info->me4000_regbase + ME4000_DIO_PORT_2_REG;
731 info->dio_context.port_3_reg =
732 info->me4000_regbase + ME4000_DIO_PORT_3_REG;
733
734 return 0;
735 }
736
737 static int init_cnt_context(comedi_device * dev)
738 {
739
740 CALL_PDEBUG("In init_cnt_context()\n");
741
742 info->cnt_context.ctrl_reg = info->timer_regbase + ME4000_CNT_CTRL_REG;
743 info->cnt_context.counter_0_reg =
744 info->timer_regbase + ME4000_CNT_COUNTER_0_REG;
745 info->cnt_context.counter_1_reg =
746 info->timer_regbase + ME4000_CNT_COUNTER_1_REG;
747 info->cnt_context.counter_2_reg =
748 info->timer_regbase + ME4000_CNT_COUNTER_2_REG;
749
750 return 0;
751 }
752
753 #define FIRMWARE_NOT_AVAILABLE 1
754 #if FIRMWARE_NOT_AVAILABLE
755 extern unsigned char *xilinx_firm;
756 #endif
757
758 static int xilinx_download(comedi_device * dev)
759 {
760 u32 value = 0;
761 wait_queue_head_t queue;
762 int idx = 0;
763 int size = 0;
764
765 CALL_PDEBUG("In xilinx_download()\n");
766
767 init_waitqueue_head(&queue);
768
769 /*
770 * Set PLX local interrupt 2 polarity to high.
771 * Interrupt is thrown by init pin of xilinx.
772 */
773 outl(0x10, info->plx_regbase + PLX_INTCSR);
774
775 /* Set /CS and /WRITE of the Xilinx */
776 value = inl(info->plx_regbase + PLX_ICR);
777 value |= 0x100;
778 outl(value, info->plx_regbase + PLX_ICR);
779
780 /* Init Xilinx with CS1 */
781 inb(info->program_regbase + 0xC8);
782
783 /* Wait until /INIT pin is set */
784 udelay(20);
785 if (!inl(info->plx_regbase + PLX_INTCSR) & 0x20) {
786 printk(KERN_ERR
787 "comedi%d: me4000: xilinx_download(): Can't init Xilinx\n",
788 dev->minor);
789 return -EIO;
790 }
791
792 /* Reset /CS and /WRITE of the Xilinx */
793 value = inl(info->plx_regbase + PLX_ICR);
794 value &= ~0x100;
795 outl(value, info->plx_regbase + PLX_ICR);
796 if (FIRMWARE_NOT_AVAILABLE) {
797 comedi_error(dev,
798 "xilinx firmware unavailable due to licensing, aborting");
799 return -EIO;
800 } else {
801 /* Download Xilinx firmware */
802 size = (xilinx_firm[0] << 24) + (xilinx_firm[1] << 16) +
803 (xilinx_firm[2] << 8) + xilinx_firm[3];
804 udelay(10);
805
806 for (idx = 0; idx < size; idx++) {
807 outb(xilinx_firm[16 + idx], info->program_regbase);
808 udelay(10);
809
810 /* Check if BUSY flag is low */
811 if (inl(info->plx_regbase + PLX_ICR) & 0x20) {
812 printk(KERN_ERR
813 "comedi%d: me4000: xilinx_download(): Xilinx is still busy (idx = %d)\n",
814 dev->minor, idx);
815 return -EIO;
816 }
817 }
818 }
819
820 /* If done flag is high download was successful */
821 if (inl(info->plx_regbase + PLX_ICR) & 0x4) {
822 } else {
823 printk(KERN_ERR
824 "comedi%d: me4000: xilinx_download(): DONE flag is not set\n",
825 dev->minor);
826 printk(KERN_ERR
827 "comedi%d: me4000: xilinx_download(): Download not succesful\n",
828 dev->minor);
829 return -EIO;
830 }
831
832 /* Set /CS and /WRITE */
833 value = inl(info->plx_regbase + PLX_ICR);
834 value |= 0x100;
835 outl(value, info->plx_regbase + PLX_ICR);
836
837 return 0;
838 }
839
840 static int reset_board(comedi_device * dev)
841 {
842 unsigned long icr;
843
844 CALL_PDEBUG("In reset_board()\n");
845
846 /* Make a hardware reset */
847 icr = me4000_inl(dev, info->plx_regbase + PLX_ICR);
848 icr |= 0x40000000;
849 me4000_outl(dev, icr, info->plx_regbase + PLX_ICR);
850 icr &= ~0x40000000;
851 me4000_outl(dev, icr, info->plx_regbase + PLX_ICR);
852
853 /* 0x8000 to the DACs means an output voltage of 0V */
854 me4000_outl(dev, 0x8000,
855 info->me4000_regbase + ME4000_AO_00_SINGLE_REG);
856 me4000_outl(dev, 0x8000,
857 info->me4000_regbase + ME4000_AO_01_SINGLE_REG);
858 me4000_outl(dev, 0x8000,
859 info->me4000_regbase + ME4000_AO_02_SINGLE_REG);
860 me4000_outl(dev, 0x8000,
861 info->me4000_regbase + ME4000_AO_03_SINGLE_REG);
862
863 /* Set both stop bits in the analog input control register */
864 me4000_outl(dev,
865 ME4000_AI_CTRL_BIT_IMMEDIATE_STOP | ME4000_AI_CTRL_BIT_STOP,
866 info->me4000_regbase + ME4000_AI_CTRL_REG);
867
868 /* Set both stop bits in the analog output control register */
869 me4000_outl(dev,
870 ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
871 info->me4000_regbase + ME4000_AO_00_CTRL_REG);
872 me4000_outl(dev,
873 ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
874 info->me4000_regbase + ME4000_AO_01_CTRL_REG);
875 me4000_outl(dev,
876 ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
877 info->me4000_regbase + ME4000_AO_02_CTRL_REG);
878 me4000_outl(dev,
879 ME4000_AO_CTRL_BIT_IMMEDIATE_STOP | ME4000_AO_CTRL_BIT_STOP,
880 info->me4000_regbase + ME4000_AO_03_CTRL_REG);
881
882 /* Enable interrupts on the PLX */
883 me4000_outl(dev, 0x43, info->plx_regbase + PLX_INTCSR);
884
885 /* Set the adustment register for AO demux */
886 me4000_outl(dev, ME4000_AO_DEMUX_ADJUST_VALUE,
887 info->me4000_regbase + ME4000_AO_DEMUX_ADJUST_REG);
888
889 /* Set digital I/O direction for port 0 to output on isolated versions */
890 if (!(me4000_inl(dev, info->me4000_regbase + ME4000_DIO_DIR_REG) & 0x1)) {
891 me4000_outl(dev, 0x1,
892 info->me4000_regbase + ME4000_DIO_CTRL_REG);
893 }
894
895 return 0;
896 }
897
898 static int me4000_detach(comedi_device * dev)
899 {
900 CALL_PDEBUG("In me4000_detach()\n");
901
902 if (info) {
903 if (info->pci_dev_p) {
904 reset_board(dev);
905 if (info->plx_regbase) {
906 comedi_pci_disable(info->pci_dev_p);
907 }
908 pci_dev_put(info->pci_dev_p);
909 }
910 }
911
912 return 0;
913 }
914
915 /*=============================================================================
916 Analog input section
917 ===========================================================================*/
918
919 static int me4000_ai_insn_read(comedi_device * dev,
920 comedi_subdevice * subdevice, comedi_insn * insn, lsampl_t * data)
921 {
922
923 int chan = CR_CHAN(insn->chanspec);
924 int rang = CR_RANGE(insn->chanspec);
925 int aref = CR_AREF(insn->chanspec);
926
927 unsigned long entry = 0;
928 unsigned long tmp;
929 long lval;
930
931 CALL_PDEBUG("In me4000_ai_insn_read()\n");
932
933 if (insn->n == 0) {
934 return 0;
935 } else if (insn->n > 1) {
936 printk(KERN_ERR
937 "comedi%d: me4000: me4000_ai_insn_read(): Invalid instruction length %d\n",
938 dev->minor, insn->n);
939 return -EINVAL;
940 }
941
942 switch (rang) {
943 case 0:
944 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_2_5;
945 break;
946 case 1:
947 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_10;
948 break;
949 case 2:
950 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_2_5;
951 break;
952 case 3:
953 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_10;
954 break;
955 default:
956 printk(KERN_ERR
957 "comedi%d: me4000: me4000_ai_insn_read(): Invalid range specified\n",
958 dev->minor);
959 return -EINVAL;
960 }
961
962 switch (aref) {
963 case AREF_GROUND:
964 case AREF_COMMON:
965 if (chan >= thisboard->ai.count) {
966 printk(KERN_ERR
967 "comedi%d: me4000: me4000_ai_insn_read(): Analog input is not available\n",
968 dev->minor);
969 return -EINVAL;
970 }
971 entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED | chan;
972 break;
973
974 case AREF_DIFF:
975 if (rang == 0 || rang == 1) {
976 printk(KERN_ERR
977 "comedi%d: me4000: me4000_ai_insn_read(): Range must be bipolar when aref = diff\n",
978 dev->minor);
979 return -EINVAL;
980 }
981
982 if (chan >= thisboard->ai.diff_count) {
983 printk(KERN_ERR
984 "comedi%d: me4000: me4000_ai_insn_read(): Analog input is not available\n",
985 dev->minor);
986 return -EINVAL;
987 }
988 entry |= ME4000_AI_LIST_INPUT_DIFFERENTIAL | chan;
989 break;
990 default:
991 printk(KERN_ERR
992 "comedi%d: me4000: me4000_ai_insn_read(): Invalid aref specified\n",
993 dev->minor);
994 return -EINVAL;
995 }
996
997 entry |= ME4000_AI_LIST_LAST_ENTRY;
998
999 /* Clear channel list, data fifo and both stop bits */
1000 tmp = me4000_inl(dev, info->ai_context.ctrl_reg);
1001 tmp &= ~(ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1002 ME4000_AI_CTRL_BIT_DATA_FIFO |
1003 ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
1004 me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1005
1006 /* Set the acquisition mode to single */
1007 tmp &= ~(ME4000_AI_CTRL_BIT_MODE_0 | ME4000_AI_CTRL_BIT_MODE_1 |
1008 ME4000_AI_CTRL_BIT_MODE_2);
1009 me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1010
1011 /* Enable channel list and data fifo */
1012 tmp |= ME4000_AI_CTRL_BIT_CHANNEL_FIFO | ME4000_AI_CTRL_BIT_DATA_FIFO;
1013 me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1014
1015 /* Generate channel list entry */
1016 me4000_outl(dev, entry, info->ai_context.channel_list_reg);
1017
1018 /* Set the timer to maximum sample rate */
1019 me4000_outl(dev, ME4000_AI_MIN_TICKS, info->ai_context.chan_timer_reg);
1020 me4000_outl(dev, ME4000_AI_MIN_TICKS,
1021 info->ai_context.chan_pre_timer_reg);
1022
1023 /* Start conversion by dummy read */
1024 me4000_inl(dev, info->ai_context.start_reg);
1025
1026 /* Wait until ready */
1027 udelay(10);
1028 if (!(me4000_inl(dev, info->ai_context.
1029 status_reg) & ME4000_AI_STATUS_BIT_EF_DATA)) {
1030 printk(KERN_ERR
1031 "comedi%d: me4000: me4000_ai_insn_read(): Value not available after wait\n",
1032 dev->minor);
1033 return -EIO;
1034 }
1035
1036 /* Read value from data fifo */
1037 lval = me4000_inl(dev, info->ai_context.data_reg) & 0xFFFF;
1038 data[0] = lval ^ 0x8000;
1039
1040 return 1;
1041 }
1042
1043 static int me4000_ai_cancel(comedi_device * dev, comedi_subdevice * s)
1044 {
1045 unsigned long tmp;
1046
1047 CALL_PDEBUG("In me4000_ai_cancel()\n");
1048
1049 /* Stop any running conversion */
1050 tmp = me4000_inl(dev, info->ai_context.ctrl_reg);
1051 tmp &= ~(ME4000_AI_CTRL_BIT_STOP | ME4000_AI_CTRL_BIT_IMMEDIATE_STOP);
1052 me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1053
1054 /* Clear the control register */
1055 me4000_outl(dev, 0x0, info->ai_context.ctrl_reg);
1056
1057 return 0;
1058 }
1059
1060 static int ai_check_chanlist(comedi_device * dev,
1061 comedi_subdevice * s, comedi_cmd * cmd)
1062 {
1063 int aref;
1064 int i;
1065
1066 CALL_PDEBUG("In ai_check_chanlist()\n");
1067
1068 /* Check whether a channel list is available */
1069 if (!cmd->chanlist_len) {
1070 printk(KERN_ERR
1071 "comedi%d: me4000: ai_check_chanlist(): No channel list available\n",
1072 dev->minor);
1073 return -EINVAL;
1074 }
1075
1076 /* Check the channel list size */
1077 if (cmd->chanlist_len > ME4000_AI_CHANNEL_LIST_COUNT) {
1078 printk(KERN_ERR
1079 "comedi%d: me4000: ai_check_chanlist(): Channel list is to large\n",
1080 dev->minor);
1081 return -EINVAL;
1082 }
1083
1084 /* Check the pointer */
1085 if (!cmd->chanlist) {
1086 printk(KERN_ERR
1087 "comedi%d: me4000: ai_check_chanlist(): NULL pointer to channel list\n",
1088 dev->minor);
1089 return -EFAULT;
1090 }
1091
1092 /* Check whether aref is equal for all entries */
1093 aref = CR_AREF(cmd->chanlist[0]);
1094 for (i = 0; i < cmd->chanlist_len; i++) {
1095 if (CR_AREF(cmd->chanlist[i]) != aref) {
1096 printk(KERN_ERR
1097 "comedi%d: me4000: ai_check_chanlist(): Mode is not equal for all entries\n",
1098 dev->minor);
1099 return -EINVAL;
1100 }
1101 }
1102
1103 /* Check whether channels are available for this ending */
1104 if (aref == SDF_DIFF) {
1105 for (i = 0; i < cmd->chanlist_len; i++) {
1106 if (CR_CHAN(cmd->chanlist[i]) >=
1107 thisboard->ai.diff_count) {
1108 printk(KERN_ERR
1109 "comedi%d: me4000: ai_check_chanlist(): Channel number to high\n",
1110 dev->minor);
1111 return -EINVAL;
1112 }
1113 }
1114 } else {
1115 for (i = 0; i < cmd->chanlist_len; i++) {
1116 if (CR_CHAN(cmd->chanlist[i]) >= thisboard->ai.count) {
1117 printk(KERN_ERR
1118 "comedi%d: me4000: ai_check_chanlist(): Channel number to high\n",
1119 dev->minor);
1120 return -EINVAL;
1121 }
1122 }
1123 }
1124
1125 /* Check if bipolar is set for all entries when in differential mode */
1126 if (aref == SDF_DIFF) {
1127 for (i = 0; i < cmd->chanlist_len; i++) {
1128 if (CR_RANGE(cmd->chanlist[i]) != 1 &&
1129 CR_RANGE(cmd->chanlist[i]) != 2) {
1130 printk(KERN_ERR
1131 "comedi%d: me4000: ai_check_chanlist(): Bipolar is not selected in differential mode\n",
1132 dev->minor);
1133 return -EINVAL;
1134 }
1135 }
1136 }
1137
1138 return 0;
1139 }
1140
1141 static int ai_round_cmd_args(comedi_device * dev,
1142 comedi_subdevice * s,
1143 comedi_cmd * cmd,
1144 unsigned int *init_ticks,
1145 unsigned int *scan_ticks, unsigned int *chan_ticks)
1146 {
1147
1148 int rest;
1149
1150 CALL_PDEBUG("In ai_round_cmd_args()\n");
1151
1152 *init_ticks = 0;
1153 *scan_ticks = 0;
1154 *chan_ticks = 0;
1155
1156 PDEBUG("ai_round_cmd_arg(): start_arg = %d\n", cmd->start_arg);
1157 PDEBUG("ai_round_cmd_arg(): scan_begin_arg = %d\n",
1158 cmd->scan_begin_arg);
1159 PDEBUG("ai_round_cmd_arg(): convert_arg = %d\n", cmd->convert_arg);
1160
1161 if (cmd->start_arg) {
1162 *init_ticks = (cmd->start_arg * 33) / 1000;
1163 rest = (cmd->start_arg * 33) % 1000;
1164
1165 if (cmd->flags & TRIG_ROUND_NEAREST) {
1166 if (rest > 33) {
1167 (*init_ticks)++;
1168 }
1169 } else if (cmd->flags & TRIG_ROUND_UP) {
1170 if (rest)
1171 (*init_ticks)++;
1172 }
1173 }
1174
1175 if (cmd->scan_begin_arg) {
1176 *scan_ticks = (cmd->scan_begin_arg * 33) / 1000;
1177 rest = (cmd->scan_begin_arg * 33) % 1000;
1178
1179 if (cmd->flags & TRIG_ROUND_NEAREST) {
1180 if (rest > 33) {
1181 (*scan_ticks)++;
1182 }
1183 } else if (cmd->flags & TRIG_ROUND_UP) {
1184 if (rest)
1185 (*scan_ticks)++;
1186 }
1187 }
1188
1189 if (cmd->convert_arg) {
1190 *chan_ticks = (cmd->convert_arg * 33) / 1000;
1191 rest = (cmd->convert_arg * 33) % 1000;
1192
1193 if (cmd->flags & TRIG_ROUND_NEAREST) {
1194 if (rest > 33) {
1195 (*chan_ticks)++;
1196 }
1197 } else if (cmd->flags & TRIG_ROUND_UP) {
1198 if (rest)
1199 (*chan_ticks)++;
1200 }
1201 }
1202
1203 PDEBUG("ai_round_cmd_args(): init_ticks = %d\n", *init_ticks);
1204 PDEBUG("ai_round_cmd_args(): scan_ticks = %d\n", *scan_ticks);
1205 PDEBUG("ai_round_cmd_args(): chan_ticks = %d\n", *chan_ticks);
1206
1207 return 0;
1208 }
1209
1210 static void ai_write_timer(comedi_device * dev,
1211 unsigned int init_ticks,
1212 unsigned int scan_ticks, unsigned int chan_ticks)
1213 {
1214
1215 CALL_PDEBUG("In ai_write_timer()\n");
1216
1217 me4000_outl(dev, init_ticks - 1,
1218 info->ai_context.scan_pre_timer_low_reg);
1219 me4000_outl(dev, 0x0, info->ai_context.scan_pre_timer_high_reg);
1220
1221 if (scan_ticks) {
1222 me4000_outl(dev, scan_ticks - 1,
1223 info->ai_context.scan_timer_low_reg);
1224 me4000_outl(dev, 0x0, info->ai_context.scan_timer_high_reg);
1225 }
1226
1227 me4000_outl(dev, chan_ticks - 1, info->ai_context.chan_pre_timer_reg);
1228 me4000_outl(dev, chan_ticks - 1, info->ai_context.chan_timer_reg);
1229 }
1230
1231 static int ai_prepare(comedi_device * dev,
1232 comedi_subdevice * s,
1233 comedi_cmd * cmd,
1234 unsigned int init_ticks,
1235 unsigned int scan_ticks, unsigned int chan_ticks)
1236 {
1237
1238 unsigned long tmp = 0;
1239
1240 CALL_PDEBUG("In ai_prepare()\n");
1241
1242 /* Write timer arguments */
1243 ai_write_timer(dev, init_ticks, scan_ticks, chan_ticks);
1244
1245 /* Reset control register */
1246 me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1247
1248 /* Start sources */
1249 if ((cmd->start_src == TRIG_EXT &&
1250 cmd->scan_begin_src == TRIG_TIMER &&
1251 cmd->convert_src == TRIG_TIMER) ||
1252 (cmd->start_src == TRIG_EXT &&
1253 cmd->scan_begin_src == TRIG_FOLLOW &&
1254 cmd->convert_src == TRIG_TIMER)) {
1255 tmp = ME4000_AI_CTRL_BIT_MODE_1 |
1256 ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1257 ME4000_AI_CTRL_BIT_DATA_FIFO;
1258 } else if (cmd->start_src == TRIG_EXT &&
1259 cmd->scan_begin_src == TRIG_EXT &&
1260 cmd->convert_src == TRIG_TIMER) {
1261 tmp = ME4000_AI_CTRL_BIT_MODE_2 |
1262 ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1263 ME4000_AI_CTRL_BIT_DATA_FIFO;
1264 } else if (cmd->start_src == TRIG_EXT &&
1265 cmd->scan_begin_src == TRIG_EXT &&
1266 cmd->convert_src == TRIG_EXT) {
1267 tmp = ME4000_AI_CTRL_BIT_MODE_0 |
1268 ME4000_AI_CTRL_BIT_MODE_1 |
1269 ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1270 ME4000_AI_CTRL_BIT_DATA_FIFO;
1271 } else {
1272 tmp = ME4000_AI_CTRL_BIT_MODE_0 |
1273 ME4000_AI_CTRL_BIT_CHANNEL_FIFO |
1274 ME4000_AI_CTRL_BIT_DATA_FIFO;
1275 }
1276
1277 /* Stop triggers */
1278 if (cmd->stop_src == TRIG_COUNT) {
1279 me4000_outl(dev, cmd->chanlist_len * cmd->stop_arg,
1280 info->ai_context.sample_counter_reg);
1281 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
1282 } else if (cmd->stop_src == TRIG_NONE &&
1283 cmd->scan_end_src == TRIG_COUNT) {
1284 me4000_outl(dev, cmd->scan_end_arg,
1285 info->ai_context.sample_counter_reg);
1286 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ;
1287 } else {
1288 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ;
1289 }
1290
1291 /* Write the setup to the control register */
1292 me4000_outl(dev, tmp, info->ai_context.ctrl_reg);
1293
1294 /* Write the channel list */
1295 ai_write_chanlist(dev, s, cmd);
1296
1297 return 0;
1298 }
1299
1300 static int ai_write_chanlist(comedi_device * dev,
1301 comedi_subdevice * s, comedi_cmd * cmd)
1302 {
1303 unsigned int entry;
1304 unsigned int chan;
1305 unsigned int rang;
1306 unsigned int aref;
1307 int i;
1308
1309 CALL_PDEBUG("In ai_write_chanlist()\n");
1310
1311 for (i = 0; i < cmd->chanlist_len; i++) {
1312 chan = CR_CHAN(cmd->chanlist[i]);
1313 rang = CR_RANGE(cmd->chanlist[i]);
1314 aref = CR_AREF(cmd->chanlist[i]);
1315
1316 entry = chan;
1317
1318 if (rang == 0) {
1319 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_2_5;
1320 } else if (rang == 1) {
1321 entry |= ME4000_AI_LIST_RANGE_UNIPOLAR_10;
1322 } else if (rang == 2) {
1323 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_2_5;
1324 } else {
1325 entry |= ME4000_AI_LIST_RANGE_BIPOLAR_10;
1326 }
1327
1328 if (aref == SDF_DIFF) {
1329 entry |= ME4000_AI_LIST_INPUT_DIFFERENTIAL;
1330 } else {
1331 entry |= ME4000_AI_LIST_INPUT_SINGLE_ENDED;
1332 }
1333
1334 me4000_outl(dev, entry, info->ai_context.channel_list_reg);
1335 }
1336
1337 return 0;
1338 }
1339
1340 static int me4000_ai_do_cmd(comedi_device * dev, comedi_subdevice * s)
1341 {
1342 int err;
1343 unsigned int init_ticks = 0;
1344 unsigned int scan_ticks = 0;
1345 unsigned int chan_ticks = 0;
1346 comedi_cmd *cmd = &s->async->cmd;
1347
1348 CALL_PDEBUG("In me4000_ai_do_cmd()\n");
1349
1350 /* Reset the analog input */
1351 err = me4000_ai_cancel(dev, s);
1352 if (err)
1353 return err;
1354
1355 /* Round the timer arguments */
1356 err = ai_round_cmd_args(dev,
1357 s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
1358 if (err)
1359 return err;
1360
1361 /* Prepare the AI for acquisition */
1362 err = ai_prepare(dev, s, cmd, init_ticks, scan_ticks, chan_ticks);
1363 if (err)
1364 return err;
1365
1366 /* Start acquistion by dummy read */
1367 me4000_inl(dev, info->ai_context.start_reg);
1368
1369 return 0;
1370 }
1371
1372 /*
1373 * me4000_ai_do_cmd_test():
1374 *
1375 * The demo cmd.c in ./comedilib/demo specifies 6 return values:
1376 * - success
1377 * - invalid source
1378 * - source conflict
1379 * - invalid argument
1380 * - argument conflict
1381 * - invalid chanlist
1382 * So I tried to adopt this scheme.
1383 */
1384 static int me4000_ai_do_cmd_test(comedi_device * dev,
1385 comedi_subdevice * s, comedi_cmd * cmd)
1386 {
1387
1388 unsigned int init_ticks;
1389 unsigned int chan_ticks;
1390 unsigned int scan_ticks;
1391 int err = 0;
1392
1393 CALL_PDEBUG("In me4000_ai_do_cmd_test()\n");
1394
1395 PDEBUG("me4000_ai_do_cmd_test(): subdev = %d\n", cmd->subdev);
1396 PDEBUG("me4000_ai_do_cmd_test(): flags = %08X\n", cmd->flags);
1397 PDEBUG("me4000_ai_do_cmd_test(): start_src = %08X\n",
1398 cmd->start_src);
1399 PDEBUG("me4000_ai_do_cmd_test(): start_arg = %d\n",
1400 cmd->start_arg);
1401 PDEBUG("me4000_ai_do_cmd_test(): scan_begin_src = %08X\n",
1402 cmd->scan_begin_src);
1403 PDEBUG("me4000_ai_do_cmd_test(): scan_begin_arg = %d\n",
1404 cmd->scan_begin_arg);
1405 PDEBUG("me4000_ai_do_cmd_test(): convert_src = %08X\n",
1406 cmd->convert_src);
1407 PDEBUG("me4000_ai_do_cmd_test(): convert_arg = %d\n",
1408 cmd->convert_arg);
1409 PDEBUG("me4000_ai_do_cmd_test(): scan_end_src = %08X\n",
1410 cmd->scan_end_src);
1411 PDEBUG("me4000_ai_do_cmd_test(): scan_end_arg = %d\n",
1412 cmd->scan_end_arg);
1413 PDEBUG("me4000_ai_do_cmd_test(): stop_src = %08X\n",
1414 cmd->stop_src);
1415 PDEBUG("me4000_ai_do_cmd_test(): stop_arg = %d\n", cmd->stop_arg);
1416 PDEBUG("me4000_ai_do_cmd_test(): chanlist = %d\n",
1417 (unsigned int)cmd->chanlist);
1418 PDEBUG("me4000_ai_do_cmd_test(): chanlist_len = %d\n",
1419 cmd->chanlist_len);
1420
1421 /* Only rounding flags are implemented */
1422 cmd->flags &= TRIG_ROUND_NEAREST | TRIG_ROUND_UP | TRIG_ROUND_DOWN;
1423
1424 /* Round the timer arguments */
1425 ai_round_cmd_args(dev, s, cmd, &init_ticks, &scan_ticks, &chan_ticks);
1426
1427 /*
1428 * Stage 1. Check if the trigger sources are generally valid.
1429 */
1430 switch (cmd->start_src) {
1431 case TRIG_NOW:
1432 case TRIG_EXT:
1433 break;
1434 case TRIG_ANY:
1435 cmd->start_src &= TRIG_NOW | TRIG_EXT;
1436 err++;
1437 break;
1438 default:
1439 printk(KERN_ERR
1440 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start source\n",
1441 dev->minor);
1442 cmd->start_src = TRIG_NOW;
1443 err++;
1444 }
1445 switch (cmd->scan_begin_src) {
1446 case TRIG_FOLLOW:
1447 case TRIG_TIMER:
1448 case TRIG_EXT:
1449 break;
1450 case TRIG_ANY:
1451 cmd->scan_begin_src &= TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT;
1452 err++;
1453 break;
1454 default:
1455 printk(KERN_ERR
1456 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid scan begin source\n",
1457 dev->minor);
1458 cmd->scan_begin_src = TRIG_FOLLOW;
1459 err++;
1460 }
1461 switch (cmd->convert_src) {
1462 case TRIG_TIMER:
1463 case TRIG_EXT:
1464 break;
1465 case TRIG_ANY:
1466 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
1467 err++;
1468 break;
1469 default:
1470 printk(KERN_ERR
1471 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid convert source\n",
1472 dev->minor);
1473 cmd->convert_src = TRIG_TIMER;
1474 err++;
1475 }
1476 switch (cmd->scan_end_src) {
1477 case TRIG_NONE:
1478 case TRIG_COUNT:
1479 break;
1480 case TRIG_ANY:
1481 cmd->scan_end_src &= TRIG_NONE | TRIG_COUNT;
1482 err++;
1483 break;
1484 default:
1485 printk(KERN_ERR
1486 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid scan end source\n",
1487 dev->minor);
1488 cmd->scan_end_src = TRIG_NONE;
1489 err++;
1490 }
1491 switch (cmd->stop_src) {
1492 case TRIG_NONE:
1493 case TRIG_COUNT:
1494 break;
1495 case TRIG_ANY:
1496 cmd->stop_src &= TRIG_NONE | TRIG_COUNT;
1497 err++;
1498 break;
1499 default:
1500 printk(KERN_ERR
1501 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid stop source\n",
1502 dev->minor);
1503 cmd->stop_src = TRIG_NONE;
1504 err++;
1505 }
1506 if (err) {
1507 return 1;
1508 }
1509
1510 /*
1511 * Stage 2. Check for trigger source conflicts.
1512 */
1513 if (cmd->start_src == TRIG_NOW &&
1514 cmd->scan_begin_src == TRIG_TIMER &&
1515 cmd->convert_src == TRIG_TIMER) {
1516 } else if (cmd->start_src == TRIG_NOW &&
1517 cmd->scan_begin_src == TRIG_FOLLOW &&
1518 cmd->convert_src == TRIG_TIMER) {
1519 } else if (cmd->start_src == TRIG_EXT &&
1520 cmd->scan_begin_src == TRIG_TIMER &&
1521 cmd->convert_src == TRIG_TIMER) {
1522 } else if (cmd->start_src == TRIG_EXT &&
1523 cmd->scan_begin_src == TRIG_FOLLOW &&
1524 cmd->convert_src == TRIG_TIMER) {
1525 } else if (cmd->start_src == TRIG_EXT &&
1526 cmd->scan_begin_src == TRIG_EXT &&
1527 cmd->convert_src == TRIG_TIMER) {
1528 } else if (cmd->start_src == TRIG_EXT &&
1529 cmd->scan_begin_src == TRIG_EXT &&
1530 cmd->convert_src == TRIG_EXT) {
1531 } else {
1532 printk(KERN_ERR
1533 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start trigger combination\n",
1534 dev->minor);
1535 cmd->start_src = TRIG_NOW;
1536 cmd->scan_begin_src = TRIG_FOLLOW;
1537 cmd->convert_src = TRIG_TIMER;
1538 err++;
1539 }
1540
1541 if (cmd->stop_src == TRIG_NONE && cmd->scan_end_src == TRIG_NONE) {
1542 } else if (cmd->stop_src == TRIG_COUNT &&
1543 cmd->scan_end_src == TRIG_NONE) {
1544 } else if (cmd->stop_src == TRIG_NONE &&
1545 cmd->scan_end_src == TRIG_COUNT) {
1546 } else if (cmd->stop_src == TRIG_COUNT &&
1547 cmd->scan_end_src == TRIG_COUNT) {
1548 } else {
1549 printk(KERN_ERR
1550 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid stop trigger combination\n",
1551 dev->minor);
1552 cmd->stop_src = TRIG_NONE;
1553 cmd->scan_end_src = TRIG_NONE;
1554 err++;
1555 }
1556 if (err) {
1557 return 2;
1558 }
1559
1560 /*
1561 * Stage 3. Check if arguments are generally valid.
1562 */
1563 if (cmd->chanlist_len < 1) {
1564 printk(KERN_ERR
1565 "comedi%d: me4000: me4000_ai_do_cmd_test(): No channel list\n",
1566 dev->minor);
1567 cmd->chanlist_len = 1;
1568 err++;
1569 }
1570 if (init_ticks < 66) {
1571 printk(KERN_ERR
1572 "comedi%d: me4000: me4000_ai_do_cmd_test(): Start arg to low\n",
1573 dev->minor);
1574 cmd->start_arg = 2000;
1575 err++;
1576 }
1577 if (scan_ticks && scan_ticks < 67) {
1578 printk(KERN_ERR
1579 "comedi%d: me4000: me4000_ai_do_cmd_test(): Scan begin arg to low\n",
1580 dev->minor);
1581 cmd->scan_begin_arg = 2031;
1582 err++;
1583 }
1584 if (chan_ticks < 66) {
1585 printk(KERN_ERR
1586 "comedi%d: me4000: me4000_ai_do_cmd_test(): Convert arg to low\n",
1587 dev->minor);
1588 cmd->convert_arg = 2000;
1589 err++;
1590 }
1591 if (err) {
1592 return 3;
1593 }
1594
1595 /*
1596 * Stage 4. Check for argument conflicts.
1597 */
1598 if (cmd->start_src == TRIG_NOW &&
1599 cmd->scan_begin_src == TRIG_TIMER &&
1600 cmd->convert_src == TRIG_TIMER) {
1601
1602 /* Check timer arguments */
1603 if (init_ticks < ME4000_AI_MIN_TICKS) {
1604 printk(KERN_ERR
1605 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start arg\n",
1606 dev->minor);
1607 cmd->start_arg = 2000; // 66 ticks at least
1608 err++;
1609 }
1610 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1611 printk(KERN_ERR
1612 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid convert arg\n",
1613 dev->minor);
1614 cmd->convert_arg = 2000; // 66 ticks at least
1615 err++;
1616 }
1617 if (scan_ticks <= cmd->chanlist_len * chan_ticks) {
1618 printk(KERN_ERR
1619 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid scan end arg\n",
1620 dev->minor);
1621 cmd->scan_end_arg = 2000 * cmd->chanlist_len + 31; // At least one tick more
1622 err++;
1623 }
1624 } else if (cmd->start_src == TRIG_NOW &&
1625 cmd->scan_begin_src == TRIG_FOLLOW &&
1626 cmd->convert_src == TRIG_TIMER) {
1627
1628 /* Check timer arguments */
1629 if (init_ticks < ME4000_AI_MIN_TICKS) {
1630 printk(KERN_ERR
1631 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start arg\n",
1632 dev->minor);
1633 cmd->start_arg = 2000; // 66 ticks at least
1634 err++;
1635 }
1636 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1637 printk(KERN_ERR
1638 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid convert arg\n",
1639 dev->minor);
1640 cmd->convert_arg = 2000; // 66 ticks at least
1641 err++;
1642 }
1643 } else if (cmd->start_src == TRIG_EXT &&
1644 cmd->scan_begin_src == TRIG_TIMER &&
1645 cmd->convert_src == TRIG_TIMER) {
1646
1647 /* Check timer arguments */
1648 if (init_ticks < ME4000_AI_MIN_TICKS) {
1649 printk(KERN_ERR
1650 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start arg\n",
1651 dev->minor);
1652 cmd->start_arg = 2000; // 66 ticks at least
1653 err++;
1654 }
1655 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1656 printk(KERN_ERR
1657 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid convert arg\n",
1658 dev->minor);
1659 cmd->convert_arg = 2000; // 66 ticks at least
1660 err++;
1661 }
1662 if (scan_ticks <= cmd->chanlist_len * chan_ticks) {
1663 printk(KERN_ERR
1664 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid scan end arg\n",
1665 dev->minor);
1666 cmd->scan_end_arg = 2000 * cmd->chanlist_len + 31; // At least one tick more
1667 err++;
1668 }
1669 } else if (cmd->start_src == TRIG_EXT &&
1670 cmd->scan_begin_src == TRIG_FOLLOW &&
1671 cmd->convert_src == TRIG_TIMER) {
1672
1673 /* Check timer arguments */
1674 if (init_ticks < ME4000_AI_MIN_TICKS) {
1675 printk(KERN_ERR
1676 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start arg\n",
1677 dev->minor);
1678 cmd->start_arg = 2000; // 66 ticks at least
1679 err++;
1680 }
1681 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1682 printk(KERN_ERR
1683 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid convert arg\n",
1684 dev->minor);
1685 cmd->convert_arg = 2000; // 66 ticks at least
1686 err++;
1687 }
1688 } else if (cmd->start_src == TRIG_EXT &&
1689 cmd->scan_begin_src == TRIG_EXT &&
1690 cmd->convert_src == TRIG_TIMER) {
1691
1692 /* Check timer arguments */
1693 if (init_ticks < ME4000_AI_MIN_TICKS) {
1694 printk(KERN_ERR
1695 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start arg\n",
1696 dev->minor);
1697 cmd->start_arg = 2000; // 66 ticks at least
1698 err++;
1699 }
1700 if (chan_ticks < ME4000_AI_MIN_TICKS) {
1701 printk(KERN_ERR
1702 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid convert arg\n",
1703 dev->minor);
1704 cmd->convert_arg = 2000; // 66 ticks at least
1705 err++;
1706 }
1707 } else if (cmd->start_src == TRIG_EXT &&
1708 cmd->scan_begin_src == TRIG_EXT &&
1709 cmd->convert_src == TRIG_EXT) {
1710
1711 /* Check timer arguments */
1712 if (init_ticks < ME4000_AI_MIN_TICKS) {
1713 printk(KERN_ERR
1714 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid start arg\n",
1715 dev->minor);
1716 cmd->start_arg = 2000; // 66 ticks at least
1717 err++;
1718 }
1719 }
1720 if (cmd->stop_src == TRIG_COUNT) {
1721 if (cmd->stop_arg == 0) {
1722 printk(KERN_ERR
1723 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid stop arg\n",
1724 dev->minor);
1725 cmd->stop_arg = 1;
1726 err++;
1727 }
1728 }
1729 if (cmd->scan_end_src == TRIG_COUNT) {
1730 if (cmd->scan_end_arg == 0) {
1731 printk(KERN_ERR
1732 "comedi%d: me4000: me4000_ai_do_cmd_test(): Invalid scan end arg\n",
1733 dev->minor);
1734 cmd->scan_end_arg = 1;
1735 err++;
1736 }
1737 }
1738 if (err) {
1739 return 4;
1740 }
1741
1742 /*
1743 * Stage 5. Check the channel list.
1744 */
1745 if (ai_check_chanlist(dev, s, cmd))
1746 return 5;
1747
1748 return 0;
1749 }
1750
1751 static irqreturn_t me4000_ai_isr(int irq, void *dev_id PT_REGS_ARG)
1752 {
1753 unsigned int tmp;
1754 comedi_device *dev = dev_id;
1755 comedi_subdevice *s = dev->subdevices;
1756 me4000_ai_context_t *ai_context = &info->ai_context;
1757 int i;
1758 int c = 0;
1759 long lval;
1760
1761 ISR_PDEBUG("me4000_ai_isr() is executed\n");
1762
1763 if (!dev->attached) {
1764 ISR_PDEBUG("me4000_ai_isr() premature interrupt\n");
1765 return IRQ_NONE;
1766 }
1767
1768 /* Reset all events */
1769 s->async->events = 0;
1770
1771 /* Check if irq number is right */
1772 if (irq != ai_context->irq) {
1773 printk(KERN_ERR
1774 "comedi%d: me4000: me4000_ai_isr(): Incorrect interrupt num: %d\n",
1775 dev->minor, irq);
1776 return IRQ_HANDLED;
1777 }
1778
1779 if (me4000_inl(dev,
1780 ai_context->
1781 irq_status_reg) & ME4000_IRQ_STATUS_BIT_AI_HF) {
1782 ISR_PDEBUG
1783 ("me4000_ai_isr(): Fifo half full interrupt occured\n");
1784
1785 /* Read status register to find out what happened */
1786 tmp = me4000_inl(dev, ai_context->ctrl_reg);
1787
1788 if (!(tmp & ME4000_AI_STATUS_BIT_FF_DATA) &&
1789 !(tmp & ME4000_AI_STATUS_BIT_HF_DATA) &&
1790 (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
1791 ISR_PDEBUG("me4000_ai_isr(): Fifo full\n");
1792 c = ME4000_AI_FIFO_COUNT;
1793
1794 /* FIFO overflow, so stop conversion and disable all interrupts */
1795 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1796 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1797 ME4000_AI_CTRL_BIT_SC_IRQ);
1798 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1799
1800 s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1801
1802 printk(KERN_ERR
1803 "comedi%d: me4000: me4000_ai_isr(): FIFO overflow\n",
1804 dev->minor);
1805 } else if ((tmp & ME4000_AI_STATUS_BIT_FF_DATA)
1806 && !(tmp & ME4000_AI_STATUS_BIT_HF_DATA)
1807 && (tmp & ME4000_AI_STATUS_BIT_EF_DATA)) {
1808 ISR_PDEBUG("me4000_ai_isr(): Fifo half full\n");
1809
1810 s->async->events |= COMEDI_CB_BLOCK;
1811
1812 c = ME4000_AI_FIFO_COUNT / 2;
1813 } else {
1814 printk(KERN_ERR
1815 "comedi%d: me4000: me4000_ai_isr(): Can't determine state of fifo\n",
1816 dev->minor);
1817 c = 0;
1818
1819 /* Undefined state, so stop conversion and disable all interrupts */
1820 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1821 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1822 ME4000_AI_CTRL_BIT_SC_IRQ);
1823 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1824
1825 s->async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
1826
1827 printk(KERN_ERR
1828 "comedi%d: me4000: me4000_ai_isr(): Undefined FIFO state\n",
1829 dev->minor);
1830 }
1831
1832 ISR_PDEBUG("me4000_ai_isr(): Try to read %d values\n", c);
1833
1834 for (i = 0; i < c; i++) {
1835 /* Read value from data fifo */
1836 lval = inl(ai_context->data_reg) & 0xFFFF;
1837 lval ^= 0x8000;
1838
1839 if (!comedi_buf_put(s->async, lval)) {
1840 /* Buffer overflow, so stop conversion and disable all interrupts */
1841 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1842 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ |
1843 ME4000_AI_CTRL_BIT_SC_IRQ);
1844 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1845
1846 s->async->events |= COMEDI_CB_OVERFLOW;
1847
1848 printk(KERN_ERR
1849 "comedi%d: me4000: me4000_ai_isr(): Buffer overflow\n",
1850 dev->minor);
1851
1852 break;
1853 }
1854 }
1855
1856 /* Work is done, so reset the interrupt */
1857 ISR_PDEBUG("me4000_ai_isr(): Reset fifo half full interrupt\n");
1858 tmp |= ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
1859 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1860 tmp &= ~ME4000_AI_CTRL_BIT_HF_IRQ_RESET;
1861 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1862 }
1863
1864 if (me4000_inl(dev,
1865 ai_context->
1866 irq_status_reg) & ME4000_IRQ_STATUS_BIT_SC) {
1867 ISR_PDEBUG
1868 ("me4000_ai_isr(): Sample counter interrupt occured\n");
1869
1870 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOA;
1871
1872 /* Acquisition is complete, so stop conversion and disable all interrupts */
1873 tmp = me4000_inl(dev, ai_context->ctrl_reg);
1874 tmp |= ME4000_AI_CTRL_BIT_IMMEDIATE_STOP;
1875 tmp &= ~(ME4000_AI_CTRL_BIT_HF_IRQ | ME4000_AI_CTRL_BIT_SC_IRQ);
1876 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1877
1878 /* Poll data until fifo empty */
1879 while (inl(ai_context->ctrl_reg) & ME4000_AI_STATUS_BIT_EF_DATA) {
1880 /* Read value from data fifo */
1881 lval = inl(ai_context->data_reg) & 0xFFFF;
1882 lval ^= 0x8000;
1883
1884 if (!comedi_buf_put(s->async, lval)) {
1885 printk(KERN_ERR
1886 "comedi%d: me4000: me4000_ai_isr(): Buffer overflow\n",
1887 dev->minor);
1888 s->async->events |= COMEDI_CB_OVERFLOW;
1889 break;
1890 }
1891 }
1892
1893 /* Work is done, so reset the interrupt */
1894 ISR_PDEBUG
1895 ("me4000_ai_isr(): Reset interrupt from sample counter\n");
1896 tmp |= ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
1897 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1898 tmp &= ~ME4000_AI_CTRL_BIT_SC_IRQ_RESET;
1899 me4000_outl(dev, tmp, ai_context->ctrl_reg);
1900 }
1901
1902 ISR_PDEBUG("me4000_ai_isr(): Events = 0x%X\n", s->async->events);
1903
1904 if (s->async->events)
1905 comedi_event(dev, s);
1906
1907 return IRQ_HANDLED;
1908 }
1909
1910 /*=============================================================================
1911 Analog output section
1912 ===========================================================================*/
1913
1914 static int me4000_ao_insn_write(comedi_device * dev,
1915 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
1916 {
1917
1918 int chan = CR_CHAN(insn->chanspec);
1919 int rang = CR_RANGE(insn->chanspec);
1920 int aref = CR_AREF(insn->chanspec);
1921 unsigned long tmp;
1922
1923 CALL_PDEBUG("In me4000_ao_insn_write()\n");
1924
1925 if (insn->n == 0) {
1926 return 0;
1927 } else if (insn->n > 1) {
1928 printk(KERN_ERR
1929 "comedi%d: me4000: me4000_ao_insn_write(): Invalid instruction length %d\n",
1930 dev->minor, insn->n);
1931 return -EINVAL;
1932 }
1933
1934 if (chan >= thisboard->ao.count) {
1935 printk(KERN_ERR
1936 "comedi%d: me4000: me4000_ao_insn_write(): Invalid channel %d\n",
1937 dev->minor, insn->n);
1938 return -EINVAL;
1939 }
1940
1941 if (rang != 0) {
1942 printk(KERN_ERR
1943 "comedi%d: me4000: me4000_ao_insn_write(): Invalid range %d\n",
1944 dev->minor, insn->n);
1945 return -EINVAL;
1946 }
1947
1948 if (aref != AREF_GROUND && aref != AREF_COMMON) {
1949 printk(KERN_ERR
1950 "comedi%d: me4000: me4000_ao_insn_write(): Invalid aref %d\n",
1951 dev->minor, insn->n);
1952 return -EINVAL;
1953 }
1954
1955 /* Stop any running conversion */
1956 tmp = me4000_inl(dev, info->ao_context[chan].ctrl_reg);
1957 tmp |= ME4000_AO_CTRL_BIT_IMMEDIATE_STOP;
1958 me4000_outl(dev, tmp, info->ao_context[chan].ctrl_reg);
1959
1960 /* Clear control register and set to single mode */
1961 me4000_outl(dev, 0x0, info->ao_context[chan].ctrl_reg);
1962
1963 /* Write data value */
1964 me4000_outl(dev, data[0], info->ao_context[chan].single_reg);
1965
1966 /* Store in the mirror */
1967 info->ao_context[chan].mirror = data[0];
1968
1969 return 1;
1970 }
1971
1972 static int me4000_ao_insn_read(comedi_device * dev,
1973 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
1974 {
1975 int chan = CR_CHAN(insn->chanspec);
1976
1977 if (insn->n == 0) {
1978 return 0;
1979 } else if (insn->n > 1) {
1980 printk("comedi%d: me4000: me4000_ao_insn_read(): Invalid instruction length\n", dev->minor);
1981 return -EINVAL;
1982 }
1983
1984 data[0] = info->ao_context[chan].mirror;
1985
1986 return 1;
1987 }
1988
1989 /*=============================================================================
1990 Digital I/O section
1991 ===========================================================================*/
1992
1993 static int me4000_dio_insn_bits(comedi_device * dev,
1994 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
1995 {
1996
1997 CALL_PDEBUG("In me4000_dio_insn_bits()\n");
1998
1999 /* Length of data must be 2 (mask and new data, see below) */
2000 if (insn->n == 0) {
2001 return 0;
2002 }
2003 if (insn->n != 2) {
2004 printk("comedi%d: me4000: me4000_dio_insn_bits(): Invalid instruction length\n", dev->minor);
2005 return -EINVAL;
2006 }
2007
2008 /*
2009 * The insn data consists of a mask in data[0] and the new data
2010 * in data[1]. The mask defines which bits we are concerning about.
2011 * The new data must be anded with the mask.
2012 * Each channel corresponds to a bit.
2013 */
2014 if (data[0]) {
2015 /* Check if requested ports are configured for output */
2016 if ((s->io_bits & data[0]) != data[0])
2017 return -EIO;
2018
2019 s->state &= ~data[0];
2020 s->state |= data[0] & data[1];
2021
2022 /* Write out the new digital output lines */
2023 me4000_outl(dev, (s->state >> 0) & 0xFF,
2024 info->dio_context.port_0_reg);
2025 me4000_outl(dev, (s->state >> 8) & 0xFF,
2026 info->dio_context.port_1_reg);
2027 me4000_outl(dev, (s->state >> 16) & 0xFF,
2028 info->dio_context.port_2_reg);
2029 me4000_outl(dev, (s->state >> 24) & 0xFF,
2030 info->dio_context.port_3_reg);
2031 }
2032
2033 /* On return, data[1] contains the value of
2034 the digital input and output lines. */
2035 data[1] =
2036 ((me4000_inl(dev, info->dio_context.port_0_reg) & 0xFF) << 0) |
2037 ((me4000_inl(dev, info->dio_context.port_1_reg) & 0xFF) << 8) |
2038 ((me4000_inl(dev, info->dio_context.port_2_reg) & 0xFF) << 16) |
2039 ((me4000_inl(dev, info->dio_context.port_3_reg) & 0xFF) << 24);
2040
2041 return 2;
2042 }
2043
2044 static int me4000_dio_insn_config(comedi_device * dev,
2045 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
2046 {
2047 unsigned long tmp;
2048 int chan = CR_CHAN(insn->chanspec);
2049
2050 CALL_PDEBUG("In me4000_dio_insn_config()\n");
2051
2052 if (data[0] == INSN_CONFIG_DIO_QUERY) {
2053 data[1] =
2054 (s->
2055 io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
2056 return insn->n;
2057 }
2058
2059 /*
2060 * The input or output configuration of each digital line is
2061 * configured by a special insn_config instruction. chanspec
2062 * contains the channel to be changed, and data[0] contains the
2063 * value COMEDI_INPUT or COMEDI_OUTPUT.
2064 * On the ME-4000 it is only possible to switch port wise (8 bit)
2065 */
2066
2067 tmp = me4000_inl(dev, info->dio_context.ctrl_reg);
2068
2069 if (data[0] == COMEDI_OUTPUT) {
2070 if (chan < 8) {
2071 s->io_bits |= 0xFF;
2072 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_0 |
2073 ME4000_DIO_CTRL_BIT_MODE_1);
2074 tmp |= ME4000_DIO_CTRL_BIT_MODE_0;
2075 } else if (chan < 16) {
2076 /*
2077 * Chech for optoisolated ME-4000 version. If one the first
2078 * port is a fixed output port and the second is a fixed input port.
2079 */
2080 if (!me4000_inl(dev, info->dio_context.dir_reg))
2081 return -ENODEV;
2082
2083 s->io_bits |= 0xFF00;
2084 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_2 |
2085 ME4000_DIO_CTRL_BIT_MODE_3);
2086 tmp |= ME4000_DIO_CTRL_BIT_MODE_2;
2087 } else if (chan < 24) {
2088 s->io_bits |= 0xFF0000;
2089 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_4 |
2090 ME4000_DIO_CTRL_BIT_MODE_5);
2091 tmp |= ME4000_DIO_CTRL_BIT_MODE_4;
2092 } else if (chan < 32) {
2093 s->io_bits |= 0xFF000000;
2094 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_6 |
2095 ME4000_DIO_CTRL_BIT_MODE_7);
2096 tmp |= ME4000_DIO_CTRL_BIT_MODE_6;
2097 } else {
2098 return -EINVAL;
2099 }
2100 } else {
2101 if (chan < 8) {
2102 /*
2103 * Chech for optoisolated ME-4000 version. If one the first
2104 * port is a fixed output port and the second is a fixed input port.
2105 */
2106 if (!me4000_inl(dev, info->dio_context.dir_reg))
2107 return -ENODEV;
2108
2109 s->io_bits &= ~0xFF;
2110 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_0 |
2111 ME4000_DIO_CTRL_BIT_MODE_1);
2112 } else if (chan < 16) {
2113 s->io_bits &= ~0xFF00;
2114 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_2 |
2115 ME4000_DIO_CTRL_BIT_MODE_3);
2116 } else if (chan < 24) {
2117 s->io_bits &= ~0xFF0000;
2118 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_4 |
2119 ME4000_DIO_CTRL_BIT_MODE_5);
2120 } else if (chan < 32) {
2121 s->io_bits &= ~0xFF000000;
2122 tmp &= ~(ME4000_DIO_CTRL_BIT_MODE_6 |
2123 ME4000_DIO_CTRL_BIT_MODE_7);
2124 } else {
2125 return -EINVAL;
2126 }
2127 }
2128
2129 me4000_outl(dev, tmp, info->dio_context.ctrl_reg);
2130
2131 return 1;
2132 }
2133
2134 /*=============================================================================
2135 Counter section
2136 ===========================================================================*/
2137
2138 static int cnt_reset(comedi_device * dev, unsigned int channel)
2139 {
2140
2141 CALL_PDEBUG("In cnt_reset()\n");
2142
2143 switch (channel) {
2144 case 0:
2145 me4000_outb(dev, 0x30, info->cnt_context.ctrl_reg);
2146 me4000_outb(dev, 0x00, info->cnt_context.counter_0_reg);
2147 me4000_outb(dev, 0x00, info->cnt_context.counter_0_reg);
2148 break;
2149 case 1:
2150 me4000_outb(dev, 0x70, info->cnt_context.ctrl_reg);
2151 me4000_outb(dev, 0x00, info->cnt_context.counter_1_reg);
2152 me4000_outb(dev, 0x00, info->cnt_context.counter_1_reg);
2153 break;
2154 case 2:
2155 me4000_outb(dev, 0xB0, info->cnt_context.ctrl_reg);
2156 me4000_outb(dev, 0x00, info->cnt_context.counter_2_reg);
2157 me4000_outb(dev, 0x00, info->cnt_context.counter_2_reg);
2158 break;
2159 default:
2160 printk(KERN_ERR
2161 "comedi%d: me4000: cnt_reset(): Invalid channel\n",
2162 dev->minor);
2163 return -EINVAL;
2164 }
2165
2166 return 0;
2167 }
2168
2169 static int cnt_config(comedi_device * dev, unsigned int channel,
2170 unsigned int mode)
2171 {
2172 int tmp = 0;
2173
2174 CALL_PDEBUG("In cnt_config()\n");
2175
2176 switch (channel) {
2177 case 0:
2178 tmp |= ME4000_CNT_COUNTER_0;
2179 break;
2180 case 1:
2181 tmp |= ME4000_CNT_COUNTER_1;
2182 break;
2183 case 2:
2184 tmp |= ME4000_CNT_COUNTER_2;
2185 break;
2186 default:
2187 printk(KERN_ERR
2188 "comedi%d: me4000: cnt_config(): Invalid channel\n",
2189 dev->minor);
2190 return -EINVAL;
2191 }
2192
2193 switch (mode) {
2194 case 0:
2195 tmp |= ME4000_CNT_MODE_0;
2196 break;
2197 case 1:
2198 tmp |= ME4000_CNT_MODE_1;
2199 break;
2200 case 2:
2201 tmp |= ME4000_CNT_MODE_2;
2202 break;
2203 case 3:
2204 tmp |= ME4000_CNT_MODE_3;
2205 break;
2206 case 4:
2207 tmp |= ME4000_CNT_MODE_4;
2208 break;
2209 case 5:
2210 tmp |= ME4000_CNT_MODE_5;
2211 break;
2212 default:
2213 printk(KERN_ERR
2214 "comedi%d: me4000: cnt_config(): Invalid counter mode\n",
2215 dev->minor);
2216 return -EINVAL;
2217 }
2218
2219 /* Write the control word */
2220 tmp |= 0x30;
2221 me4000_outb(dev, tmp, info->cnt_context.ctrl_reg);
2222
2223 return 0;
2224 }
2225
2226 static int me4000_cnt_insn_config(comedi_device * dev,
2227 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
2228 {
2229
2230 int err;
2231
2232 CALL_PDEBUG("In me4000_cnt_insn_config()\n");
2233
2234 switch (data[0]) {
2235 case GPCT_RESET:
2236 if (insn->n != 1) {
2237 printk(KERN_ERR
2238 "comedi%d: me4000: me4000_cnt_insn_config(): Invalid instruction length%d\n",
2239 dev->minor, insn->n);
2240 return -EINVAL;
2241 }
2242
2243 err = cnt_reset(dev, insn->chanspec);
2244 if (err)
2245 return err;
2246 break;
2247 case GPCT_SET_OPERATION:
2248 if (insn->n != 2) {
2249 printk(KERN_ERR
2250 "comedi%d: me4000: me4000_cnt_insn_config(): Invalid instruction length%d\n",
2251 dev->minor, insn->n);
2252 return -EINVAL;
2253 }
2254
2255 err = cnt_config(dev, insn->chanspec, data[1]);
2256 if (err)
2257 return err;
2258 break;
2259 default:
2260 printk(KERN_ERR
2261 "comedi%d: me4000: me4000_cnt_insn_config(): Invalid instruction\n",
2262 dev->minor);
2263 return -EINVAL;
2264 }
2265
2266 return 2;
2267 }
2268
2269 static int me4000_cnt_insn_read(comedi_device * dev,
2270 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
2271 {
2272
2273 unsigned short tmp;
2274
2275 CALL_PDEBUG("In me4000_cnt_insn_read()\n");
2276
2277 if (insn->n == 0) {
2278 return 0;
2279 }
2280 if (insn->n > 1) {
2281 printk(KERN_ERR
2282 "comedi%d: me4000: me4000_cnt_insn_read(): Invalid instruction length %d\n",
2283 dev->minor, insn->n);
2284 return -EINVAL;
2285 }
2286
2287 switch (insn->chanspec) {
2288 case 0:
2289 tmp = me4000_inb(dev, info->cnt_context.counter_0_reg);
2290 data[0] = tmp;
2291 tmp = me4000_inb(dev, info->cnt_context.counter_0_reg);
2292 data[0] |= tmp << 8;
2293 break;
2294 case 1:
2295 tmp = me4000_inb(dev, info->cnt_context.counter_1_reg);
2296 data[0] = tmp;
2297 tmp = me4000_inb(dev, info->cnt_context.counter_1_reg);
2298 data[0] |= tmp << 8;
2299 break;
2300 case 2:
2301 tmp = me4000_inb(dev, info->cnt_context.counter_2_reg);
2302 data[0] = tmp;
2303 tmp = me4000_inb(dev, info->cnt_context.counter_2_reg);
2304 data[0] |= tmp << 8;
2305 break;
2306 default:
2307 printk(KERN_ERR
2308 "comedi%d: me4000: me4000_cnt_insn_read(): Invalid channel %d\n",
2309 dev->minor, insn->chanspec);
2310 return -EINVAL;
2311 }
2312
2313 return 1;
2314 }
2315
2316 static int me4000_cnt_insn_write(comedi_device * dev,
2317 comedi_subdevice * s, comedi_insn * insn, lsampl_t * data)
2318 {
2319
2320 unsigned short tmp;
2321
2322 CALL_PDEBUG("In me4000_cnt_insn_write()\n");
2323
2324 if (insn->n == 0) {
2325 return 0;
2326 } else if (insn->n > 1) {
2327 printk(KERN_ERR
2328 "comedi%d: me4000: me4000_cnt_insn_write(): Invalid instruction length %d\n",
2329 dev->minor, insn->n);
2330 return -EINVAL;
2331 }
2332
2333 switch (insn->chanspec) {
2334 case 0:
2335 tmp = data[0] & 0xFF;
2336 me4000_outb(dev, tmp, info->cnt_context.counter_0_reg);
2337 tmp = (data[0] >> 8) & 0xFF;
2338 me4000_outb(dev, tmp, info->cnt_context.counter_0_reg);
2339 break;
2340 case 1:
2341 tmp = data[0] & 0xFF;
2342 me4000_outb(dev, tmp, info->cnt_context.counter_1_reg);
2343 tmp = (data[0] >> 8) & 0xFF;
2344 me4000_outb(dev, tmp, info->cnt_context.counter_1_reg);
2345 break;
2346 case 2:
2347 tmp = data[0] & 0xFF;
2348 me4000_outb(dev, tmp, info->cnt_context.counter_2_reg);
2349 tmp = (data[0] >> 8) & 0xFF;
2350 me4000_outb(dev, tmp, info->cnt_context.counter_2_reg);
2351 break;
2352 default:
2353 printk(KERN_ERR
2354 "comedi%d: me4000: me4000_cnt_insn_write(): Invalid channel %d\n",
2355 dev->minor, insn->chanspec);
2356 return -EINVAL;
2357 }
2358
2359 return 1;
2360 }
2361
2362 COMEDI_PCI_INITCLEANUP(driver_me4000, me4000_pci_table);
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK