librtd-dm7520.c

rt 7520采集卡 linux驱动源代码

	return -1;
    }

    if (rate <= (float) (primeClock / 0x00FFFFFF)) {
	errno = EINVAL;
	return -1;
    }

    err = SelectPacerClockPrimaryClock7520(board, clock);
    RETERR;

    divisor = (uint32_t) (primeClock / rate);
    err = dm7520_writereg(board, LAS0, LAS0_PCLK, divisor - 1);
    RETERR;

    err = SetPacerSource7520(board, PCLK_INTERNAL);
    if (err == 0) {
	*pActualRate = ((float) primeClock) / divisor;
    }

    return err;
}


int
SetPacerRepeat7520(int board, uint16_t repeat) {
    switch (repeat) {
	case PCLK_NO_REPEAT:
	case PCLK_REPEAT:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_PACER_REPEAT, repeat);
}


int
SetPacerSource7520(int board, uint16_t src) {
    switch (src) {
	case PCLK_EXTERNAL:
	case PCLK_INTERNAL:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_PACER_SELECT, src);
}


int
SetPacerStart7520(int board, uint16_t src) {
    switch (src) {
	case PCLK_START_SOFTWARE:
	case PCLK_START_ETRIG:
	case PCLK_START_DIGITAL_IT:
	case PCLK_START_UTC2:
	case PCLK_START_SBUS0:
	case PCLK_START_SBUS1:
	case PCLK_START_SBUS2:
	case PCLK_START_D_SOFTWARE:
	case PCLK_START_D_ETRIG:
	case PCLK_START_D_DIGITAL_IT:
	case PCLK_START_D_UTC2:
	case PCLK_START_D_SBUS0:
	case PCLK_START_D_SBUS1:
	case PCLK_START_D_SBUS2:
	case PCLK_START_ETRIG_GATED:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_PACER_START, src);
}


int
SetPacerStop7520(int board, uint16_t src) {
    switch (src) {
	case PCLK_STOP_SOFTWARE:
	case PCLK_STOP_ETRIG:
	case PCLK_STOP_DIGITAL_IT:
	case PCLK_STOP_ACNT:
	case PCLK_STOP_UTC2:
	case PCLK_STOP_SBUS0:
	case PCLK_STOP_SBUS1:
	case PCLK_STOP_SBUS2:
	case PCLK_STOP_A_SOFTWARE:
	case PCLK_STOP_A_ETRIG:
	case PCLK_STOP_A_DIGITAL_IT:
	case PCLK_STOP_A_UTC2:
	case PCLK_STOP_A_SBUS0:
	case PCLK_STOP_A_SBUS1:
	case PCLK_STOP_A_SBUS2:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_PACER_STOP, src);
}


int
SetReadChannel7520(int board, int channel) {
    dm7520_request	req;

    req.data = channel;
    return ioctl(board, DM7520IOCSETRCHAN, &req);
}


int
SetSbus0Source7520(int board, uint16_t src) {
    switch (src) {
	case SBUS0_START_ADC_COMMAND:
	case SBUS0_PCLK:
	case SBUS0_BCLK:
	case SBUS0_CGT_DAC1_UPDATE:
	case SBUS0_ETRG:
	case SBUS0_START_DACS_COMMAND:
	case SBUS0_DAC_CLK:
	case SBUS0_UTC2:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_SBUS0_SRC, src);
}


int
SetSbus1Source7520(int board, uint16_t src) {
    switch (src) {
	case SBUS1_START_ADC_COMMAND:
	case SBUS1_PCLK:
	case SBUS1_BCLK:
	case SBUS1_CGT_DAC2_UPDATE:
	case SBUS1_ETRG:
	case SBUS1_START_DACS_COMMAND:
	case SBUS1_DAC_CLK:
	case SBUS1_UTC2:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_SBUS1_SRC, src);
}


int
SetSbus2Source7520(int board, uint16_t src) {
    switch (src) {
	case SBUS2_START_ADC_COMMAND:
	case SBUS2_START_PCLK_COMMAND:
	case SBUS2_STOP_PCLK_COMMAND:
	case SBUS2_UPDATE_DAC1_COMMAND:
	case SBUS2_UPDATE_DAC2_COMMAND:
	case SBUS2_EPCLK:
	case SBUS2_ETRG:
	case SBUS2_UTC2:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_SBUS2_SRC, src);
}


int
SetUout0Source7520(int board, uint16_t src) {
    switch (src) {
	case UOUT_ADC:
	case UOUT_DAC1:
	case UOUT_DAC2:
	case UOUT_SOFTWARE:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UOUT0_SELECT, src);
}


int
SetUout1Source7520(int board, uint16_t src) {
    switch (src) {
	case UOUT_ADC:
	case UOUT_DAC1:
	case UOUT_DAC2:
	case UOUT_SOFTWARE:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UOUT1_SELECT, src);
}


