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