1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75#include <linux/module.h>
76#include <linux/interrupt.h>
77
78#include "../comedidev.h"
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97#define PCMUIO_PORT_REG(x) (0x00 + (x))
98#define PCMUIO_INT_PENDING_REG 0x06
99#define PCMUIO_PAGE_LOCK_REG 0x07
100#define PCMUIO_LOCK_PORT(x) ((1 << (x)) & 0x3f)
101#define PCMUIO_PAGE(x) (((x) & 0x3) << 6)
102#define PCMUIO_PAGE_MASK PCMUIO_PAGE(3)
103#define PCMUIO_PAGE_POL 1
104#define PCMUIO_PAGE_ENAB 2
105#define PCMUIO_PAGE_INT_ID 3
106#define PCMUIO_PAGE_REG(x) (0x08 + (x))
107
108#define PCMUIO_ASIC_IOSIZE 0x10
109#define PCMUIO_MAX_ASICS 2
110
111struct pcmuio_board {
112 const char *name;
113 const int num_asics;
114};
115
116static const struct pcmuio_board pcmuio_boards[] = {
117 {
118 .name = "pcmuio48",
119 .num_asics = 1,
120 }, {
121 .name = "pcmuio96",
122 .num_asics = 2,
123 },
124};
125
126struct pcmuio_asic {
127 spinlock_t pagelock;
128 spinlock_t spinlock;
129 unsigned int enabled_mask;
130 unsigned int active:1;
131};
132
133struct pcmuio_private {
134 struct pcmuio_asic asics[PCMUIO_MAX_ASICS];
135 unsigned int irq2;
136};
137
138static inline unsigned long pcmuio_asic_iobase(struct comedi_device *dev,
139 int asic)
140{
141 return dev->iobase + (asic * PCMUIO_ASIC_IOSIZE);
142}
143
144static inline int pcmuio_subdevice_to_asic(struct comedi_subdevice *s)
145{
146
147
148
149
150 return s->index / 2;
151}
152
153static inline int pcmuio_subdevice_to_port(struct comedi_subdevice *s)
154{
155
156
157
158
159 return (s->index % 2) ? 3 : 0;
160}
161
162static void pcmuio_write(struct comedi_device *dev, unsigned int val,
163 int asic, int page, int port)
164{
165 struct pcmuio_private *devpriv = dev->private;
166 struct pcmuio_asic *chip = &devpriv->asics[asic];
167 unsigned long iobase = pcmuio_asic_iobase(dev, asic);
168 unsigned long flags;
169
170 spin_lock_irqsave(&chip->pagelock, flags);
171 if (page == 0) {
172
173 outb(val & 0xff, iobase + PCMUIO_PORT_REG(port + 0));
174 outb((val >> 8) & 0xff, iobase + PCMUIO_PORT_REG(port + 1));
175 outb((val >> 16) & 0xff, iobase + PCMUIO_PORT_REG(port + 2));
176 } else {
177 outb(PCMUIO_PAGE(page), iobase + PCMUIO_PAGE_LOCK_REG);
178 outb(val & 0xff, iobase + PCMUIO_PAGE_REG(0));
179 outb((val >> 8) & 0xff, iobase + PCMUIO_PAGE_REG(1));
180 outb((val >> 16) & 0xff, iobase + PCMUIO_PAGE_REG(2));
181 }
182 spin_unlock_irqrestore(&chip->pagelock, flags);
183}
184
185static unsigned int pcmuio_read(struct comedi_device *dev,
186 int asic, int page, int port)
187{
188 struct pcmuio_private *devpriv = dev->private;
189 struct pcmuio_asic *chip = &devpriv->asics[asic];
190 unsigned long iobase = pcmuio_asic_iobase(dev, asic);
191 unsigned long flags;
192 unsigned int val;
193
194 spin_lock_irqsave(&chip->pagelock, flags);
195 if (page == 0) {
196
197 val = inb(iobase + PCMUIO_PORT_REG(port + 0));
198 val |= (inb(iobase + PCMUIO_PORT_REG(port + 1)) << 8);
199 val |= (inb(iobase + PCMUIO_PORT_REG(port + 2)) << 16);
200 } else {
201 outb(PCMUIO_PAGE(page), iobase + PCMUIO_PAGE_LOCK_REG);
202 val = inb(iobase + PCMUIO_PAGE_REG(0));
203 val |= (inb(iobase + PCMUIO_PAGE_REG(1)) << 8);
204 val |= (inb(iobase + PCMUIO_PAGE_REG(2)) << 16);
205 }
206 spin_unlock_irqrestore(&chip->pagelock, flags);
207
208 return val;
209}
210
211
212
213
214
215
216
217
218
219
220
221static int pcmuio_dio_insn_bits(struct comedi_device *dev,
222 struct comedi_subdevice *s,
223 struct comedi_insn *insn,
224 unsigned int *data)
225{
226 int asic = pcmuio_subdevice_to_asic(s);
227 int port = pcmuio_subdevice_to_port(s);
228 unsigned int chanmask = (1 << s->n_chan) - 1;
229 unsigned int mask;
230 unsigned int val;
231
232 mask = comedi_dio_update_state(s, data);
233 if (mask) {
234
235
236
237
238
239
240
241
242 val = ~s->state & chanmask;
243 val &= s->io_bits;
244 pcmuio_write(dev, val, asic, 0, port);
245 }
246
247
248 val = pcmuio_read(dev, asic, 0, port);
249
250
251 data[1] = ~val & chanmask;
252
253 return insn->n;
254}
255
256static int pcmuio_dio_insn_config(struct comedi_device *dev,
257 struct comedi_subdevice *s,
258 struct comedi_insn *insn,
259 unsigned int *data)
260{
261 int asic = pcmuio_subdevice_to_asic(s);
262 int port = pcmuio_subdevice_to_port(s);
263 int ret;
264
265 ret = comedi_dio_insn_config(dev, s, insn, data, 0);
266 if (ret)
267 return ret;
268
269 if (data[0] == INSN_CONFIG_DIO_INPUT)
270 pcmuio_write(dev, s->io_bits, asic, 0, port);
271
272 return insn->n;
273}
274
275static void pcmuio_reset(struct comedi_device *dev)
276{
277 const struct pcmuio_board *board = dev->board_ptr;
278 int asic;
279
280 for (asic = 0; asic < board->num_asics; ++asic) {
281
282 pcmuio_write(dev, 0, asic, 0, 0);
283 pcmuio_write(dev, 0, asic, 0, 3);
284
285
286 pcmuio_write(dev, 0, asic, PCMUIO_PAGE_POL, 0);
287 pcmuio_write(dev, 0, asic, PCMUIO_PAGE_ENAB, 0);
288 pcmuio_write(dev, 0, asic, PCMUIO_PAGE_INT_ID, 0);
289 }
290}
291
292
293static void pcmuio_stop_intr(struct comedi_device *dev,
294 struct comedi_subdevice *s)
295{
296 struct pcmuio_private *devpriv = dev->private;
297 int asic = pcmuio_subdevice_to_asic(s);
298 struct pcmuio_asic *chip = &devpriv->asics[asic];
299
300 chip->enabled_mask = 0;
301 chip->active = 0;
302 s->async->inttrig = NULL;
303
304
305 pcmuio_write(dev, 0, asic, PCMUIO_PAGE_ENAB, 0);
306}
307
308static void pcmuio_handle_intr_subdev(struct comedi_device *dev,
309 struct comedi_subdevice *s,
310 unsigned triggered)
311{
312 struct pcmuio_private *devpriv = dev->private;
313 int asic = pcmuio_subdevice_to_asic(s);
314 struct pcmuio_asic *chip = &devpriv->asics[asic];
315 struct comedi_cmd *cmd = &s->async->cmd;
316 unsigned int val = 0;
317 unsigned long flags;
318 unsigned int i;
319
320 spin_lock_irqsave(&chip->spinlock, flags);
321
322 if (!chip->active)
323 goto done;
324
325 if (!(triggered & chip->enabled_mask))
326 goto done;
327
328 for (i = 0; i < cmd->chanlist_len; i++) {
329 unsigned int chan = CR_CHAN(cmd->chanlist[i]);
330
331 if (triggered & (1 << chan))
332 val |= (1 << i);
333 }
334
335 comedi_buf_write_samples(s, &val, 1);
336
337 if (cmd->stop_src == TRIG_COUNT &&
338 s->async->scans_done >= cmd->stop_arg)
339 s->async->events |= COMEDI_CB_EOA;
340
341done:
342 spin_unlock_irqrestore(&chip->spinlock, flags);
343
344 comedi_handle_events(dev, s);
345}
346
347static int pcmuio_handle_asic_interrupt(struct comedi_device *dev, int asic)
348{
349
350 struct comedi_subdevice *s = &dev->subdevices[asic * 2];
351 unsigned long iobase = pcmuio_asic_iobase(dev, asic);
352 unsigned int val;
353
354
355 val = inb(iobase + PCMUIO_INT_PENDING_REG) & 0x07;
356 if (!val)
357 return 0;
358
359
360 val = pcmuio_read(dev, asic, PCMUIO_PAGE_INT_ID, 0);
361 pcmuio_write(dev, 0, asic, PCMUIO_PAGE_INT_ID, 0);
362
363
364 pcmuio_handle_intr_subdev(dev, s, val);
365
366 return 1;
367}
368
369static irqreturn_t pcmuio_interrupt(int irq, void *d)
370{
371 struct comedi_device *dev = d;
372 struct pcmuio_private *devpriv = dev->private;
373 int handled = 0;
374
375 if (irq == dev->irq)
376 handled += pcmuio_handle_asic_interrupt(dev, 0);
377 if (irq == devpriv->irq2)
378 handled += pcmuio_handle_asic_interrupt(dev, 1);
379
380 return handled ? IRQ_HANDLED : IRQ_NONE;
381}
382
383
384static void pcmuio_start_intr(struct comedi_device *dev,
385 struct comedi_subdevice *s)
386{
387 struct pcmuio_private *devpriv = dev->private;
388 int asic = pcmuio_subdevice_to_asic(s);
389 struct pcmuio_asic *chip = &devpriv->asics[asic];
390 struct comedi_cmd *cmd = &s->async->cmd;
391 unsigned int bits = 0;
392 unsigned int pol_bits = 0;
393 int i;
394
395 chip->enabled_mask = 0;
396 chip->active = 1;
397 if (cmd->chanlist) {
398 for (i = 0; i < cmd->chanlist_len; i++) {
399 unsigned int chanspec = cmd->chanlist[i];
400 unsigned int chan = CR_CHAN(chanspec);
401 unsigned int range = CR_RANGE(chanspec);
402 unsigned int aref = CR_AREF(chanspec);
403
404 bits |= (1 << chan);
405 pol_bits |= ((aref || range) ? 1 : 0) << chan;
406 }
407 }
408 bits &= ((1 << s->n_chan) - 1);
409 chip->enabled_mask = bits;
410
411
412 pcmuio_write(dev, pol_bits, asic, PCMUIO_PAGE_POL, 0);
413 pcmuio_write(dev, bits, asic, PCMUIO_PAGE_ENAB, 0);
414}
415
416static int pcmuio_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
417{
418 struct pcmuio_private *devpriv = dev->private;
419 int asic = pcmuio_subdevice_to_asic(s);
420 struct pcmuio_asic *chip = &devpriv->asics[asic];
421 unsigned long flags;
422
423 spin_lock_irqsave(&chip->spinlock, flags);
424 if (chip->active)
425 pcmuio_stop_intr(dev, s);
426 spin_unlock_irqrestore(&chip->spinlock, flags);
427
428 return 0;
429}
430
431static int pcmuio_inttrig_start_intr(struct comedi_device *dev,
432 struct comedi_subdevice *s,
433 unsigned int trig_num)
434{
435 struct pcmuio_private *devpriv = dev->private;
436 struct comedi_cmd *cmd = &s->async->cmd;
437 int asic = pcmuio_subdevice_to_asic(s);
438 struct pcmuio_asic *chip = &devpriv->asics[asic];
439 unsigned long flags;
440
441 if (trig_num != cmd->start_arg)
442 return -EINVAL;
443
444 spin_lock_irqsave(&chip->spinlock, flags);
445 s->async->inttrig = NULL;
446 if (chip->active)
447 pcmuio_start_intr(dev, s);
448
449 spin_unlock_irqrestore(&chip->spinlock, flags);
450
451 return 1;
452}
453
454
455
456
457static int pcmuio_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
458{
459 struct pcmuio_private *devpriv = dev->private;
460 struct comedi_cmd *cmd = &s->async->cmd;
461 int asic = pcmuio_subdevice_to_asic(s);
462 struct pcmuio_asic *chip = &devpriv->asics[asic];
463 unsigned long flags;
464
465 spin_lock_irqsave(&chip->spinlock, flags);
466 chip->active = 1;
467
468
469 if (cmd->start_src == TRIG_INT)
470 s->async->inttrig = pcmuio_inttrig_start_intr;
471 else
472 pcmuio_start_intr(dev, s);
473
474 spin_unlock_irqrestore(&chip->spinlock, flags);
475
476 return 0;
477}
478
479static int pcmuio_cmdtest(struct comedi_device *dev,
480 struct comedi_subdevice *s,
481 struct comedi_cmd *cmd)
482{
483 int err = 0;
484
485
486
487 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
488 err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
489 err |= comedi_check_trigger_src(&cmd->convert_src, TRIG_NOW);
490 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
491 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
492
493 if (err)
494 return 1;
495
496
497
498 err |= comedi_check_trigger_is_unique(cmd->start_src);
499 err |= comedi_check_trigger_is_unique(cmd->stop_src);
500
501
502
503 if (err)
504 return 2;
505
506
507
508 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
509 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
510 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
511 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
512 cmd->chanlist_len);
513
514 if (cmd->stop_src == TRIG_COUNT)
515 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
516 else
517 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
518
519 if (err)
520 return 3;
521
522
523
524
525
526 return 0;
527}
528
529static int pcmuio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
530{
531 const struct pcmuio_board *board = dev->board_ptr;
532 struct comedi_subdevice *s;
533 struct pcmuio_private *devpriv;
534 int ret;
535 int i;
536
537 ret = comedi_request_region(dev, it->options[0],
538 board->num_asics * PCMUIO_ASIC_IOSIZE);
539 if (ret)
540 return ret;
541
542 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
543 if (!devpriv)
544 return -ENOMEM;
545
546 for (i = 0; i < PCMUIO_MAX_ASICS; ++i) {
547 struct pcmuio_asic *chip = &devpriv->asics[i];
548
549 spin_lock_init(&chip->pagelock);
550 spin_lock_init(&chip->spinlock);
551 }
552
553 pcmuio_reset(dev);
554
555 if (it->options[1]) {
556
557 ret = request_irq(it->options[1], pcmuio_interrupt, 0,
558 dev->board_name, dev);
559 if (ret == 0)
560 dev->irq = it->options[1];
561 }
562
563 if (board->num_asics == 2) {
564 if (it->options[2] == dev->irq) {
565
566 devpriv->irq2 = it->options[2];
567 } else if (it->options[2]) {
568
569 ret = request_irq(it->options[2], pcmuio_interrupt, 0,
570 dev->board_name, dev);
571 if (ret == 0)
572 devpriv->irq2 = it->options[2];
573 }
574 }
575
576 ret = comedi_alloc_subdevices(dev, board->num_asics * 2);
577 if (ret)
578 return ret;
579
580 for (i = 0; i < dev->n_subdevices; ++i) {
581 s = &dev->subdevices[i];
582 s->type = COMEDI_SUBD_DIO;
583 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
584 s->n_chan = 24;
585 s->maxdata = 1;
586 s->range_table = &range_digital;
587 s->insn_bits = pcmuio_dio_insn_bits;
588 s->insn_config = pcmuio_dio_insn_config;
589
590
591 if ((i == 0 && dev->irq) || (i == 2 && devpriv->irq2)) {
592
593 dev->read_subdev = s;
594 s->subdev_flags |= SDF_CMD_READ | SDF_LSAMPL |
595 SDF_PACKED;
596 s->len_chanlist = s->n_chan;
597 s->cancel = pcmuio_cancel;
598 s->do_cmd = pcmuio_cmd;
599 s->do_cmdtest = pcmuio_cmdtest;
600 }
601 }
602
603 return 0;
604}
605
606static void pcmuio_detach(struct comedi_device *dev)
607{
608 struct pcmuio_private *devpriv = dev->private;
609
610 if (devpriv) {
611 pcmuio_reset(dev);
612
613
614 if (devpriv->irq2 && devpriv->irq2 != dev->irq)
615 free_irq(devpriv->irq2, dev);
616 }
617 comedi_legacy_detach(dev);
618}
619
620static struct comedi_driver pcmuio_driver = {
621 .driver_name = "pcmuio",
622 .module = THIS_MODULE,
623 .attach = pcmuio_attach,
624 .detach = pcmuio_detach,
625 .board_name = &pcmuio_boards[0].name,
626 .offset = sizeof(struct pcmuio_board),
627 .num_names = ARRAY_SIZE(pcmuio_boards),
628};
629module_comedi_driver(pcmuio_driver);
630
631MODULE_AUTHOR("Comedi http://www.comedi.org");
632MODULE_DESCRIPTION("Comedi low-level driver");
633MODULE_LICENSE("GPL");
634