int
SetupAboutCounter7520(int board, uint16_t samples, uint16_t enable) {
    int	err;

    err = LoadAcnt7520(board, samples);
    RETERR;

    return EnableAcntStop7520(board, enable);
}


int
SetupBurst7520(int board, uint16_t start, float rate) {
    int	err;

    err = SetBurstStart7520(board, start);
    RETERR;

    return SetBurstRate7520(board, rate);
}


int
SetupBurstF7520(
    int board,
    uint16_t start,
    float rate,
    uint16_t clock,
    float *pActualRate
) {
    int	err;

    err = SetBurstStart7520(board, start);
    RETERR;

    return SetBurstRateF7520(board, rate, clock, pActualRate);
}


int SetupCgtRow7520
(
    cg_entry_t *cscRow,
    int aChannel,
    int aGain,
    int aRange,
    int aNRSE,
    int aGround,
    int aPause,
    int aDAC1,
    int aDAC2,
    int aSkip
) {
    memset(cscRow, 0, sizeof(*cscRow));
    cscRow->channel = aChannel;
    cscRow->gain = aGain;
    cscRow->range = aRange;
    cscRow->nrse = aNRSE;
    cscRow->ground = aGround;
    cscRow->pause = aPause;
    cscRow->dac1 = aDAC1;
    cscRow->dac2 = aDAC2;
    cscRow->skip = aSkip;
    cscRow->reserved = 0;

    return(0);
}


int
SetupDAC7520(
    int board,
    int channel,
    uint16_t rng,
    uint16_t cycle,
    uint16_t src
) {
    int	err;

    switch (channel) {
	case DM7520_WRITE_DA1:
	    err = SetDAC1Range7520(board, rng);
	    RETERR;

	    err = SetDAC1Start7520(board, src);
	    RETERR;

	    err = SetDAC1Cycle7520(board, cycle);
	    break;

	case DM7520_WRITE_DA2:
	    err = SetDAC2Range7520(board, rng);
	    RETERR;

	    err = SetDAC2Start7520(board, src);
	    RETERR;

	    err = SetDAC2Cycle7520(board, cycle);
	    break;

	default:
	    errno = EINVAL;
	    err = -1;
	    break;
    }

    return err;
}


int
SetupDelayCounter7520(int board, uint16_t samples) {
    return LoadDcnt7520(board, samples);
}


int
SetupPort07520(
    int board,
    int direction,
    int mask,
    int mode,
    int compare,
    int clock,
    int irq
) {
    int	err;

    err = SetDIO0Direction7520(board, direction);
    RETERR;

    err = SetDIO0Mask7520(board, mask);
    RETERR;

    err = SetDIO0CompareMode7520(board, mode);
    RETERR;

    err = SetDIO0CompareValue7520(board, compare);
    RETERR;

    err = SetDIO0Clock7520(board, clock);
    RETERR;

    return EnableDIO0Irq7520(board, irq);
}


int
SetupSampleCounter7520(
    int board,
    int counter,
    uint16_t source,
    uint16_t divisor
) {
    int	err;

    switch (counter) {
	case TC_ADC_SCNT:
	    err = SetAdcntSource7520(board, source);
	    RETERR;

	    err = LoadAdcnt7520(board, divisor);
	    break;

	case TC_DAC1_UCNT:
	    err = LoadUcnt17520(board, divisor);
	    break;

	case TC_DAC2_UCNT:
	    err = LoadUcnt27520(board, divisor);
	    break;

	default:
	    errno = EINVAL;
	    err = -1;
	    break;
    }

    return err;
}

int
SetupSbus7520(int board, int idx, uint16_t src, uint16_t enable) {
    int	err;

    switch (idx) {
	case 0:
	    err = SetSbus0Source7520(board, src);
	    RETERR;

	    err = EnableSbus07520(board, enable);
	    break;

	case 1:
	    err = SetSbus1Source7520(board, src);
	    RETERR;

	    err = EnableSbus17520(board, enable);
	    break;

	case 2:
	    err = SetSbus2Source7520(board, src);
	    RETERR;

	    err = EnableSbus27520(board, enable);
	    break;

	default:
	    errno = EINVAL;
	    err = -1;
	    break;
    }

    return err;
}


int
SetupTimerCounter7520(int board, int counter, int mode, uint16_t divisor) {
    int	err;

    err = Set8254Mode7520(board, counter, mode);
    RETERR;

    return Set8254Divisor7520(board, counter, divisor);
}


int
SetUtc0Clock7520(int board, uint16_t src) {
    switch (src) {
	case CUTC0_8MHZ:
	case CUTC0_EXT_TC_CLOCK1:
	case CUTC0_EXT_TC_CLOCK2:
	case CUTC0_EXT_PCLK:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UTC0_CLOCK, src);
}


