librtd-dm7520.c

rt 7520采集卡 linux驱动源代码

    switch (counter) {
	case TC_UTC0:
	    cntr = 0;
	    break;

	case TC_UTC1:
	    cntr = 1;
	    break;

	case TC_UTC2:
	    cntr = 2;
	    break;

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

    /*
     * The 0x30 below sets read/load to least significant byte first then
     * most significant byte
     */

    return dm7520_writereg(
	board, LAS0, LAS0_UTC_CTRL, ((cntr << 6) | (mode << 1) | 0x30)
    );
}


int
SetAdcntSource7520(int board, uint16_t src) {
    return dm7520_writereg(board, LAS0, LAS0_ADC_SCNT_SRC, src);
}


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

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

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

    req.data = 0;
    req.addr = dmach;
    req.las = DM7520_READ_AD;
    return ioctl(board, DM7520IOCSETDMA, &req);
}


int
SetBurstRate7520(int board, float rate) {
    float	actualRate;

    return SetBurstRateF7520(board, rate, 0, &actualRate);
}


int
SetBurstRateF7520(int board, float rate, uint16_t clock, float *pActualRate) {
    int		err;
    uint32_t	divisor;
    uint32_t	primeClock;

    switch (clock) {
	case 0:
	    primeClock = 8000000L;
	    break;

	case 1:
	    primeClock = 20000000L;
	    break;

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

    if (rate > 1250000L) {
	errno = EINVAL;
	return -1;
    }

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

    err = SelectBurstClockPrimaryClock7520(board, clock);
    RETERR;

    divisor = (uint32_t) (primeClock / rate);
    err = dm7520_writereg(board, LAS0, LAS0_BCLK, (divisor - 1));
    if (err == 0) {
	*pActualRate = ((float) primeClock) / divisor;
    }

    return err;
}


int
SetBurstStart7520(int board, uint16_t src) {
    return dm7520_writereg(board, LAS0, LAS0_BURST_START, src);
}


int
SetChannelGain7520(
    int board,
    uint16_t Channel,
    uint16_t Gain,
    uint16_t Range,
    uint16_t Se_Diff,
    uint16_t NrSe
) {
    int		err;
    cg_entry_t	cscRow;

    err = SetupCgtRow7520(
	&cscRow, Channel, Gain, Range, NrSe, Se_Diff, 0, 0, 0, 0
    );
    RETERR;

    return WriteCGTLatch7520(board, *((uint16_t *) &cscRow));
}


int
SetConversionSelect7520(int board, uint16_t src) {
    return dm7520_writereg(board, LAS0, LAS0_ADC_CONVERSION, src);
}


int
SetDAC1Cycle7520(int board, uint16_t cycle) {
    unsigned char	dac_cycle;

    /*
     * Start out assuming cycle mode will be disabled
     */

    dac_cycle = 0;

    if (cycle) {
	dac_cycle = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_DAC1_CYCLE, dac_cycle);
}


int
SetDAC1Range7520(int board, uint16_t rng) {
    return dm7520_writereg(board, LAS0, LAS0_DAC1_CTRL, rng);
}


int
SetDAC1Start7520(int board, uint16_t src) {
    return dm7520_writereg(board, LAS0, LAS0_DAC1_SRC, src);
}


int
SetDAC2Cycle7520(int board, uint16_t cycle) {
    unsigned char	dac_cycle;

    /*
     * Start out assuming cycle mode will be disabled
     */

    dac_cycle = 0;

    if (cycle) {
	dac_cycle = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_DAC2_CYCLE, dac_cycle);
}


int
SetDAC2Range7520(int board, uint16_t rng) {
    return dm7520_writereg(board, LAS0, LAS0_DAC2_CTRL, rng);
}


int
SetDAC2Start7520(int board, uint16_t src) {
    return dm7520_writereg(board, LAS0, LAS0_DAC2_SRC, src);
}


int
SetDACDivisor7520(int board, uint32 divisor) {
    if (divisor > 0x0000FFFF) {
	errno = EINVAL;
	return -1;
    }

    return dm7520_writereg(board, LAS0, LAS0_DAC_CLK, divisor);
}

int
SetDACRate7520(int board, float rate) {
    float	actualRate;

    return SetDACRateF7520(board, rate, 0, &actualRate);
}


int
SetDACRateF7520(int board, float rate, uint16_t clock, float *pActualRate) {
    int		err = 0;
    uint32_t	divisor;
    uint32_t	primeClock;

    switch (clock) {
	case 0:
            primeClock = 8000000L;
	    break;

	case 1:
	    primeClock = 20000000L;
	    break;

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

    if (rate > 2000000L) {
	errno = EINVAL;
	return -1;
    }

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

    err = SelectDACClockPrimaryClock7520(board, clock);
    RETERR;

    divisor = (uint32_t) (primeClock / rate);
    err = dm7520_writereg(board, LAS0, LAS0_DAC_CLK, (divisor - 1));
    if (err == 0) {
	*pActualRate = ((float) primeClock) / divisor;
    }

    return err;
}


int
setDA_DMA7520(
    int board,
    short channel,
    short dmach,
    int16_t **newbuffer,
    size_t size
) {
    dm7520_request	req;
    int			err;

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

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

    switch (channel) {
	case DM7520_WRITE_DA1:
	case DM7520_WRITE_DA2:
	    break;

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

    if (size <= 0) {
	errno = EINVAL;
	return -1;
    }

    req.las = channel;
    req.addr = dmach;
    req.data = size;
    err = ioctl(board, DM7520IOCSETDMA, &req);
    RETERR;

    *newbuffer = (int16_t *) mmap(
	NULL, size, (PROT_READ | PROT_WRITE), MAP_PRIVATE, board, 0
    );
    if ((MAP_FAILED == *newbuffer) || (NULL == *newbuffer)) {
	return -1;
    }

    return 0; 
}


int
SetDIO0Clock7520(int board, int src) {
    int	err;
    int	reg;

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

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

    /*
     * Read the Digital IRQ/Strobe Status Register because we do not want to
     * disturb the settings of bits 0 through 4 and 6 and 7
     */

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &reg);
    RETERR;

    /*
     * Zero out bit 5, keeping all other bits intact
     */

    reg &= ~0x20;

    /*
     * Set bit 5 according to caller's wishes
     */

    reg |= (src << 5);
    return dm7520_writereg(board, LAS0, LAS0_DIO_STATUS, reg);
}


int
SetDIO0CompareMode7520(int board, int mode) {
    int	reg;
    int	err;

    switch (mode) {
	case DIO_MODE_EVENT:
	case DIO_MODE_MATCH:
	    break;

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

    /*
     * Read the Digital IRQ/Strobe Status Register because we do not want to
     * disturb the settings of bits 0 through 2 and 4 through 7
     */

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &reg);
    RETERR;

    /*
     * Zero out bit 3, keeping all other bits intact
     */

    reg &= ~0x08;

    /*
     * Set bit 3 according to caller's wishes
     */

    reg |= (mode << 3);
    return dm7520_writereg(board, LAS0, LAS0_DIO_STATUS, reg);
}


int
SetDIO0CompareValue7520(int board, int compare) {
    int	err;

    /*
     * Target register is the Compare Register
     */

    err = SelectDIO0Register7520(board, 3);
    RETERR;

    return dm7520_writereg(board, LAS0, LAS0_DIO0_CTRL, compare);
}


int
SetDIO0Direction7520(int board, int direction) {
    int	err;

    /*
     * Target register is the Direction Register
     */

    err = SelectDIO0Register7520(board, 1);
    RETERR;

    return dm7520_writereg(board, LAS0, LAS0_DIO0_CTRL, direction);
}


int
SetDIO0Mask7520(int board, int mask) {
    int	err;

    /*
     * Target register is the Mask Register
     */

    err = SelectDIO0Register7520(board, 2);
    RETERR;

    return dm7520_writereg(board, LAS0, LAS0_DIO0_CTRL, mask);
}


int
SetDIO1Direction7520(int board, int direction) {
    int	err;
    int	reg;

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

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

    /*
     * Read the Digital IRQ/Strobe Status Register because we do not want to
     * disturb the settings of bits 0, 1, and 3 through 7
     */

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &reg);
    RETERR;

    /*
     * Zero out bit 2, keeping all other bits intact
     */

    reg &= ~0x04;

    /*
     * Set bit 2 according to caller's wishes
     */

    reg |= (direction << 2);
    return dm7520_writereg(board, LAS0, LAS0_DIO_STATUS, reg);
}


int
SetEintPolarity7520(int board, uint16_t polarity) {
    switch (polarity) {
	case EINT_POL_POSITIVE:
	case EINT_POL_NEGATIVE:
	    break;

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

    return dm7520_writereg(board, LAS0, LAS0_EINT_POLARITY, polarity);
}


int
SetEtrgPolarity7520(int board, uint16_t polarity) {
    switch (polarity) {
	case ETRG_POL_POSITIVE:
	case ETRG_POL_NEGATIVE:
	    break;

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

    return dm7520_writereg(board, LAS0, LAS0_ETRG_POLARITY, polarity);
}


int
SetHD_DMAMode7520(int board, int dmach) {
    dm7520_request	req;
    int			err;
    int			fifosize;

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

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

    err = SetUtc1Clock7520(board, CUTC1_DIN_SIGNAL);
    RETERR;

    err = dm7520_getFifoSize(board, &fifosize);
    RETERR;

    err = SetUtc1Gate7520(board, GUTC1_NOT_GATED);
    RETERR;

    err = Set8254Mode7520(board, TC_UTC1, M8254_RATE_GENERATOR);
    RETERR;

    err = Set8254Divisor7520(board, TC_UTC1, fifosize / 2);
    RETERR;

    req.data = 0;
    req.addr = dmach;
    req.las = DM7520_READ_HD;
    return ioctl(board, DM7520IOCSETDMA, &req);
}


int
SetHdinStart7520(int board, uint16_t src) {
    switch (src) {
	case HDIN_SOFTWARE:
	case HDIN_ADC:
	case HDIN_UTC0:
	case HDIN_UTC1:
	case HDIN_UTC2:
	case HDIN_EPCLK:
	case HDIN_ETRG:
	    break;

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

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


int
SetITMask7520(int board, uint16_t mask) {
    return dm7520_writereg(board, LAS0, LAS0_IT, mask);
}


int
SetNotification7520(int board, unsigned short irqsrc, void (*userfunc)(void)) {
    unsigned int	flags;

    switch (irqsrc) {
	case IRQS_ADC_FIFO_WRITE:
	case IRQS_CGT_RESET:
	case IRQS_CGT_PAUSE:
	case IRQS_ADC_ABOUT_CNT:
	case IRQS_ADC_DELAY_CNT:
	case IRQS_ADC_SCNT:
	case IRQS_DAC1_UCNT:
	case IRQS_DAC2_UCNT:
	case IRQS_UTC1:
	case IRQS_UTC1_INV:
	case IRQS_UTC2:
	case IRQS_DIGITAL_IT:
	case IRQS_EXTERNAL_IT:
	case IRQS_ETRIG_RISING:
	case IRQS_ETRIG_FALLING:
	    break;

	case IRQS_RESERVED:
	    errno = EOPNOTSUPP;
	    return -1;
	    break;

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

    if (userfunc == NULL) {
	errno = EINVAL;
	return -1;
    }

    if (signal(SIGIO, async_wrapper) == SIG_ERR) {
	return -1;
    }

    if (SetITMask7520(board, (1 << irqsrc)) == -1) {
	return -1;
    }

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

    user_callback = userfunc;
    flags = fcntl(board, F_GETFL);
    flags |= FASYNC;
    return fcntl(board, F_SETFL, flags);
}


int
SetPacerClock7520(
    int board,
    uint16_t start,
    uint16_t stop,
    uint16_t repeat,
    uint16_t src,
    float rate
) {
    float actualRate;

    return SetPacerClockF7520(
	board, start, stop, repeat, src, rate, 0, &actualRate
    );
}


int
SetPacerClockF7520(
    int board,
    uint16_t start,
    uint16_t stop,
    uint16_t repeat,
    uint16_t src,
    float rate,
    uint16_t clock,
    float *pActualRate
) {
    int	err;

    err = SetPacerStart7520(board, start);
    RETERR;

    err = SetPacerStop7520(board, stop);
    RETERR;

    err = SetPacerRepeat7520(board, repeat);
    RETERR;

    err = SetPacerSource7520(board, src);
    RETERR;

    /*
     * SetPacerSource7520() validates the clock source, so it's OK to use it
     * here without further checking
     */

    if (src == PCLK_EXTERNAL) {
	return 0;
    }

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


int
SetPacerDivisor7520(int board, uint32 divisor) {
    int	err;

    if (divisor > 0x00FFFFFF) {
	errno = EINVAL;
	return -1;
    }

    err = dm7520_writereg(board, LAS0, LAS0_PCLK, divisor);
    RETERR;

    return SetPacerSource7520(board, PCLK_INTERNAL);
}


int
SetPacerRate7520(int board, float rate) {
    float	actualRate;

    return SetPacerRateF7520(board, rate, 0, &actualRate);
}


int
SetPacerRateF7520(int board, float rate, uint16_t clock, float *pActualRate) {
    int		err;
    uint32_t	divisor;
    uint32_t	primeClock;

    switch (clock) {
	case 0:
	    primeClock = 8000000L;
            break;

	case 1:
	    primeClock = 20000000L;
	    break;

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

    if (rate > 1250000L) {
	errno = EINVAL;