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