?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.32.60
[linux-2.6.32.60-moxart.git] / drivers / staging / comedi / drivers / pcmuio.c
blobc1ae20ffb37957f77048bd021a944c5f17255f6c
1 /*
2 comedi/drivers/pcmuio.c
3 Driver for Winsystems PC-104 based 48-channel and 96-channel DIO boards.
4
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 2006 Calin A. Culianu <calin@ajvar.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 Driver: pcmuio
24 Description: A driver for the PCM-UIO48A and PCM-UIO96A boards from Winsystems.
25 Devices: [Winsystems] PCM-UIO48A (pcmuio48), PCM-UIO96A (pcmuio96)
26 Author: Calin Culianu <calin@ajvar.org>
27 Updated: Fri, 13 Jan 2006 12:01:01 -0500
28 Status: works
29
30 A driver for the relatively straightforward-to-program PCM-UIO48A and
31 PCM-UIO96A boards from Winsystems. These boards use either one or two
32 (in the 96-DIO version) WS16C48 ASIC HighDensity I/O Chips (HDIO).
33 This chip is interesting in that each I/O line is individually
34 programmable for INPUT or OUTPUT (thus comedi_dio_config can be done
35 on a per-channel basis). Also, each chip supports edge-triggered
36 interrupts for the first 24 I/O lines. Of course, since the
37 96-channel version of the board has two ASICs, it can detect polarity
38 changes on up to 48 I/O lines. Since this is essentially an (non-PnP)
39 ISA board, I/O Address and IRQ selection are done through jumpers on
40 the board. You need to pass that information to this driver as the
41 first and second comedi_config option, respectively. Note that the
42 48-channel version uses 16 bytes of IO memory and the 96-channel
43 version uses 32-bytes (in case you are worried about conflicts). The
44 48-channel board is split into two 24-channel comedi subdevices.
45 The 96-channel board is split into 4 24-channel DIO subdevices.
46
47 Note that IRQ support has been added, but it is untested.
48
49 To use edge-detection IRQ support, pass the IRQs of both ASICS
50 (for the 96 channel version) or just 1 ASIC (for 48-channel version).
51 Then, use use comedi_commands with TRIG_NOW.
52 Your callback will be called each time an edge is triggered, and the data
53 values will be two sample_t's, which should be concatenated to form one
54 32-bit unsigned int. This value is the mask of channels that had
55 edges detected from your channel list. Note that the bits positions
56 in the mask correspond to positions in your chanlist when you specified
57 the command and *not* channel id's!
58
59 To set the polarity of the edge-detection interrupts pass a nonzero value for
60 either CR_RANGE or CR_AREF for edge-up polarity, or a zero value for both
61 CR_RANGE and CR_AREF if you want edge-down polarity.
62
63 In the 48-channel version:
64
65 On subdev 0, the first 24 channels channels are edge-detect channels.
66
67 In the 96-channel board you have the collowing channels that can do edge detection:
68
69 subdev 0, channels 0-24 (first 24 channels of 1st ASIC)
70 subdev 2, channels 0-24 (first 24 channels of 2nd ASIC)
71
72 Configuration Options:
73 [0] - I/O port base address
74 [1] - IRQ (for first ASIC, or first 24 channels)
75 [2] - IRQ for second ASIC (pcmuio96 only - IRQ for chans 48-72 .. can be the same as first irq!)
76 */
77
78 #include <linux/interrupt.h>
79 #include "../comedidev.h"
80 #include "pcm_common.h"
81
82 #include <linux/pci.h> /* for PCI devices */
83
84 #define CHANS_PER_PORT 8
85 #define PORTS_PER_ASIC 6
86 #define INTR_PORTS_PER_ASIC 3
87 #define MAX_CHANS_PER_SUBDEV 24 /* number of channels per comedi subdevice */
88 #define PORTS_PER_SUBDEV (MAX_CHANS_PER_SUBDEV/CHANS_PER_PORT)
89 #define CHANS_PER_ASIC (CHANS_PER_PORT*PORTS_PER_ASIC)
90 #define INTR_CHANS_PER_ASIC 24
91 #define INTR_PORTS_PER_SUBDEV (INTR_CHANS_PER_ASIC/CHANS_PER_PORT)
92 #define MAX_DIO_CHANS (PORTS_PER_ASIC*2*CHANS_PER_PORT)
93 #define MAX_ASICS (MAX_DIO_CHANS/CHANS_PER_ASIC)
94 #define SDEV_NO ((int)(s - dev->subdevices))
95 #define CALC_N_SUBDEVS(nchans) ((nchans)/MAX_CHANS_PER_SUBDEV + (!!((nchans)%MAX_CHANS_PER_SUBDEV)) /*+ (nchans > INTR_CHANS_PER_ASIC ? 2 : 1)*/)
96 /* IO Memory sizes */
97 #define ASIC_IOSIZE (0x10)
98 #define PCMUIO48_IOSIZE ASIC_IOSIZE
99 #define PCMUIO96_IOSIZE (ASIC_IOSIZE*2)
100
101 /* Some offsets - these are all in the 16byte IO memory offset from
102 the base address. Note that there is a paging scheme to swap out
103 offsets 0x8-0xA using the PAGELOCK register. See the table below.
104
105 Register(s) Pages R/W? Description
106 --------------------------------------------------------------
107 REG_PORTx All R/W Read/Write/Configure IO
108 REG_INT_PENDING All ReadOnly Quickly see which INT_IDx has int.
109 REG_PAGELOCK All WriteOnly Select a page
110 REG_POLx Pg. 1 only WriteOnly Select edge-detection polarity
111 REG_ENABx Pg. 2 only WriteOnly Enable/Disable edge-detect. int.
112 REG_INT_IDx Pg. 3 only R/W See which ports/bits have ints.
113 */
114 #define REG_PORT0 0x0
115 #define REG_PORT1 0x1
116 #define REG_PORT2 0x2
117 #define REG_PORT3 0x3
118 #define REG_PORT4 0x4
119 #define REG_PORT5 0x5
120 #define REG_INT_PENDING 0x6
121 #define REG_PAGELOCK 0x7 /* page selector register, upper 2 bits select a page
122 and bits 0-5 are used to 'lock down' a particular
123 port above to make it readonly. */
124 #define REG_POL0 0x8
125 #define REG_POL1 0x9
126 #define REG_POL2 0xA
127 #define REG_ENAB0 0x8
128 #define REG_ENAB1 0x9
129 #define REG_ENAB2 0xA
130 #define REG_INT_ID0 0x8
131 #define REG_INT_ID1 0x9
132 #define REG_INT_ID2 0xA
133
134 #define NUM_PAGED_REGS 3
135 #define NUM_PAGES 4
136 #define FIRST_PAGED_REG 0x8
137 #define REG_PAGE_BITOFFSET 6
138 #define REG_LOCK_BITOFFSET 0
139 #define REG_PAGE_MASK (~((0x1<<REG_PAGE_BITOFFSET)-1))
140 #define REG_LOCK_MASK ~(REG_PAGE_MASK)
141 #define PAGE_POL 1
142 #define PAGE_ENAB 2
143 #define PAGE_INT_ID 3
144
145 /*
146 * Board descriptions for two imaginary boards. Describing the
147 * boards in this way is optional, and completely driver-dependent.
148 * Some drivers use arrays such as this, other do not.
149 */
150 struct pcmuio_board {
151 const char *name;
152 const int num_asics;
153 const int num_channels_per_port;
154 const int num_ports;
155 };
156
157 static const struct pcmuio_board pcmuio_boards[] = {
158 {
159 .name = "pcmuio48",
160 .num_asics = 1,
161 .num_ports = 6,
162 },
163 {
164 .name = "pcmuio96",
165 .num_asics = 2,
166 .num_ports = 12,
167 },
168 };
169
170 /*
171 * Useful for shorthand access to the particular board structure
172 */
173 #define thisboard ((const struct pcmuio_board *)dev->board_ptr)
174
175 /* this structure is for data unique to this subdevice. */
176 struct pcmuio_subdev_private {
177 /* mapping of halfwords (bytes) in port/chanarray to iobase */
178 unsigned long iobases[PORTS_PER_SUBDEV];
179
180 /* The below is only used for intr subdevices */
181 struct {
182 int asic; /* if non-negative, this subdev has an interrupt asic */
183 int first_chan; /* if nonnegative, the first channel id for
184 interrupts. */
185 int num_asic_chans; /* the number of asic channels in this subdev
186 that have interrutps */
187 int asic_chan; /* if nonnegative, the first channel id with
188 respect to the asic that has interrupts */
189 int enabled_mask; /* subdev-relative channel mask for channels
190 we are interested in */
191 int active;
192 int stop_count;
193 int continuous;
194 spinlock_t spinlock;
195 } intr;
196 };
197
198 /* this structure is for data unique to this hardware driver. If
199 several hardware drivers keep similar information in this structure,
200 feel free to suggest moving the variable to the struct comedi_device struct. */
201 struct pcmuio_private {
202 struct {
203 unsigned char pagelock; /* current page and lock */
204 unsigned char pol[NUM_PAGED_REGS]; /* shadow of POLx registers */
205 unsigned char enab[NUM_PAGED_REGS]; /* shadow of ENABx registers */
206 int num;
207 unsigned long iobase;
208 unsigned int irq;
209 spinlock_t spinlock;
210 } asics[MAX_ASICS];
211 struct pcmuio_subdev_private *sprivs;
212 };
213
214 /*
215 * most drivers define the following macro to make it easy to
216 * access the private structure.
217 */
218 #define devpriv ((struct pcmuio_private *)dev->private)
219 #define subpriv ((struct pcmuio_subdev_private *)s->private)
220 /*
221 * The struct comedi_driver structure tells the Comedi core module
222 * which functions to call to configure/deconfigure (attach/detach)
223 * the board, and also about the kernel module that contains
224 * the device code.
225 */
226 static int pcmuio_attach(struct comedi_device *dev,
227 struct comedi_devconfig *it);
228 static int pcmuio_detach(struct comedi_device *dev);
229
230 static struct comedi_driver driver = {
231 .driver_name = "pcmuio",
232 .module = THIS_MODULE,
233 .attach = pcmuio_attach,
234 .detach = pcmuio_detach,
235 /* It is not necessary to implement the following members if you are
236 * writing a driver for a ISA PnP or PCI card */
237 /* Most drivers will support multiple types of boards by
238 * having an array of board structures. These were defined
239 * in pcmuio_boards[] above. Note that the element 'name'
240 * was first in the structure -- Comedi uses this fact to
241 * extract the name of the board without knowing any details
242 * about the structure except for its length.
243 * When a device is attached (by comedi_config), the name
244 * of the device is given to Comedi, and Comedi tries to
245 * match it by going through the list of board names. If
246 * there is a match, the address of the pointer is put
247 * into dev->board_ptr and driver->attach() is called.
248 *
249 * Note that these are not necessary if you can determine
250 * the type of board in software. ISA PnP, PCI, and PCMCIA
251 * devices are such boards.
252 */
253 .board_name = &pcmuio_boards[0].name,
254 .offset = sizeof(struct pcmuio_board),
255 .num_names = ARRAY_SIZE(pcmuio_boards),
256 };
257
258 static int pcmuio_dio_insn_bits(struct comedi_device *dev,
259 struct comedi_subdevice *s,
260 struct comedi_insn *insn, unsigned int *data);
261 static int pcmuio_dio_insn_config(struct comedi_device *dev,
262 struct comedi_subdevice *s,
263 struct comedi_insn *insn, unsigned int *data);
264
265 static irqreturn_t interrupt_pcmuio(int irq, void *d);
266 static void pcmuio_stop_intr(struct comedi_device *, struct comedi_subdevice *);
267 static int pcmuio_cancel(struct comedi_device *dev, struct comedi_subdevice *s);
268 static int pcmuio_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
269 static int pcmuio_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
270 struct comedi_cmd *cmd);
271
272 /* some helper functions to deal with specifics of this device's registers */
273 static void init_asics(struct comedi_device *dev); /* sets up/clears ASIC chips to defaults */
274 static void switch_page(struct comedi_device *dev, int asic, int page);
275 #ifdef notused
276 static void lock_port(struct comedi_device *dev, int asic, int port);
277 static void unlock_port(struct comedi_device *dev, int asic, int port);
278 #endif
279
280 /*
281 * Attach is called by the Comedi core to configure the driver
282 * for a particular board. If you specified a board_name array
283 * in the driver structure, dev->board_ptr contains that
284 * address.
285 */
286 static int pcmuio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
287 {
288 struct comedi_subdevice *s;
289 int sdev_no, chans_left, n_subdevs, port, asic, thisasic_chanct = 0;
290 unsigned long iobase;
291 unsigned int irq[MAX_ASICS];
292
293 iobase = it->options[0];
294 irq[0] = it->options[1];
295 irq[1] = it->options[2];
296
297 printk("comedi%d: %s: io: %lx ", dev->minor, driver.driver_name,
298 iobase);
299
300 dev->iobase = iobase;
301
302 if (!iobase || !request_region(iobase,
303 thisboard->num_asics * ASIC_IOSIZE,
304 driver.driver_name)) {
305 printk("I/O port conflict\n");
306 return -EIO;
307 }
308
309 /*
310 * Initialize dev->board_name. Note that we can use the "thisboard"
311 * macro now, since we just initialized it in the last line.
312 */
313 dev->board_name = thisboard->name;
314
315 /*
316 * Allocate the private structure area. alloc_private() is a
317 * convenient macro defined in comedidev.h.
318 */
319 if (alloc_private(dev, sizeof(struct pcmuio_private)) < 0) {
320 printk("cannot allocate private data structure\n");
321 return -ENOMEM;
322 }
323
324 for (asic = 0; asic < MAX_ASICS; ++asic) {
325 devpriv->asics[asic].num = asic;
326 devpriv->asics[asic].iobase = dev->iobase + asic * ASIC_IOSIZE;
327 devpriv->asics[asic].irq = 0; /* this gets actually set at the end of
328 this function when we
329 request_irqs */
330 spin_lock_init(&devpriv->asics[asic].spinlock);
331 }
332
333 chans_left = CHANS_PER_ASIC * thisboard->num_asics;
334 n_subdevs = CALC_N_SUBDEVS(chans_left);
335 devpriv->sprivs =
336 kcalloc(n_subdevs, sizeof(struct pcmuio_subdev_private),
337 GFP_KERNEL);
338 if (!devpriv->sprivs) {
339 printk("cannot allocate subdevice private data structures\n");
340 return -ENOMEM;
341 }
342 /*
343 * Allocate the subdevice structures. alloc_subdevice() is a
344 * convenient macro defined in comedidev.h.
345 *
346 * Allocate 2 subdevs (32 + 16 DIO lines) or 3 32 DIO subdevs for the
347 * 96-channel version of the board.
348 */
349 if (alloc_subdevices(dev, n_subdevs) < 0) {
350 printk("cannot allocate subdevice data structures\n");
351 return -ENOMEM;
352 }
353
354 port = 0;
355 asic = 0;
356 for (sdev_no = 0; sdev_no < (int)dev->n_subdevices; ++sdev_no) {
357 int byte_no;
358
359 s = dev->subdevices + sdev_no;
360 s->private = devpriv->sprivs + sdev_no;
361 s->maxdata = 1;
362 s->range_table = &range_digital;
363 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
364 s->type = COMEDI_SUBD_DIO;
365 s->insn_bits = pcmuio_dio_insn_bits;
366 s->insn_config = pcmuio_dio_insn_config;
367 s->n_chan = min(chans_left, MAX_CHANS_PER_SUBDEV);
368 subpriv->intr.asic = -1;
369 subpriv->intr.first_chan = -1;
370 subpriv->intr.asic_chan = -1;
371 subpriv->intr.num_asic_chans = -1;
372 subpriv->intr.active = 0;
373 s->len_chanlist = 1;
374
375 /* save the ioport address for each 'port' of 8 channels in the
376 subdevice */
377 for (byte_no = 0; byte_no < PORTS_PER_SUBDEV; ++byte_no, ++port) {
378 if (port >= PORTS_PER_ASIC) {
379 port = 0;
380 ++asic;
381 thisasic_chanct = 0;
382 }
383 subpriv->iobases[byte_no] =
384 devpriv->asics[asic].iobase + port;
385
386 if (thisasic_chanct <
387 CHANS_PER_PORT * INTR_PORTS_PER_ASIC
388 && subpriv->intr.asic < 0) {
389 /* this is an interrupt subdevice, so setup the struct */
390 subpriv->intr.asic = asic;
391 subpriv->intr.active = 0;
392 subpriv->intr.stop_count = 0;
393 subpriv->intr.first_chan = byte_no * 8;
394 subpriv->intr.asic_chan = thisasic_chanct;
395 subpriv->intr.num_asic_chans =
396 s->n_chan - subpriv->intr.first_chan;
397 dev->read_subdev = s;
398 s->subdev_flags |= SDF_CMD_READ;
399 s->cancel = pcmuio_cancel;
400 s->do_cmd = pcmuio_cmd;
401 s->do_cmdtest = pcmuio_cmdtest;
402 s->len_chanlist = subpriv->intr.num_asic_chans;
403 }
404 thisasic_chanct += CHANS_PER_PORT;
405 }
406 spin_lock_init(&subpriv->intr.spinlock);
407
408 chans_left -= s->n_chan;
409
410 if (!chans_left) {
411 asic = 0; /* reset the asic to our first asic, to do intr subdevs */
412 port = 0;
413 }
414
415 }
416
417 init_asics(dev); /* clear out all the registers, basically */
418
419 for (asic = 0; irq[0] && asic < MAX_ASICS; ++asic) {
420 if (irq[asic]
421 && request_irq(irq[asic], interrupt_pcmuio,
422 IRQF_SHARED, thisboard->name, dev)) {
423 int i;
424 /* unroll the allocated irqs.. */
425 for (i = asic - 1; i >= 0; --i) {
426 free_irq(irq[i], dev);
427 devpriv->asics[i].irq = irq[i] = 0;
428 }
429 irq[asic] = 0;
430 }
431 devpriv->asics[asic].irq = irq[asic];
432 }
433
434 dev->irq = irq[0]; /* grr.. wish comedi dev struct supported multiple
435 irqs.. */
436
437 if (irq[0]) {
438 printk("irq: %u ", irq[0]);
439 if (irq[1] && thisboard->num_asics == 2)
440 printk("second ASIC irq: %u ", irq[1]);
441 } else {
442 printk("(IRQ mode disabled) ");
443 }
444
445 printk("attached\n");
446
447 return 1;
448 }
449
450 /*
451 * _detach is called to deconfigure a device. It should deallocate
452 * resources.
453 * This function is also called when _attach() fails, so it should be
454 * careful not to release resources that were not necessarily
455 * allocated by _attach(). dev->private and dev->subdevices are
456 * deallocated automatically by the core.
457 */
458 static int pcmuio_detach(struct comedi_device *dev)
459 {
460 int i;
461
462 printk("comedi%d: %s: remove\n", dev->minor, driver.driver_name);
463 if (dev->iobase)
464 release_region(dev->iobase, ASIC_IOSIZE * thisboard->num_asics);
465
466 for (i = 0; i < MAX_ASICS; ++i) {
467 if (devpriv->asics[i].irq)
468 free_irq(devpriv->asics[i].irq, dev);
469 }
470
471 if (devpriv && devpriv->sprivs)
472 kfree(devpriv->sprivs);
473
474 return 0;
475 }
476
477 /* DIO devices are slightly special. Although it is possible to
478 * implement the insn_read/insn_write interface, it is much more
479 * useful to applications if you implement the insn_bits interface.
480 * This allows packed reading/writing of the DIO channels. The
481 * comedi core can convert between insn_bits and insn_read/write */
482 static int pcmuio_dio_insn_bits(struct comedi_device *dev,
483 struct comedi_subdevice *s,
484 struct comedi_insn *insn, unsigned int *data)
485 {
486 int byte_no;
487 if (insn->n != 2)
488 return -EINVAL;
489
490 /* NOTE:
491 reading a 0 means this channel was high
492 writine a 0 sets the channel high
493 reading a 1 means this channel was low
494 writing a 1 means set this channel low
495
496 Therefore everything is always inverted. */
497
498 /* The insn data is a mask in data[0] and the new data
499 * in data[1], each channel cooresponding to a bit. */
500
501 #ifdef DAMMIT_ITS_BROKEN
502 /* DEBUG */
503 printk("write mask: %08x data: %08x\n", data[0], data[1]);
504 #endif
505
506 s->state = 0;
507
508 for (byte_no = 0; byte_no < s->n_chan / CHANS_PER_PORT; ++byte_no) {
509 /* address of 8-bit port */
510 unsigned long ioaddr = subpriv->iobases[byte_no],
511 /* bit offset of port in 32-bit doubleword */
512 offset = byte_no * 8;
513 /* this 8-bit port's data */
514 unsigned char byte = 0,
515 /* The write mask for this port (if any) */
516 write_mask_byte = (data[0] >> offset) & 0xff,
517 /* The data byte for this port */
518 data_byte = (data[1] >> offset) & 0xff;
519
520 byte = inb(ioaddr); /* read all 8-bits for this port */
521
522 #ifdef DAMMIT_ITS_BROKEN
523 /* DEBUG */
524 printk
525 ("byte %d wmb %02x db %02x offset %02d io %04x, data_in %02x ",
526 byte_no, (unsigned)write_mask_byte, (unsigned)data_byte,
527 offset, ioaddr, (unsigned)byte);
528 #endif
529
530 if (write_mask_byte) {
531 /* this byte has some write_bits -- so set the output lines */
532 byte &= ~write_mask_byte; /* clear bits for write mask */
533 byte |= ~data_byte & write_mask_byte; /* set to inverted data_byte */
534 /* Write out the new digital output state */
535 outb(byte, ioaddr);
536 }
537 #ifdef DAMMIT_ITS_BROKEN
538 /* DEBUG */
539 printk("data_out_byte %02x\n", (unsigned)byte);
540 #endif
541 /* save the digital input lines for this byte.. */
542 s->state |= ((unsigned int)byte) << offset;
543 }
544
545 /* now return the DIO lines to data[1] - note they came inverted! */
546 data[1] = ~s->state;
547
548 #ifdef DAMMIT_ITS_BROKEN
549 /* DEBUG */
550 printk("s->state %08x data_out %08x\n", s->state, data[1]);
551 #endif
552
553 return 2;
554 }
555
556 /* The input or output configuration of each digital line is
557 * configured by a special insn_config instruction. chanspec
558 * contains the channel to be changed, and data[0] contains the
559 * value COMEDI_INPUT or COMEDI_OUTPUT. */
560 static int pcmuio_dio_insn_config(struct comedi_device *dev,
561 struct comedi_subdevice *s,
562 struct comedi_insn *insn, unsigned int *data)
563 {
564 int chan = CR_CHAN(insn->chanspec), byte_no = chan / 8, bit_no =
565 chan % 8;
566 unsigned long ioaddr;
567 unsigned char byte;
568
569 /* Compute ioaddr for this channel */
570 ioaddr = subpriv->iobases[byte_no];
571
572 /* NOTE:
573 writing a 0 an IO channel's bit sets the channel to INPUT
574 and pulls the line high as well
575
576 writing a 1 to an IO channel's bit pulls the line low
577
578 All channels are implicitly always in OUTPUT mode -- but when
579 they are high they can be considered to be in INPUT mode..
580
581 Thus, we only force channels low if the config request was INPUT,
582 otherwise we do nothing to the hardware. */
583
584 switch (data[0]) {
585 case INSN_CONFIG_DIO_OUTPUT:
586 /* save to io_bits -- don't actually do anything since
587 all input channels are also output channels... */
588 s->io_bits |= 1 << chan;
589 break;
590 case INSN_CONFIG_DIO_INPUT:
591 /* write a 0 to the actual register representing the channel
592 to set it to 'input'. 0 means "float high". */
593 byte = inb(ioaddr);
594 byte &= ~(1 << bit_no);
595 /**< set input channel to '0' */
596
597 /* write out byte -- this is the only time we actually affect the
598 hardware as all channels are implicitly output -- but input
599 channels are set to float-high */
600 outb(byte, ioaddr);
601
602 /* save to io_bits */
603 s->io_bits &= ~(1 << chan);
604 break;
605
606 case INSN_CONFIG_DIO_QUERY:
607 /* retreive from shadow register */
608 data[1] =
609 (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
610 return insn->n;
611 break;
612
613 default:
614 return -EINVAL;
615 break;
616 }
617
618 return insn->n;
619 }
620
621 static void init_asics(struct comedi_device *dev)
622 { /* sets up an
623 ASIC chip to defaults */
624 int asic;
625
626 for (asic = 0; asic < thisboard->num_asics; ++asic) {
627 int port, page;
628 unsigned long baseaddr = dev->iobase + asic * ASIC_IOSIZE;
629
630 switch_page(dev, asic, 0); /* switch back to page 0 */
631
632 /* first, clear all the DIO port bits */
633 for (port = 0; port < PORTS_PER_ASIC; ++port)
634 outb(0, baseaddr + REG_PORT0 + port);
635
636 /* Next, clear all the paged registers for each page */
637 for (page = 1; page < NUM_PAGES; ++page) {
638 int reg;
639 /* now clear all the paged registers */
640 switch_page(dev, asic, page);
641 for (reg = FIRST_PAGED_REG;
642 reg < FIRST_PAGED_REG + NUM_PAGED_REGS; ++reg)
643 outb(0, baseaddr + reg);
644 }
645
646 /* DEBUG set rising edge interrupts on port0 of both asics */
647 /*switch_page(dev, asic, PAGE_POL);
648 outb(0xff, baseaddr + REG_POL0);
649 switch_page(dev, asic, PAGE_ENAB);
650 outb(0xff, baseaddr + REG_ENAB0); */
651 /* END DEBUG */
652
653 switch_page(dev, asic, 0); /* switch back to default page 0 */
654
655 }
656 }
657
658 static void switch_page(struct comedi_device *dev, int asic, int page)
659 {
660 if (asic < 0 || asic >= thisboard->num_asics)
661 return; /* paranoia */
662 if (page < 0 || page >= NUM_PAGES)
663 return; /* more paranoia */
664
665 devpriv->asics[asic].pagelock &= ~REG_PAGE_MASK;
666 devpriv->asics[asic].pagelock |= page << REG_PAGE_BITOFFSET;
667
668 /* now write out the shadow register */
669 outb(devpriv->asics[asic].pagelock,
670 dev->iobase + ASIC_IOSIZE * asic + REG_PAGELOCK);
671 }
672
673 #ifdef notused
674 static void lock_port(struct comedi_device *dev, int asic, int port)
675 {
676 if (asic < 0 || asic >= thisboard->num_asics)
677 return; /* paranoia */
678 if (port < 0 || port >= PORTS_PER_ASIC)
679 return; /* more paranoia */
680
681 devpriv->asics[asic].pagelock |= 0x1 << port;
682 /* now write out the shadow register */
683 outb(devpriv->asics[asic].pagelock,
684 dev->iobase + ASIC_IOSIZE * asic + REG_PAGELOCK);
685 }
686
687 static void unlock_port(struct comedi_device *dev, int asic, int port)
688 {
689 if (asic < 0 || asic >= thisboard->num_asics)
690 return; /* paranoia */
691 if (port < 0 || port >= PORTS_PER_ASIC)
692 return; /* more paranoia */
693 devpriv->asics[asic].pagelock &= ~(0x1 << port) | REG_LOCK_MASK;
694 /* now write out the shadow register */
695 outb(devpriv->asics[asic].pagelock,
696 dev->iobase + ASIC_IOSIZE * asic + REG_PAGELOCK);
697 }
698 #endif /* notused */
699
700 static irqreturn_t interrupt_pcmuio(int irq, void *d)
701 {
702 int asic, got1 = 0;
703 struct comedi_device *dev = (struct comedi_device *)d;
704
705 for (asic = 0; asic < MAX_ASICS; ++asic) {
706 if (irq == devpriv->asics[asic].irq) {
707 unsigned long flags;
708 unsigned triggered = 0;
709 unsigned long iobase = devpriv->asics[asic].iobase;
710 /* it is an interrupt for ASIC #asic */
711 unsigned char int_pend;
712
713 spin_lock_irqsave(&devpriv->asics[asic].spinlock,
714 flags);
715
716 int_pend = inb(iobase + REG_INT_PENDING) & 0x07;
717
718 if (int_pend) {
719 int port;
720 for (port = 0; port < INTR_PORTS_PER_ASIC;
721 ++port) {
722 if (int_pend & (0x1 << port)) {
723 unsigned char
724 io_lines_with_edges = 0;
725 switch_page(dev, asic,
726 PAGE_INT_ID);
727 io_lines_with_edges =
728 inb(iobase +
729 REG_INT_ID0 + port);
730
731 if (io_lines_with_edges)
732 /* clear pending interrupt */
733 outb(0, iobase +
734 REG_INT_ID0 +
735 port);
736
737 triggered |=
738 io_lines_with_edges <<
739 port * 8;
740 }
741 }
742
743 ++got1;
744 }
745
746 spin_unlock_irqrestore(&devpriv->asics[asic].spinlock,
747 flags);
748
749 if (triggered) {
750 struct comedi_subdevice *s;
751 /* TODO here: dispatch io lines to subdevs with commands.. */
752 printk
753 ("PCMUIO DEBUG: got edge detect interrupt %d asic %d which_chans: %06x\n",
754 irq, asic, triggered);
755 for (s = dev->subdevices;
756 s < dev->subdevices + dev->n_subdevices;
757 ++s) {
758 if (subpriv->intr.asic == asic) { /* this is an interrupt subdev, and it matches this asic! */
759 unsigned long flags;
760 unsigned oldevents;
761
762 spin_lock_irqsave(&subpriv->
763 intr.spinlock,
764 flags);
765
766 oldevents = s->async->events;
767
768 if (subpriv->intr.active) {
769 unsigned mytrig =
770 ((triggered >>
771 subpriv->intr.asic_chan)
772 &
773 ((0x1 << subpriv->
774 intr.
775 num_asic_chans) -
776 1)) << subpriv->
777 intr.first_chan;
778 if (mytrig &
779 subpriv->intr.enabled_mask)
780 {
781 unsigned int val
782 = 0;
783 unsigned int n,
784 ch, len;
785
786 len =
787 s->
788 async->cmd.chanlist_len;
789 for (n = 0;
790 n < len;
791 n++) {
792 ch = CR_CHAN(s->async->cmd.chanlist[n]);
793 if (mytrig & (1U << ch)) {
794 val |= (1U << n);
795 }
796 }
797 /* Write the scan to the buffer. */
798 if (comedi_buf_put(s->async, ((short *)&val)[0])
799 &&
800 comedi_buf_put
801 (s->async,
802 ((short *)
803 &val)[1]))
804 {
805 s->async->events |= (COMEDI_CB_BLOCK | COMEDI_CB_EOS);
806 } else {
807 /* Overflow! Stop acquisition!! */
808 /* TODO: STOP_ACQUISITION_CALL_HERE!! */
809 pcmuio_stop_intr
810 (dev,
811 s);
812 }
813
814 /* Check for end of acquisition. */
815 if (!subpriv->intr.continuous) {
816 /* stop_src == TRIG_COUNT */
817 if (subpriv->intr.stop_count > 0) {
818 subpriv->intr.stop_count--;
819 if (subpriv->intr.stop_count == 0) {
820 s->async->events |= COMEDI_CB_EOA;
821 /* TODO: STOP_ACQUISITION_CALL_HERE!! */
822 pcmuio_stop_intr
823 (dev,
824 s);
825 }
826 }
827 }
828 }
829 }
830
831 spin_unlock_irqrestore
832 (&subpriv->intr.spinlock,
833 flags);
834
835 if (oldevents !=
836 s->async->events) {
837 comedi_event(dev, s);
838 }
839
840 }
841
842 }
843 }
844
845 }
846 }
847 if (!got1)
848 return IRQ_NONE; /* interrupt from other source */
849 return IRQ_HANDLED;
850 }
851
852 static void pcmuio_stop_intr(struct comedi_device *dev,
853 struct comedi_subdevice *s)
854 {
855 int nports, firstport, asic, port;
856
857 asic = subpriv->intr.asic;
858 if (asic < 0)
859 return; /* not an interrupt subdev */
860
861 subpriv->intr.enabled_mask = 0;
862 subpriv->intr.active = 0;
863 s->async->inttrig = 0;
864 nports = subpriv->intr.num_asic_chans / CHANS_PER_PORT;
865 firstport = subpriv->intr.asic_chan / CHANS_PER_PORT;
866 switch_page(dev, asic, PAGE_ENAB);
867 for (port = firstport; port < firstport + nports; ++port) {
868 /* disable all intrs for this subdev.. */
869 outb(0, devpriv->asics[asic].iobase + REG_ENAB0 + port);
870 }
871 }
872
873 static int pcmuio_start_intr(struct comedi_device *dev,
874 struct comedi_subdevice *s)
875 {
876 if (!subpriv->intr.continuous && subpriv->intr.stop_count == 0) {
877 /* An empty acquisition! */
878 s->async->events |= COMEDI_CB_EOA;
879 subpriv->intr.active = 0;
880 return 1;
881 } else {
882 unsigned bits = 0, pol_bits = 0, n;
883 int nports, firstport, asic, port;
884 struct comedi_cmd *cmd = &s->async->cmd;
885
886 asic = subpriv->intr.asic;
887 if (asic < 0)
888 return 1; /* not an interrupt
889 subdev */
890 subpriv->intr.enabled_mask = 0;
891 subpriv->intr.active = 1;
892 nports = subpriv->intr.num_asic_chans / CHANS_PER_PORT;
893 firstport = subpriv->intr.asic_chan / CHANS_PER_PORT;
894 if (cmd->chanlist) {
895 for (n = 0; n < cmd->chanlist_len; n++) {
896 bits |= (1U << CR_CHAN(cmd->chanlist[n]));
897 pol_bits |= (CR_AREF(cmd->chanlist[n])
898 || CR_RANGE(cmd->
899 chanlist[n]) ? 1U : 0U)
900 << CR_CHAN(cmd->chanlist[n]);
901 }
902 }
903 bits &= ((0x1 << subpriv->intr.num_asic_chans) -
904 1) << subpriv->intr.first_chan;
905 subpriv->intr.enabled_mask = bits;
906
907 switch_page(dev, asic, PAGE_ENAB);
908 for (port = firstport; port < firstport + nports; ++port) {
909 unsigned enab =
910 bits >> (subpriv->intr.first_chan + (port -
911 firstport) *
912 8) & 0xff, pol =
913 pol_bits >> (subpriv->intr.first_chan +
914 (port - firstport) * 8) & 0xff;
915 /* set enab intrs for this subdev.. */
916 outb(enab,
917 devpriv->asics[asic].iobase + REG_ENAB0 + port);
918 switch_page(dev, asic, PAGE_POL);
919 outb(pol,
920 devpriv->asics[asic].iobase + REG_ENAB0 + port);
921 }
922 }
923 return 0;
924 }
925
926 static int pcmuio_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
927 {
928 unsigned long flags;
929
930 spin_lock_irqsave(&subpriv->intr.spinlock, flags);
931 if (subpriv->intr.active)
932 pcmuio_stop_intr(dev, s);
933 spin_unlock_irqrestore(&subpriv->intr.spinlock, flags);
934
935 return 0;
936 }
937
938 /*
939 * Internal trigger function to start acquisition for an 'INTERRUPT' subdevice.
940 */
941 static int
942 pcmuio_inttrig_start_intr(struct comedi_device *dev, struct comedi_subdevice *s,
943 unsigned int trignum)
944 {
945 unsigned long flags;
946 int event = 0;
947
948 if (trignum != 0)
949 return -EINVAL;
950
951 spin_lock_irqsave(&subpriv->intr.spinlock, flags);
952 s->async->inttrig = 0;
953 if (subpriv->intr.active) {
954 event = pcmuio_start_intr(dev, s);
955 }
956 spin_unlock_irqrestore(&subpriv->intr.spinlock, flags);
957
958 if (event) {
959 comedi_event(dev, s);
960 }
961
962 return 1;
963 }
964
965 /*
966 * 'do_cmd' function for an 'INTERRUPT' subdevice.
967 */
968 static int pcmuio_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
969 {
970 struct comedi_cmd *cmd = &s->async->cmd;
971 unsigned long flags;
972 int event = 0;
973
974 spin_lock_irqsave(&subpriv->intr.spinlock, flags);
975 subpriv->intr.active = 1;
976
977 /* Set up end of acquisition. */
978 switch (cmd->stop_src) {
979 case TRIG_COUNT:
980 subpriv->intr.continuous = 0;
981 subpriv->intr.stop_count = cmd->stop_arg;
982 break;
983 default:
984 /* TRIG_NONE */
985 subpriv->intr.continuous = 1;
986 subpriv->intr.stop_count = 0;
987 break;
988 }
989
990 /* Set up start of acquisition. */
991 switch (cmd->start_src) {
992 case TRIG_INT:
993 s->async->inttrig = pcmuio_inttrig_start_intr;
994 break;
995 default:
996 /* TRIG_NOW */
997 event = pcmuio_start_intr(dev, s);
998 break;
999 }
1000 spin_unlock_irqrestore(&subpriv->intr.spinlock, flags);
1001
1002 if (event) {
1003 comedi_event(dev, s);
1004 }
1005
1006 return 0;
1007 }
1008
1009 static int
1010 pcmuio_cmdtest(struct comedi_device *dev, struct comedi_subdevice *s,
1011 struct comedi_cmd *cmd)
1012 {
1013 return comedi_pcm_cmdtest(dev, s, cmd);
1014 }
1015
1016 /*
1017 * A convenient macro that defines init_module() and cleanup_module(),
1018 * as necessary.
1019 */
1020 COMEDI_INITCLEANUP(driver);
Linux ARM platform port for MOXA ART SoC