2 comedi/drivers/ni_pcidio.c
3 driver for National Instruments PCI-DIO-32HS
5 COMEDI - Linux Control and Measurement Device Interface
6 Copyright (C) 1999,2002 David A. Schleef <ds@schleef.org>
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.
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.
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.
25 Description: National Instruments PCI-DIO32HS, PCI-6533
28 Devices: [National Instruments] PCI-DIO-32HS (ni_pcidio)
29 [National Instruments] PXI-6533, PCI-6533 (pxi-6533)
30 [National Instruments] PCI-6534 (pci-6534)
31 Updated: Mon, 09 Jan 2012 14:27:23 +0000
33 The DIO32HS board appears as one subdevice, with 32 channels.
34 Each channel is individually I/O configurable. The channel order
35 is 0=A0, 1=A1, 2=A2, ... 8=B0, 16=C0, 24=D0. The driver only
36 supports simple digital I/O; no handshaking is supported.
38 DMA mostly works for the PCI-DIO32HS, but only in timed input mode.
40 The PCI-DIO-32HS/PCI-6533 has a configurable external trigger. Setting
41 scan_begin_arg to 0 or CR_EDGE triggers on the leading edge. Setting
42 scan_begin_arg to CR_INVERT or (CR_EDGE | CR_INVERT) triggers on the
45 This driver could be easily modified to support AT-MIO32HS and
48 The PCI-6534 requires a firmware upload after power-up to work, the
49 firmware data and instructions for loading it with comedi_config
50 it are contained in the
51 comedi_nonfree_firmware tarball available from http://www.comedi.org
56 /* #define DEBUG_FLAGS */
58 #include <linux/delay.h>
59 #include <linux/interrupt.h>
60 #include <linux/sched.h>
61 #include <linux/firmware.h>
63 #include "../comedidev.h"
65 #include "comedi_fc.h"
70 #define DPRINTK(format, args...) pr_debug(format, ## args)
72 #define DPRINTK(format, args...) do { } while (0)
75 #define PCI_DIO_SIZE 4096
76 #define PCI_MITE_SIZE 4096
78 /* defines for the PCI-DIO-32HS */
80 #define Window_Address 4 /* W */
81 #define Interrupt_And_Window_Status 4 /* R */
82 #define IntStatus1 (1<<0)
83 #define IntStatus2 (1<<1)
84 #define WindowAddressStatus_mask 0x7c
86 #define Master_DMA_And_Interrupt_Control 5 /* W */
87 #define InterruptLine(x) ((x)&3)
88 #define OpenInt (1<<2)
89 #define Group_Status 5 /* R */
90 #define DataLeft (1<<0)
92 #define StopTrig (1<<3)
94 #define Group_1_Flags 6 /* R */
95 #define Group_2_Flags 7 /* R */
96 #define TransferReady (1<<0)
97 #define CountExpired (1<<1)
99 #define PrimaryTC (1<<6)
100 #define SecondaryTC (1<<7)
101 /* #define SerialRose */
102 /* #define ReqRose */
105 #define Group_1_First_Clear 6 /* W */
106 #define Group_2_First_Clear 7 /* W */
107 #define ClearWaited (1<<3)
108 #define ClearPrimaryTC (1<<4)
109 #define ClearSecondaryTC (1<<5)
110 #define DMAReset (1<<6)
111 #define FIFOReset (1<<7)
112 #define ClearAll 0xf8
114 #define Group_1_FIFO 8 /* W */
115 #define Group_2_FIFO 12 /* W */
117 #define Transfer_Count 20
121 #define Chip_Version 27
122 #define Port_IO(x) (28+(x))
123 #define Port_Pin_Directions(x) (32+(x))
124 #define Port_Pin_Mask(x) (36+(x))
125 #define Port_Pin_Polarities(x) (40+(x))
127 #define Master_Clock_Routing 45
128 #define RTSIClocking(x) (((x)&3)<<4)
130 #define Group_1_Second_Clear 46 /* W */
131 #define Group_2_Second_Clear 47 /* W */
132 #define ClearExpired (1<<0)
134 #define Port_Pattern(x) (48+(x))
137 #define FIFOEnableA (1<<0)
138 #define FIFOEnableB (1<<1)
139 #define FIFOEnableC (1<<2)
140 #define FIFOEnableD (1<<3)
141 #define Funneling(x) (((x)&3)<<4)
142 #define GroupDirection (1<<7)
144 #define Protocol_Register_1 65
145 #define OpMode Protocol_Register_1
146 #define RunMode(x) ((x)&7)
147 #define Numbered (1<<3)
149 #define Protocol_Register_2 66
150 #define ClockReg Protocol_Register_2
151 #define ClockLine(x) (((x)&3)<<5)
152 #define InvertStopTrig (1<<7)
153 #define DataLatching(x) (((x)&3)<<5)
155 #define Protocol_Register_3 67
156 #define Sequence Protocol_Register_3
158 #define Protocol_Register_14 68 /* 16 bit */
159 #define ClockSpeed Protocol_Register_14
161 #define Protocol_Register_4 70
162 #define ReqReg Protocol_Register_4
163 #define ReqConditioning(x) (((x)&7)<<3)
165 #define Protocol_Register_5 71
166 #define BlockMode Protocol_Register_5
168 #define FIFO_Control 72
169 #define ReadyLevel(x) ((x)&7)
171 #define Protocol_Register_6 73
172 #define LinePolarities Protocol_Register_6
173 #define InvertAck (1<<0)
174 #define InvertReq (1<<1)
175 #define InvertClock (1<<2)
176 #define InvertSerial (1<<3)
177 #define OpenAck (1<<4)
178 #define OpenClock (1<<5)
180 #define Protocol_Register_7 74
181 #define AckSer Protocol_Register_7
182 #define AckLine(x) (((x)&3)<<2)
183 #define ExchangePins (1<<7)
185 #define Interrupt_Control 75
186 /* bits same as flags */
188 #define DMA_Line_Control_Group1 76
189 #define DMA_Line_Control_Group2 108
190 /* channel zero is none */
191 static inline unsigned primary_DMAChannel_bits(unsigned channel)
193 return channel & 0x3;
196 static inline unsigned secondary_DMAChannel_bits(unsigned channel)
198 return (channel << 2) & 0xc;
201 #define Transfer_Size_Control 77
202 #define TransferWidth(x) ((x)&3)
203 #define TransferLength(x) (((x)&3)<<3)
204 #define RequireRLevel (1<<5)
206 #define Protocol_Register_15 79
207 #define DAQOptions Protocol_Register_15
208 #define StartSource(x) ((x)&0x3)
209 #define InvertStart (1<<2)
210 #define StopSource(x) (((x)&0x3)<<3)
211 #define ReqStart (1<<6)
212 #define PreStart (1<<7)
214 #define Pattern_Detection 81
215 #define DetectionMethod (1<<0)
216 #define InvertMatch (1<<1)
217 #define IE_Pattern_Detection (1<<2)
219 #define Protocol_Register_9 82
220 #define ReqDelay Protocol_Register_9
222 #define Protocol_Register_10 83
223 #define ReqNotDelay Protocol_Register_10
225 #define Protocol_Register_11 84
226 #define AckDelay Protocol_Register_11
228 #define Protocol_Register_12 85
229 #define AckNotDelay Protocol_Register_12
231 #define Protocol_Register_13 86
232 #define Data1Delay Protocol_Register_13
234 #define Protocol_Register_8 88 /* 32 bit */
235 #define StartDelay Protocol_Register_8
237 /* Firmware files for PCI-6524 */
238 #define FW_PCI_6534_MAIN "ni6534a.bin"
239 #define FW_PCI_6534_SCARAB_DI "niscrb01.bin"
240 #define FW_PCI_6534_SCARAB_DO "niscrb02.bin"
241 MODULE_FIRMWARE(FW_PCI_6534_MAIN);
242 MODULE_FIRMWARE(FW_PCI_6534_SCARAB_DI);
243 MODULE_FIRMWARE(FW_PCI_6534_SCARAB_DO);
245 enum pci_6534_firmware_registers { /* 16 bit */
246 Firmware_Control_Register = 0x100,
247 Firmware_Status_Register = 0x104,
248 Firmware_Data_Register = 0x108,
249 Firmware_Mask_Register = 0x10c,
250 Firmware_Debug_Register = 0x110,
252 /* main fpga registers (32 bit)*/
253 enum pci_6534_fpga_registers {
254 FPGA_Control1_Register = 0x200,
255 FPGA_Control2_Register = 0x204,
256 FPGA_Irq_Mask_Register = 0x208,
257 FPGA_Status_Register = 0x20c,
258 FPGA_Signature_Register = 0x210,
259 FPGA_SCALS_Counter_Register = 0x280, /*write-clear */
260 FPGA_SCAMS_Counter_Register = 0x284, /*write-clear */
261 FPGA_SCBLS_Counter_Register = 0x288, /*write-clear */
262 FPGA_SCBMS_Counter_Register = 0x28c, /*write-clear */
263 FPGA_Temp_Control_Register = 0x2a0,
264 FPGA_DAR_Register = 0x2a8,
265 FPGA_ELC_Read_Register = 0x2b8,
266 FPGA_ELC_Write_Register = 0x2bc,
268 enum FPGA_Control_Bits {
269 FPGA_Enable_Bit = 0x8000,
272 #define TIMER_BASE 50 /* nanoseconds */
275 #define IntEn (CountExpired|Waited|PrimaryTC|SecondaryTC)
277 #define IntEn (TransferReady|CountExpired|Waited|PrimaryTC|SecondaryTC)
280 static int ni_pcidio_cancel(struct comedi_device *dev,
281 struct comedi_subdevice *s);
286 unsigned int uses_firmware:1;
289 static const struct nidio_board nidio_boards[] = {
292 .name = "pci-dio-32hs",
303 #define n_nidio_boards ARRAY_SIZE(nidio_boards)
304 #define this_board ((const struct nidio_board *)dev->board_ptr)
306 struct nidio96_private {
307 struct mite_struct *mite;
310 unsigned short OpModeBits;
311 struct mite_channel *di_mite_chan;
312 struct mite_dma_descriptor_ring *di_mite_ring;
313 spinlock_t mite_channel_lock;
316 static int ni_pcidio_cmdtest(struct comedi_device *dev,
317 struct comedi_subdevice *s,
318 struct comedi_cmd *cmd);
319 static int ni_pcidio_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
320 static int ni_pcidio_inttrig(struct comedi_device *dev,
321 struct comedi_subdevice *s, unsigned int trignum);
322 static int ni_pcidio_ns_to_timer(int *nanosec, int round_mode);
323 static int setup_mite_dma(struct comedi_device *dev,
324 struct comedi_subdevice *s);
327 static void ni_pcidio_print_flags(unsigned int flags);
328 static void ni_pcidio_print_status(unsigned int status);
330 #define ni_pcidio_print_flags(x)
331 #define ni_pcidio_print_status(x)
334 static int ni_pcidio_request_di_mite_channel(struct comedi_device *dev)
336 struct nidio96_private *devpriv = dev->private;
339 spin_lock_irqsave(&devpriv->mite_channel_lock, flags);
340 BUG_ON(devpriv->di_mite_chan);
341 devpriv->di_mite_chan =
342 mite_request_channel_in_range(devpriv->mite,
343 devpriv->di_mite_ring, 1, 2);
344 if (devpriv->di_mite_chan == NULL) {
345 spin_unlock_irqrestore(&devpriv->mite_channel_lock, flags);
346 comedi_error(dev, "failed to reserve mite dma channel.");
349 devpriv->di_mite_chan->dir = COMEDI_INPUT;
350 writeb(primary_DMAChannel_bits(devpriv->di_mite_chan->channel) |
351 secondary_DMAChannel_bits(devpriv->di_mite_chan->channel),
352 devpriv->mite->daq_io_addr + DMA_Line_Control_Group1);
354 spin_unlock_irqrestore(&devpriv->mite_channel_lock, flags);
358 static void ni_pcidio_release_di_mite_channel(struct comedi_device *dev)
360 struct nidio96_private *devpriv = dev->private;
363 spin_lock_irqsave(&devpriv->mite_channel_lock, flags);
364 if (devpriv->di_mite_chan) {
365 mite_dma_disarm(devpriv->di_mite_chan);
366 mite_dma_reset(devpriv->di_mite_chan);
367 mite_release_channel(devpriv->di_mite_chan);
368 devpriv->di_mite_chan = NULL;
369 writeb(primary_DMAChannel_bits(0) |
370 secondary_DMAChannel_bits(0),
371 devpriv->mite->daq_io_addr + DMA_Line_Control_Group1);
374 spin_unlock_irqrestore(&devpriv->mite_channel_lock, flags);
377 static void ni_pcidio_event(struct comedi_device *dev,
378 struct comedi_subdevice *s)
381 async->events & (COMEDI_CB_EOA | COMEDI_CB_ERROR |
382 COMEDI_CB_OVERFLOW)) {
383 ni_pcidio_cancel(dev, s);
385 comedi_event(dev, s);
388 static int ni_pcidio_poll(struct comedi_device *dev, struct comedi_subdevice *s)
390 struct nidio96_private *devpriv = dev->private;
391 unsigned long irq_flags;
394 spin_lock_irqsave(&dev->spinlock, irq_flags);
395 spin_lock(&devpriv->mite_channel_lock);
396 if (devpriv->di_mite_chan)
397 mite_sync_input_dma(devpriv->di_mite_chan, s->async);
398 spin_unlock(&devpriv->mite_channel_lock);
399 count = s->async->buf_write_count - s->async->buf_read_count;
400 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
404 static irqreturn_t nidio_interrupt(int irq, void *d)
406 struct comedi_device *dev = d;
407 struct nidio96_private *devpriv = dev->private;
408 struct comedi_subdevice *s = &dev->subdevices[0];
409 struct comedi_async *async = s->async;
410 struct mite_struct *mite = devpriv->mite;
413 long int AuxData = 0;
419 unsigned int m_status = 0;
421 /* interrupcions parasites */
422 if (dev->attached == 0) {
423 /* assume it's from another card */
427 /* Lock to avoid race with comedi_poll */
428 spin_lock(&dev->spinlock);
430 status = readb(devpriv->mite->daq_io_addr +
431 Interrupt_And_Window_Status);
432 flags = readb(devpriv->mite->daq_io_addr + Group_1_Flags);
434 DPRINTK("ni_pcidio_interrupt: status=0x%02x,flags=0x%02x\n",
436 ni_pcidio_print_flags(flags);
437 ni_pcidio_print_status(status);
439 spin_lock(&devpriv->mite_channel_lock);
440 if (devpriv->di_mite_chan)
441 m_status = mite_get_status(devpriv->di_mite_chan);
443 mite_print_chsr(m_status);
446 /* mite_dump_regs(mite); */
447 if (m_status & CHSR_INT) {
448 if (m_status & CHSR_LINKC) {
451 MITE_CHOR(devpriv->di_mite_chan->channel));
452 mite_sync_input_dma(devpriv->di_mite_chan, s->async);
453 /* XXX need to byteswap */
455 if (m_status & ~(CHSR_INT | CHSR_LINKC | CHSR_DONE | CHSR_DRDY |
456 CHSR_DRQ1 | CHSR_MRDY)) {
457 DPRINTK("unknown mite interrupt, disabling IRQ\n");
458 async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
459 disable_irq(dev->irq);
462 spin_unlock(&devpriv->mite_channel_lock);
464 while (status & DataLeft) {
467 DPRINTK("too much work in interrupt\n");
469 devpriv->mite->daq_io_addr +
470 Master_DMA_And_Interrupt_Control);
476 if (flags & TransferReady) {
477 /* DPRINTK("TransferReady\n"); */
478 while (flags & TransferReady) {
481 DPRINTK("too much work in interrupt\n");
483 devpriv->mite->daq_io_addr +
484 Master_DMA_And_Interrupt_Control
489 readl(devpriv->mite->daq_io_addr +
491 data1 = AuxData & 0xffff;
492 data2 = (AuxData & 0xffff0000) >> 16;
493 comedi_buf_put(async, data1);
494 comedi_buf_put(async, data2);
495 /* DPRINTK("read:%d, %d\n",data1,data2); */
496 flags = readb(devpriv->mite->daq_io_addr +
499 /* DPRINTK("buf_int_count: %d\n",
500 async->buf_int_count); */
501 /* DPRINTK("1) IntEn=%d,flags=%d,status=%d\n",
502 IntEn,flags,status); */
503 /* ni_pcidio_print_flags(flags); */
504 /* ni_pcidio_print_status(status); */
505 async->events |= COMEDI_CB_BLOCK;
508 if (flags & CountExpired) {
509 DPRINTK("CountExpired\n");
511 devpriv->mite->daq_io_addr +
512 Group_1_Second_Clear);
513 async->events |= COMEDI_CB_EOA;
515 writeb(0x00, devpriv->mite->daq_io_addr + OpMode);
517 } else if (flags & Waited) {
520 devpriv->mite->daq_io_addr +
521 Group_1_First_Clear);
522 async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
524 } else if (flags & PrimaryTC) {
525 DPRINTK("PrimaryTC\n");
526 writeb(ClearPrimaryTC,
527 devpriv->mite->daq_io_addr +
528 Group_1_First_Clear);
529 async->events |= COMEDI_CB_EOA;
530 } else if (flags & SecondaryTC) {
531 DPRINTK("SecondaryTC\n");
532 writeb(ClearSecondaryTC,
533 devpriv->mite->daq_io_addr +
534 Group_1_First_Clear);
535 async->events |= COMEDI_CB_EOA;
539 DPRINTK("ni_pcidio: unknown interrupt\n");
540 async->events |= COMEDI_CB_ERROR | COMEDI_CB_EOA;
542 devpriv->mite->daq_io_addr +
543 Master_DMA_And_Interrupt_Control);
546 flags = readb(devpriv->mite->daq_io_addr + Group_1_Flags);
547 status = readb(devpriv->mite->daq_io_addr +
548 Interrupt_And_Window_Status);
549 /* DPRINTK("loop end: IntEn=0x%02x,flags=0x%02x,"
550 "status=0x%02x\n", IntEn, flags, status); */
551 /* ni_pcidio_print_flags(flags); */
552 /* ni_pcidio_print_status(status); */
556 ni_pcidio_event(dev, s);
560 devpriv->mite->daq_io_addr +
561 Master_DMA_And_Interrupt_Control);
565 spin_unlock(&dev->spinlock);
570 static const char *bit_set_string(unsigned int bits, unsigned int bit,
571 const char *const strings[])
573 return (bits & (1U << bit)) ? strings[bit] : "";
576 static const char *const flags_strings[] = {
577 " TransferReady", " CountExpired", " 2", " 3",
578 " 4", " Waited", " PrimaryTC", " SecondaryTC",
582 static void ni_pcidio_print_flags(unsigned int flags)
584 pr_debug("group_1_flags:%s%s%s%s%s%s%s%s\n",
585 bit_set_string(flags, 7, flags_strings),
586 bit_set_string(flags, 6, flags_strings),
587 bit_set_string(flags, 5, flags_strings),
588 bit_set_string(flags, 4, flags_strings),
589 bit_set_string(flags, 3, flags_strings),
590 bit_set_string(flags, 2, flags_strings),
591 bit_set_string(flags, 1, flags_strings),
592 bit_set_string(flags, 0, flags_strings));
595 static const char *const status_strings[] = {
596 " DataLeft1", " Reserved1", " Req1", " StopTrig1",
597 " DataLeft2", " Reserved2", " Req2", " StopTrig2",
600 static void ni_pcidio_print_status(unsigned int flags)
602 pr_debug("group_status:%s%s%s%s%s%s%s%s\n",
603 bit_set_string(flags, 7, status_strings),
604 bit_set_string(flags, 6, status_strings),
605 bit_set_string(flags, 5, status_strings),
606 bit_set_string(flags, 4, status_strings),
607 bit_set_string(flags, 3, status_strings),
608 bit_set_string(flags, 2, status_strings),
609 bit_set_string(flags, 1, status_strings),
610 bit_set_string(flags, 0, status_strings));
615 static void debug_int(struct comedi_device *dev)
617 struct nidio96_private *devpriv = dev->private;
622 do_gettimeofday(&tv);
623 a = readb(devpriv->mite->daq_io_addr + Group_Status);
624 b = readb(devpriv->mite->daq_io_addr + Group_1_Flags);
627 DPRINTK("status 0x%02x flags 0x%02x time %06d\n", a, b,
632 writew(0xff, devpriv->mite->daq_io_addr + Group_1_FIFO);
633 b = readb(devpriv->mite->daq_io_addr + Group_1_Flags);
636 b = readb(devpriv->mite->daq_io_addr + Group_1_Flags);
639 DPRINTK("new status 0x%02x\n", b);
645 static int ni_pcidio_insn_config(struct comedi_device *dev,
646 struct comedi_subdevice *s,
647 struct comedi_insn *insn, unsigned int *data)
649 struct nidio96_private *devpriv = dev->private;
654 case INSN_CONFIG_DIO_OUTPUT:
655 s->io_bits |= 1 << CR_CHAN(insn->chanspec);
657 case INSN_CONFIG_DIO_INPUT:
658 s->io_bits &= ~(1 << CR_CHAN(insn->chanspec));
660 case INSN_CONFIG_DIO_QUERY:
663 io_bits & (1 << CR_CHAN(insn->chanspec))) ? COMEDI_OUTPUT :
670 writel(s->io_bits, devpriv->mite->daq_io_addr + Port_Pin_Directions(0));
675 static int ni_pcidio_insn_bits(struct comedi_device *dev,
676 struct comedi_subdevice *s,
677 struct comedi_insn *insn, unsigned int *data)
679 struct nidio96_private *devpriv = dev->private;
682 s->state &= ~data[0];
683 s->state |= (data[0] & data[1]);
684 writel(s->state, devpriv->mite->daq_io_addr + Port_IO(0));
686 data[1] = readl(devpriv->mite->daq_io_addr + Port_IO(0));
691 static int ni_pcidio_cmdtest(struct comedi_device *dev,
692 struct comedi_subdevice *s, struct comedi_cmd *cmd)
697 /* Step 1 : check if triggers are trivially valid */
699 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
700 err |= cfc_check_trigger_src(&cmd->scan_begin_src,
701 TRIG_TIMER | TRIG_EXT);
702 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
703 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
704 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
709 /* Step 2a : make sure trigger sources are unique */
711 err |= cfc_check_trigger_is_unique(cmd->start_src);
712 err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
713 err |= cfc_check_trigger_is_unique(cmd->stop_src);
715 /* Step 2b : and mutually compatible */
720 /* Step 3: check if arguments are trivially valid */
722 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
724 #define MAX_SPEED (TIMER_BASE) /* in nanoseconds */
726 if (cmd->scan_begin_src == TRIG_TIMER) {
727 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
729 /* no minimum speed */
732 /* should be level/edge, hi/lo specification here */
733 if ((cmd->scan_begin_arg & ~(CR_EDGE | CR_INVERT)) != 0) {
734 cmd->scan_begin_arg &= (CR_EDGE | CR_INVERT);
739 err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
740 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
742 if (cmd->stop_src == TRIG_COUNT) {
744 } else { /* TRIG_NONE */
745 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
751 /* step 4: fix up any arguments */
753 if (cmd->scan_begin_src == TRIG_TIMER) {
754 tmp = cmd->scan_begin_arg;
755 ni_pcidio_ns_to_timer(&cmd->scan_begin_arg,
756 cmd->flags & TRIG_ROUND_MASK);
757 if (tmp != cmd->scan_begin_arg)
767 static int ni_pcidio_ns_to_timer(int *nanosec, int round_mode)
773 switch (round_mode) {
774 case TRIG_ROUND_NEAREST:
776 divider = (*nanosec + base / 2) / base;
778 case TRIG_ROUND_DOWN:
779 divider = (*nanosec) / base;
782 divider = (*nanosec + base - 1) / base;
786 *nanosec = base * divider;
790 static int ni_pcidio_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
792 struct nidio96_private *devpriv = dev->private;
793 struct comedi_cmd *cmd = &s->async->cmd;
795 /* XXX configure ports for input */
796 writel(0x0000, devpriv->mite->daq_io_addr + Port_Pin_Directions(0));
799 /* enable fifos A B C D */
800 writeb(0x0f, devpriv->mite->daq_io_addr + Data_Path);
802 /* set transfer width a 32 bits */
803 writeb(TransferWidth(0) | TransferLength(0),
804 devpriv->mite->daq_io_addr + Transfer_Size_Control);
806 writeb(0x03, devpriv->mite->daq_io_addr + Data_Path);
807 writeb(TransferWidth(3) | TransferLength(0),
808 devpriv->mite->daq_io_addr + Transfer_Size_Control);
811 /* protocol configuration */
812 if (cmd->scan_begin_src == TRIG_TIMER) {
813 /* page 4-5, "input with internal REQs" */
814 writeb(0, devpriv->mite->daq_io_addr + OpMode);
815 writeb(0x00, devpriv->mite->daq_io_addr + ClockReg);
816 writeb(1, devpriv->mite->daq_io_addr + Sequence);
817 writeb(0x04, devpriv->mite->daq_io_addr + ReqReg);
818 writeb(4, devpriv->mite->daq_io_addr + BlockMode);
819 writeb(3, devpriv->mite->daq_io_addr + LinePolarities);
820 writeb(0xc0, devpriv->mite->daq_io_addr + AckSer);
821 writel(ni_pcidio_ns_to_timer(&cmd->scan_begin_arg,
823 devpriv->mite->daq_io_addr + StartDelay);
824 writeb(1, devpriv->mite->daq_io_addr + ReqDelay);
825 writeb(1, devpriv->mite->daq_io_addr + ReqNotDelay);
826 writeb(1, devpriv->mite->daq_io_addr + AckDelay);
827 writeb(0x0b, devpriv->mite->daq_io_addr + AckNotDelay);
828 writeb(0x01, devpriv->mite->daq_io_addr + Data1Delay);
829 /* manual, page 4-5: ClockSpeed comment is incorrectly listed
831 writew(0, devpriv->mite->daq_io_addr + ClockSpeed);
832 writeb(0, devpriv->mite->daq_io_addr + DAQOptions);
835 /* page 4-5, "input with external REQs" */
836 writeb(0, devpriv->mite->daq_io_addr + OpMode);
837 writeb(0x00, devpriv->mite->daq_io_addr + ClockReg);
838 writeb(0, devpriv->mite->daq_io_addr + Sequence);
839 writeb(0x00, devpriv->mite->daq_io_addr + ReqReg);
840 writeb(4, devpriv->mite->daq_io_addr + BlockMode);
841 if (!(cmd->scan_begin_arg & CR_INVERT)) {
842 /* Leading Edge pulse mode */
843 writeb(0, devpriv->mite->daq_io_addr + LinePolarities);
845 /* Trailing Edge pulse mode */
846 writeb(2, devpriv->mite->daq_io_addr + LinePolarities);
848 writeb(0x00, devpriv->mite->daq_io_addr + AckSer);
849 writel(1, devpriv->mite->daq_io_addr + StartDelay);
850 writeb(1, devpriv->mite->daq_io_addr + ReqDelay);
851 writeb(1, devpriv->mite->daq_io_addr + ReqNotDelay);
852 writeb(1, devpriv->mite->daq_io_addr + AckDelay);
853 writeb(0x0C, devpriv->mite->daq_io_addr + AckNotDelay);
854 writeb(0x10, devpriv->mite->daq_io_addr + Data1Delay);
855 writew(0, devpriv->mite->daq_io_addr + ClockSpeed);
856 writeb(0x60, devpriv->mite->daq_io_addr + DAQOptions);
859 if (cmd->stop_src == TRIG_COUNT) {
860 writel(cmd->stop_arg,
861 devpriv->mite->daq_io_addr + Transfer_Count);
867 writeb(ClearPrimaryTC | ClearSecondaryTC,
868 devpriv->mite->daq_io_addr + Group_1_First_Clear);
871 int retval = setup_mite_dma(dev, s);
876 writeb(0x00, devpriv->mite->daq_io_addr + DMA_Line_Control_Group1);
878 writeb(0x00, devpriv->mite->daq_io_addr + DMA_Line_Control_Group2);
880 /* clear and enable interrupts */
881 writeb(0xff, devpriv->mite->daq_io_addr + Group_1_First_Clear);
882 /* writeb(ClearExpired,
883 devpriv->mite->daq_io_addr+Group_1_Second_Clear); */
885 writeb(IntEn, devpriv->mite->daq_io_addr + Interrupt_Control);
887 devpriv->mite->daq_io_addr + Master_DMA_And_Interrupt_Control);
889 if (cmd->stop_src == TRIG_NONE) {
890 devpriv->OpModeBits = DataLatching(0) | RunMode(7);
891 } else { /* TRIG_TIMER */
892 devpriv->OpModeBits = Numbered | RunMode(7);
894 if (cmd->start_src == TRIG_NOW) {
896 writeb(devpriv->OpModeBits,
897 devpriv->mite->daq_io_addr + OpMode);
898 s->async->inttrig = NULL;
901 s->async->inttrig = ni_pcidio_inttrig;
904 DPRINTK("ni_pcidio: command started\n");
908 static int setup_mite_dma(struct comedi_device *dev, struct comedi_subdevice *s)
910 struct nidio96_private *devpriv = dev->private;
914 retval = ni_pcidio_request_di_mite_channel(dev);
918 /* write alloc the entire buffer */
919 comedi_buf_write_alloc(s->async, s->async->prealloc_bufsz);
921 spin_lock_irqsave(&devpriv->mite_channel_lock, flags);
922 if (devpriv->di_mite_chan) {
923 mite_prep_dma(devpriv->di_mite_chan, 32, 32);
924 mite_dma_arm(devpriv->di_mite_chan);
927 spin_unlock_irqrestore(&devpriv->mite_channel_lock, flags);
932 static int ni_pcidio_inttrig(struct comedi_device *dev,
933 struct comedi_subdevice *s, unsigned int trignum)
935 struct nidio96_private *devpriv = dev->private;
940 writeb(devpriv->OpModeBits, devpriv->mite->daq_io_addr + OpMode);
941 s->async->inttrig = NULL;
946 static int ni_pcidio_cancel(struct comedi_device *dev,
947 struct comedi_subdevice *s)
949 struct nidio96_private *devpriv = dev->private;
952 devpriv->mite->daq_io_addr + Master_DMA_And_Interrupt_Control);
953 ni_pcidio_release_di_mite_channel(dev);
958 static int ni_pcidio_change(struct comedi_device *dev,
959 struct comedi_subdevice *s, unsigned long new_size)
961 struct nidio96_private *devpriv = dev->private;
964 ret = mite_buf_change(devpriv->di_mite_ring, s->async);
968 memset(s->async->prealloc_buf, 0xaa, s->async->prealloc_bufsz);
973 static int pci_6534_load_fpga(struct comedi_device *dev, int fpga_index,
974 const u8 *data, size_t data_len)
976 struct nidio96_private *devpriv = dev->private;
977 static const int timeout = 1000;
981 writew(0x80 | fpga_index,
982 devpriv->mite->daq_io_addr + Firmware_Control_Register);
983 writew(0xc0 | fpga_index,
984 devpriv->mite->daq_io_addr + Firmware_Control_Register);
986 (readw(devpriv->mite->daq_io_addr +
987 Firmware_Status_Register) & 0x2) == 0 && i < timeout; ++i) {
991 dev_warn(dev->class_dev,
992 "ni_pcidio: failed to load fpga %i, waiting for status 0x2\n",
996 writew(0x80 | fpga_index,
997 devpriv->mite->daq_io_addr + Firmware_Control_Register);
999 readw(devpriv->mite->daq_io_addr + Firmware_Status_Register) !=
1000 0x3 && i < timeout; ++i) {
1004 dev_warn(dev->class_dev,
1005 "ni_pcidio: failed to load fpga %i, waiting for status 0x3\n",
1009 for (j = 0; j + 1 < data_len;) {
1010 unsigned int value = data[j++];
1011 value |= data[j++] << 8;
1013 devpriv->mite->daq_io_addr + Firmware_Data_Register);
1015 (readw(devpriv->mite->daq_io_addr +
1016 Firmware_Status_Register) & 0x2) == 0
1017 && i < timeout; ++i) {
1021 dev_warn(dev->class_dev,
1022 "ni_pcidio: failed to load word into fpga %i\n",
1029 writew(0x0, devpriv->mite->daq_io_addr + Firmware_Control_Register);
1033 static int pci_6534_reset_fpga(struct comedi_device *dev, int fpga_index)
1035 return pci_6534_load_fpga(dev, fpga_index, NULL, 0);
1038 static int pci_6534_reset_fpgas(struct comedi_device *dev)
1040 struct nidio96_private *devpriv = dev->private;
1044 writew(0x0, devpriv->mite->daq_io_addr + Firmware_Control_Register);
1045 for (i = 0; i < 3; ++i) {
1046 ret = pci_6534_reset_fpga(dev, i);
1050 writew(0x0, devpriv->mite->daq_io_addr + Firmware_Mask_Register);
1054 static void pci_6534_init_main_fpga(struct comedi_device *dev)
1056 struct nidio96_private *devpriv = dev->private;
1058 writel(0, devpriv->mite->daq_io_addr + FPGA_Control1_Register);
1059 writel(0, devpriv->mite->daq_io_addr + FPGA_Control2_Register);
1060 writel(0, devpriv->mite->daq_io_addr + FPGA_SCALS_Counter_Register);
1061 writel(0, devpriv->mite->daq_io_addr + FPGA_SCAMS_Counter_Register);
1062 writel(0, devpriv->mite->daq_io_addr + FPGA_SCBLS_Counter_Register);
1063 writel(0, devpriv->mite->daq_io_addr + FPGA_SCBMS_Counter_Register);
1066 static int pci_6534_upload_firmware(struct comedi_device *dev)
1068 struct nidio96_private *devpriv = dev->private;
1070 const struct firmware *fw;
1071 static const char *const fw_file[3] = {
1072 FW_PCI_6534_SCARAB_DI, /* loaded into scarab A for DI */
1073 FW_PCI_6534_SCARAB_DO, /* loaded into scarab B for DO */
1074 FW_PCI_6534_MAIN, /* loaded into main FPGA */
1078 ret = pci_6534_reset_fpgas(dev);
1081 /* load main FPGA first, then the two scarabs */
1082 for (n = 2; n >= 0; n--) {
1083 ret = request_firmware(&fw, fw_file[n],
1084 &devpriv->mite->pcidev->dev);
1086 ret = pci_6534_load_fpga(dev, n, fw->data, fw->size);
1087 if (ret == 0 && n == 2)
1088 pci_6534_init_main_fpga(dev);
1089 release_firmware(fw);
1097 static const struct nidio_board *
1098 nidio_find_boardinfo(struct pci_dev *pcidev)
1100 unsigned int dev_id = pcidev->device;
1103 for (n = 0; n < ARRAY_SIZE(nidio_boards); n++) {
1104 const struct nidio_board *board = &nidio_boards[n];
1105 if (board->dev_id == dev_id)
1111 static int nidio_auto_attach(struct comedi_device *dev,
1112 unsigned long context_unused)
1114 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1115 struct nidio96_private *devpriv;
1116 struct comedi_subdevice *s;
1120 devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
1123 dev->private = devpriv;
1125 spin_lock_init(&devpriv->mite_channel_lock);
1127 dev->board_ptr = nidio_find_boardinfo(pcidev);
1128 if (!dev->board_ptr)
1130 devpriv->mite = mite_alloc(pcidev);
1134 ret = mite_setup(devpriv->mite);
1136 dev_warn(dev->class_dev, "error setting up mite\n");
1140 devpriv->di_mite_ring = mite_alloc_ring(devpriv->mite);
1141 if (devpriv->di_mite_ring == NULL)
1144 dev->board_name = this_board->name;
1145 irq = mite_irq(devpriv->mite);
1146 if (this_board->uses_firmware) {
1147 ret = pci_6534_upload_firmware(dev);
1152 ret = comedi_alloc_subdevices(dev, 1);
1156 dev_info(dev->class_dev, "%s rev=%d\n", dev->board_name,
1157 readb(devpriv->mite->daq_io_addr + Chip_Version));
1159 s = &dev->subdevices[0];
1161 dev->read_subdev = s;
1162 s->type = COMEDI_SUBD_DIO;
1164 SDF_READABLE | SDF_WRITABLE | SDF_LSAMPL | SDF_PACKED |
1167 s->range_table = &range_digital;
1169 s->insn_config = &ni_pcidio_insn_config;
1170 s->insn_bits = &ni_pcidio_insn_bits;
1171 s->do_cmd = &ni_pcidio_cmd;
1172 s->do_cmdtest = &ni_pcidio_cmdtest;
1173 s->cancel = &ni_pcidio_cancel;
1174 s->len_chanlist = 32; /* XXX */
1175 s->buf_change = &ni_pcidio_change;
1176 s->async_dma_dir = DMA_BIDIRECTIONAL;
1177 s->poll = &ni_pcidio_poll;
1179 writel(0, devpriv->mite->daq_io_addr + Port_IO(0));
1180 writel(0, devpriv->mite->daq_io_addr + Port_Pin_Directions(0));
1181 writel(0, devpriv->mite->daq_io_addr + Port_Pin_Mask(0));
1183 /* disable interrupts on board */
1185 devpriv->mite->daq_io_addr +
1186 Master_DMA_And_Interrupt_Control);
1188 ret = request_irq(irq, nidio_interrupt, IRQF_SHARED,
1191 dev_warn(dev->class_dev, "irq not available\n");
1198 static void nidio_detach(struct comedi_device *dev)
1200 struct nidio96_private *devpriv = dev->private;
1203 free_irq(dev->irq, dev);
1205 if (devpriv->di_mite_ring) {
1206 mite_free_ring(devpriv->di_mite_ring);
1207 devpriv->di_mite_ring = NULL;
1209 if (devpriv->mite) {
1210 mite_unsetup(devpriv->mite);
1211 mite_free(devpriv->mite);
1216 static struct comedi_driver ni_pcidio_driver = {
1217 .driver_name = "ni_pcidio",
1218 .module = THIS_MODULE,
1219 .auto_attach = nidio_auto_attach,
1220 .detach = nidio_detach,
1223 static int ni_pcidio_pci_probe(struct pci_dev *dev,
1224 const struct pci_device_id *ent)
1226 return comedi_pci_auto_config(dev, &ni_pcidio_driver);
1229 static DEFINE_PCI_DEVICE_TABLE(ni_pcidio_pci_table) = {
1230 { PCI_DEVICE(PCI_VENDOR_ID_NI, 0x1150) },
1231 { PCI_DEVICE(PCI_VENDOR_ID_NI, 0x1320) },
1232 { PCI_DEVICE(PCI_VENDOR_ID_NI, 0x12b0) },
1235 MODULE_DEVICE_TABLE(pci, ni_pcidio_pci_table);
1237 static struct pci_driver ni_pcidio_pci_driver = {
1238 .name = "ni_pcidio",
1239 .id_table = ni_pcidio_pci_table,
1240 .probe = ni_pcidio_pci_probe,
1241 .remove = comedi_pci_auto_unconfig,
1243 module_comedi_pci_driver(ni_pcidio_driver, ni_pcidio_pci_driver);
1245 MODULE_AUTHOR("Comedi http://www.comedi.org");
1246 MODULE_DESCRIPTION("Comedi low-level driver");
1247 MODULE_LICENSE("GPL");