librtd-dm7520.c

rt 7520采集卡 linux驱动源代码

GetDIO0Mask7520(int board, uint8_t *mask_p) {
    int		err;
    uint32	dummy;

    /*
     * Target register is the Mask Register
     */

    err = SelectDIO0Register7520(board, 2);
    RETERR;

    err = dm7520_readreg(board, LAS0, LAS0_DIO0_CTRL, &dummy);
    if (err == 0) {
	*mask_p = (uint8_t) (dummy & 0xFF);
    }

    return err;
}


int
GetDIO1Direction7520(int board, uint8_t *direction_p) {
    int err;
    int reg;

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &reg);
    if (err == 0) {
	*direction_p = ((reg & 0x04) >> 2);
    }

    return err;
}


int
GetDIOStatus7520(int board, uint8_t *status_p) {
    int		err;
    uint32	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &dummy);
    if (err == 0) {
	*status_p = (uint8_t) (dummy & 0xFF);
    }

    return err;
}


int
GetErrorCode7520(int board, int *code) {
    dm7520_request	req;
    int			ret;

    req.las = 0;
    req.addr = 0;
    req.data = 0;
    ret = ioctl(board, DM7520IOCGETECODE, &req);
    if (ret == 0) {
	*code = req.data;
    }

    return ret;
}


int
GetFifoStatus7520(int board, uint16_t *status_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_ADC, &dummy);
    if (err == 0) {

	/*
	 * Make sure bits 3, 7, 11, and 15 are set to 0; the hardware is
	 * supposed to do this also
	 */

	*status_p = (uint16_t) (dummy & 0x7777);
    }

    return err;
}


int
GetITStatus7520(int board, uint16_t *status_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_IT, &dummy);
    if (err == 0) {
	*status_p = (uint16_t) (dummy & 0xFFFF);
    }

    return err;
}


int
GetTimerStatus7520(int board, uint16_t *status_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_TIMER, &dummy);
    if (err == 0) {

	/*
	 * Make sure bits 6 through 15 are set to 0
	 */

	*status_p = (uint16_t) (dummy & 0x3F);
    }

    return err;
}


int
GetUcnt1Count7520(int board, uint16_t *count_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_DAC1_UCNT, &dummy);
    if (err == 0) {
	*count_p = (uint16_t) (dummy & 0x0000FFFF);
    }

    return err;
}


int
GetUcnt2Count7520(int board, uint16_t *count_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_DAC2_UCNT, &dummy);
    if (err == 0) {
	*count_p = (uint16_t) (dummy & 0x0000FFFF);
    }

    return err;
}


int
InitBoard7520(int board) {
    int	err;

    err = ClearAllIO7520(board);
    RETERR;

    err = ClearADFifo7520(board);
    RETERR;

    err = ClearDAC1Fifo7520(board);
    RETERR;

    err = ClearDAC2Fifo7520(board);
    RETERR;

    err = ClearDinFifo7520(board);
    RETERR;

    err = ClearCGT7520(board);
    RETERR;

    err = ClearDIO7520(board);
    RETERR;

    return ClearDIO0IrqStatus7520(board);
}


int
IsADFifoEmpty7520(int board, uint8_t *empty_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*empty_p = (0 == (fifo_status & FS_ADC_EMPTY));
    }

    return status;
}


int
IsADFifoFull7520(int board, uint8_t *full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*full_p = (0 == (fifo_status & FS_ADC_FULL));
    }

    return status;
}


int
IsADFifoHalfFull7520(int board, uint8_t *half_full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*half_full_p = (0 == (fifo_status & FS_ADC_HEMPTY));
    }

    return status;
}


int
IsBusMaster7520(int board, uint8_t *bus_master_p) {
    int		err;
    uint32_t	dummy;
   
    err = dm7520_readreg(board, LAS0, LAS0_MT_MODE, &dummy);
    if (err == 0) {
	*bus_master_p = (1 == (dummy & 0x1));
    }

    return err;
}


int
IsDAC1FifoEmpty7520(int board, uint8_t *empty_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*empty_p = (0 == (fifo_status & FS_DAC1_EMPTY));
    }

    return status;
}


int
IsDAC1FifoFull7520(int board, uint8_t *full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*full_p = (0 == (fifo_status & FS_DAC1_FULL));
    }

    return status;
}


int
IsDAC1FifoHalfFull7520(int board, uint8_t *half_full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*half_full_p = (0 == (fifo_status & FS_DAC1_HEMPTY));
    }

    return status;
}


int
IsDAC2FifoEmpty7520(int board, uint8_t *empty_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*empty_p = (0 == (fifo_status & FS_DAC2_EMPTY));
    }

    return status;
}