int
SetUtc0Gate7520(int board, uint16_t src) {
    switch (src) {
	case GUTC0_NOT_GATED:
	case GUTC0_GATED:
	case GUTC0_EXT_TC_GATE1:
	case GUTC0_EXT_TC_GATE2:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UTC0_GATE, src);
}


int
SetUtc1Clock7520(int board, uint16_t src) {
    switch (src) {
	case CUTC1_8MHZ:
	case CUTC1_EXT_TC_CLOCK1:
	case CUTC1_EXT_TC_CLOCK2:
	case CUTC1_EXT_PCLK:
	case CUTC1_UTC0_OUT:
	case CUTC1_DIN_SIGNAL:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UTC1_CLOCK, src);
}


int
SetUtc1Gate7520(int board, uint16_t src) {
    switch (src) {
	case GUTC1_NOT_GATED:
	case GUTC1_GATED:
	case GUTC1_EXT_TC_GATE1:
	case GUTC1_EXT_TC_GATE2:
	case GUTC1_UTC0_OUT:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UTC1_GATE, src);
}


int
SetUtc2Clock7520(int board, uint16_t src) {
    switch (src) {
	case CUTC2_8MHZ:
	case CUTC2_EXT_TC_CLOCK1:
	case CUTC2_EXT_TC_CLOCK2:
	case CUTC2_EXT_PCLK:
	case CUTC2_UTC1_OUT:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    return dm7520_writereg(board, LAS0, LAS0_UTC2_CLOCK, src);
}

int
SetUtc2Gate7520(int board, uint16_t src) {
    switch (src) {
	case GUTC2_NOT_GATED:
	case GUTC2_GATED:
	case GUTC2_EXT_TC_GATE1:
	case GUTC2_EXT_TC_GATE2:
	case GUTC2_UTC1_OUT:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }
    return dm7520_writereg(board, LAS0, LAS0_UTC2_GATE, src);
}


int
setWriteBuffer7520(int board, short channel, short dmach, size_t size) {
    dm7520_request	req;

    switch (dmach) {
	case 0:
	case 1:
	    break;

	default:
	    errno = EINVAL;
	    return -1;
	    break;
    }

    req.las = channel;
    req.addr = dmach;
    req.data = size;
    return ioctl(board, DM7520IOCSETWRITEBUFFER, &req);
}


int
StartBurst7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_ADC, NO_ARG);
}


int
StartConversion7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_ADC, NO_ARG);
}


int
StartHdin7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_TIMER, NO_ARG);
}


int
StartPacer7520(int board) {
    uint32_t	dummy;

    return dm7520_readreg(board, LAS0, LAS0_PACER, &dummy);
}


int
StopPacer7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_PACER, NO_ARG);
}


int
UnSetDMAMode7520(int board, int dmach) {
    dm7520_request	req;

    /*
     * No need to validate dmach here as the driver does it for us
     */

    req.addr = dmach;
    return ioctl(board, DM7520IOCUNSETDDMA, &req);
}


int
UnSetNotification7520(int board) {
    unsigned int	flags;

    user_callback = NULL;
    if (signal(SIGIO, SIG_DFL) == SIG_ERR) {
	return -1;
    }

    if (fcntl(board, F_SETOWN, getpid()) == -1) {
	return -1;
    }

    flags = fcntl(board, F_GETFL);
    flags &= ~FASYNC;
    return fcntl(board, F_SETFL, flags);
}


int
UpdateAllDAC7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC, NO_ARG);
}


int
UpdateDAC17520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC1, NO_ARG);
}


int
UpdateDAC27520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC2, NO_ARG);
}


int
WriteCGTAnalog7520(int board, uint16_t entry) {
    return dm7520_writereg(board, LAS0, LAS0_CGT_WRITE, entry);
}


int
WriteCGTDigital7520(int board, unsigned char entry) {
    return dm7520_writereg(board, LAS0, LAS0_CG_DATA, entry);
}


int
WriteCGTLatch7520(int board, uint16_t entry) {
    return dm7520_writereg(board, LAS0, LAS0_CGL_WRITE, entry);
}


int
WriteDac1Fifo7520(int board, uint16_t value) {
    return dm7520_writereg(board, LAS1, LAS1_DAC1_FIFO, value);
}


int
WriteDac2Fifo7520(int board, uint16_t value) {
    return dm7520_writereg(board, LAS1, LAS1_DAC2_FIFO, value);
}


int
WriteDIO07520(int board, int value) {
    return dm7520_writereg(board, LAS0, LAS0_DIO0, value);
}


int
WriteDIO17520(int board, int value) {
    return dm7520_writereg(board, LAS0, LAS0_DIO1, value);
}


int
WriteUserOutput7520(int board, uint16_t data) {
    return dm7520_writereg(board, LAS0, LAS0_USER_IO, data);
}


/*=============================================================================
End of exported library functions
 =============================================================================*/


#ifdef __cplusplus

}

#endif