int
IsDAC2FifoFull7520(int board, uint8_t *full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*full_p = (0 == (fifo_status & FS_DAC2_FULL));
    }

    return status;
}


int
IsDAC2FifoHalfFull7520(int board, uint8_t *half_full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*half_full_p = (0 == (fifo_status & FS_DAC2_HEMPTY));
    }

    return status;
}


int
IsDINFifoEmpty7520(int board, uint8_t *empty_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*empty_p = (0 == (fifo_status & FS_DIN_EMPTY));
    }

    return status;
}


int
IsDINFifoFull7520(int board, uint8_t *full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*full_p = (0 == (fifo_status & FS_DIN_FULL));
    }

    return status;
}


int
IsDINFifoHalfFull7520(int board, uint8_t *half_full_p) {
    int		status;
    uint16_t	fifo_status;

    status = GetFifoStatus7520(board, &fifo_status);
    if (status == 0) {
	*half_full_p = (0 == (fifo_status & FS_DIN_HEMPTY));
    }

    return status;
}


int
LoadAcnt7520(int board, uint16_t num_samples) {
    return dm7520_writereg(board, LAS0, LAS0_ACNT, num_samples - 1);
}


int
LoadAdcnt7520(int board, uint16_t num_samples) {
    return dm7520_writereg(board, LAS0, LAS0_ADC_SCNT, num_samples);
}


int
LoadDAC17520(int board, int value) {
    return dm7520_writereg(
	board, LAS1, LAS1_DAC1_FIFO, (uint16_t) (value << 3)
    );
}


int
LoadDAC27520(int board, int value) {
    return dm7520_writereg(
	board, LAS1, LAS1_DAC2_FIFO, (uint16_t) (value << 3)
    );
}


int
LoadDcnt7520(int board, uint16_t divisor) {
    return dm7520_writereg(board, LAS0, LAS0_DCNT, divisor);
}


int
LoadUcnt17520(int board, uint16_t divisor) {
    return dm7520_writereg(board, LAS0, LAS0_DAC1_UCNT, divisor);
}


int
LoadUcnt27520(int board, uint16_t divisor) {
    return dm7520_writereg(board, LAS0, LAS0_DAC2_UCNT, divisor);
}


int
McBSPADControl7520(int board, int enable) {
    unsigned char	ad_send;

    /*
     * Start out assuming A/D FIFO data send to McBSP will be disabled
     */

    ad_send = 0;

    if (enable) {
	ad_send = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_MCBSP_AD_CTRL, ad_send);
}


int
McBSPDAControl7520(int board, int enable) {
    unsigned char	mcbsp_write;

    /*
     * Start out assuming McBSP data write to D/A 1 and D/A 2 FIFOs will be
     * disabled
     */

    mcbsp_write = 0;

    if (enable) {
	mcbsp_write = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_MCBSP_DA_CTRL, mcbsp_write);
}


int
PollDIO07520(
    int board,
    int *direction,
    int *mask,
    int *mode,
    int *compare,
    int *clock,
    int *irq,
    int *itstatus
) {
    int		err;
    uint8_t	bit_direction;
    uint8_t	compare_register;
    uint8_t	dio_status;
    uint8_t	interrupt_mask;

    err = GetDIO0Direction7520(board, &bit_direction);
    RETERR;

    err = GetDIO0Mask7520(board, &interrupt_mask);
    RETERR;

    err = GetDIO0CompareValue7520(board, &compare_register);
    RETERR;

    err = GetDIOStatus7520(board, &dio_status);
    if (err == 0) {
	*direction = bit_direction;
	*mask = interrupt_mask;
	*mode = ((dio_status >> 3) & 0x1);
	*compare = compare_register;
	*clock = ((dio_status >> 5) & 0x1);
	*irq = ((dio_status >> 4) & 0x1);
	*itstatus = ((dio_status >> 6) & 0x1);
    }

    return err;
}


int
ReadADData7520(int board, int16_t *data_p) {
    int		err;
    uint32_t	sample;

    err = dm7520_readreg(board, LAS1, LAS1_ADC_FIFO, &sample);
    if (err == 0) {
	*data_p = ((int16_t) (sample & 0x0000FFFF) >> 3);
    }

    return err;
}


int
ReadADDataWithMarker7520(int board, int16_t *data_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS1, LAS1_ADC_FIFO, &dummy);
    if (err == 0) {
	*data_p = (int16_t) (dummy & 0x0000FFFF);
    }

    return err;
}


int
ReadData7520(int board, int16_t *buffer, int num_samples) {
    dm7520_read_request	readreq;
    int			ret;

    mlock(buffer, (num_samples * sizeof(int16_t)));
    readreq.pBuf = buffer;
    readreq.size = num_samples;
    ret = ioctl(board, DM7520IOCREAD, &readreq);
    munlock(buffer, (num_samples * sizeof(int16_t)));
    return ret;
}


int
ReadDinFifo7520(int board, uint16_t *data_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS1, LAS1_HDIO_FIFO, &dummy);
    if (err == 0) {
	*data_p = (uint16_t) (dummy & 0x0000FFFF);
    }

    return err;
}


int
ReadDIO07520(int board, uint8_t *data_p) {
    int		err;
    uint32	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_DIO0, &dummy);
    if (err == 0) {
	*data_p = (uint8_t) (dummy & 0x000000FF);
    }

    return err;
}


int
ReadDIO17520(int board, uint8_t *data_p) {
    int		err;
    uint32	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_DIO1, &dummy);
    if (err == 0) {
	*data_p = (uint8_t) (dummy & 0x000000FF);
    }

    return err;
}


int
ReadPacer7520(int board, uint32_t *value_p) {
    int		err;
    uint32_t	dummy;

    err = dm7520_readreg(board, LAS0, LAS0_PCLK, &dummy);
    if (err == 0) {
	*value_p = (dummy & 0x00FFFFFF);
    }

    return err;
}


int
ReadSampleCounter7520(int board, int counter, uint16_t *value_p) {
    int		err;
    uint16_t	counter_value;

    switch (counter) {
	case TC_ADC_SCNT:
	    err = GetAdcntCount7520(board, &counter_value);
	    break;

	case TC_DAC1_UCNT:
	    err = GetUcnt1Count7520(board, &counter_value);
	    break;

	case TC_DAC2_UCNT:
	    err = GetUcnt2Count7520(board, &counter_value);
	    break;

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

    if (err == 0) {
	*value_p = counter_value;
    }

    return err;
}


int
ReadTimerCounter7520(int board, int counter, int *mode, uint16_t *count) {
    int		err;
    uint16_t	tc_count;
    uint8_t	tc_mode;

    err = Get8254Count7520(board, counter, &tc_count);
    RETERR;

    err = Get8254Mode7520(board, counter, &tc_mode);
    RETERR;

    *mode = tc_mode;
    *count = tc_count;
    return 0;
}


int
ReadUserInput7520(int board, uint16_t *value_p) {
    uint32_t	dummy;
    int		err;

    err = dm7520_readreg(board, LAS0, LAS0_USER_IO, &dummy);
    if (err == 0) {
	*value_p = (uint16_t) (dummy & 0x3);
    }

    return err;
}


int
ResetCGT7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_CGT_RESET, NO_ARG);
}


int
ResetDAC1Fifo7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC1_RESET, NO_ARG);
}


int
ResetDAC2Fifo7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC2_RESET, NO_ARG);
}


int
SelectBurstClockPrimaryClock7520(int board, uint16_t clock) {
    return dm7520_writereg(board, LAS0, LAS0_BURST_CLK_SRC_SEL, clock);
}


int
SelectDACClockPrimaryClock7520(int board, uint16_t clock) {
    return dm7520_writereg(board, LAS0, LAS0_DAC_CLK_SRC_SEL, clock);
}


int
SelectDIO0Register7520(int board, int aReg) {
    int	err;
    int	reg;

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

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

    /*
     * Zero out bits 0 and 1, keeping bits 2 through 7 intact
     */

    reg &= ~0x03;

    /*
     * Set bits 0 and 1 according to caller's wishes
     */

    reg |= (aReg & 0x03);
    return dm7520_writereg(board, LAS0, LAS0_DIO_STATUS, reg);
}


int
SelectPacerClockPrimaryClock7520(int board, uint16_t clock) {
    return dm7520_writereg(board, LAS0, LAS0_PACER_CLK_SRC_SEL, clock);
}


int
Set8254Divisor7520(int board, int counter, uint16_t divisor) {
    int			err;
    int			reg;
    unsigned char	LSB = (divisor & 0x00FF);
    unsigned char	MSB = (divisor &0xFF00) >> 8;

    switch (counter) {
	case TC_UTC0:
	    reg = LAS0_UTC0;
	    break;

	case TC_UTC1:
	    reg = LAS0_UTC1;
	    break;

	case TC_UTC2:
	    reg = LAS0_UTC2;
	    break;

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

    err = dm7520_writereg(board, LAS0, reg, LSB);
    RETERR;

    return dm7520_writereg(board, LAS0, reg, MSB);
}


int
Set8254Mode7520(int board, int counter, int mode) {
    uint32_t	cntr;