librtd-dm7520.c

rt 7520采集卡 linux驱动源代码

/*
	FILE NAME: librtd-dm7520.c

	FILE DESCRIPTION: DM7520 user level library source code

	PROJECT NAME: Linux DM7520 Driver, Library, and Example Programs

	PROJECT VERSION: (Defined in README.TXT)

	Copyright 2004 RTD Embedded Technologies, Inc.  All Rights Reserved.
*/

#include <errno.h>
#include <sys/ioctl.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <stdint.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>	//mlock

#include "dm7520.h"
#include <dm7520_library.h>

#ifdef __cplusplus

extern "C" {

#endif  // __cplusplus

#define FALSE	0
#define TRUE	1

#define RETERR	if (err < 0) {return(err);}

#define uint32 uint32_t

void (*user_callback)(void);


/*=============================================================================
Non-exported library functions
 =============================================================================*/


/******************************************************************************
async_wrapper()

    Purpose:
        Receive SIGIO signal from kernel and call user installed callback
        handler if one exists.  Also, reinstall the signal handler so that
        other SIGIO signals get handled.

    Parameters:
        sig => Signal number that was delivered.

    Return Value:
        None.
 ******************************************************************************/

static void
async_wrapper(int sig) {
    if (user_callback) {
	user_callback();
    }
    signal(SIGIO, async_wrapper);
}


/******************************************************************************
dm7520_readreg()

    Purpose:
        Read the contents of a register in one of a DM7520 device's address
        spaces.

    Parameters:
        descriptor ====> File descriptor of board.
        address_space => The device's address space to read from.  Valid values
                         are LAS0, LAS1, and LCFG.
        register_num ==> Register number to read.  Register numbers begin at
                         zero.
        data_p ========> Address where data read should be stored.  If
                         address_space is LAS1, then 16 bits are returned.
                         Otherwise, 32 bits are returned.

    Return Value:
        0
            Success.

        -1
            Failure with errno set as follows:
                EBUSY
                    The device file referred to by descriptor was not opened.

                EINVAL
                    address_space is not valid.

                ENXIO
                    The minor number of the device file referred to by
                    descriptor is greater than the number of DM7520 devices
                    supported.

                ENXIO
                    The device referred to by descriptor was not configured,
                    failed its configuration, or is not present.
 ******************************************************************************/

static int
dm7520_readreg(
    int descriptor,
    unsigned short address_space,
    short register_num,
    unsigned int *data_p
) {
    dm7520_request	req;
    int			ret;

    req.las = address_space;
    req.addr = register_num;
    req.data = 0;
    ret = ioctl(descriptor, DM7520IOCGETREG, &req); 
    if (ret == 0) {
	*data_p = req.data;
    }
    return ret;
}


/******************************************************************************
dm7520_writereg()

    Purpose:
        Write data to a register in one of a DM7520 device's address spaces.

    Parameters:
        descriptor ====> File descriptor of board.
        address_space => The device's address space to write to.  Valid values
                         are LAS0, LAS1, and LCFG.
        register_num ==> Register number to write.  Register numbers begin at
                         zero.
        data ==========> The data to write.  If address_space is LAS1, then
                         16 bits are written.  Otherwise, 32 bits are written.

    Return Value:
        0
            Success.

        -1
            Failure with errno set as follows:
                EBUSY
                    The device file referred to by descriptor was not opened.

                EINVAL
                    address_space is not valid.

                ENXIO
                    The minor number of the device file referred to by
                    descriptor is greater than the number of DM7520 devices
                    supported.

                ENXIO
                    The device referred to by descriptor was not configured,
                    failed its configuration, or is not present.
 ******************************************************************************/


static int
dm7520_writereg(
    int descriptor,
    unsigned short address_space,
    short register_num,
    unsigned int data
) {
    dm7520_request	req;

    req.las = address_space;
    req.addr = register_num;
    req.data = data;
    return ioctl(descriptor, DM7520IOCSETREG, &req);
}


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


/*=============================================================================
Exported library functions
 =============================================================================*/


int
ClearADFifo7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_ADC_FIFO_CLEAR, NO_ARG);
}


int
ClearAllIO7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_BOARD_RESET, NO_ARG);
}


int
ClearCGT7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_CGT_CLEAR, NO_ARG);
}


int
ClearDAC1Fifo7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC1_FIFO_CLEAR, NO_ARG);
}


int
ClearDAC2Fifo7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC2_FIFO_CLEAR, NO_ARG);
}


int
ClearDinFifo7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DIN_FIFO_CLEAR, NO_ARG);
}


int
ClearDIO0IrqStatus7520(int board) {
    int	dummy;
    int	err;

    /*
     * Target register is the Clear Register
     */

    err = SelectDIO0Register7520(board, 0);
    RETERR;

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


int
ClearDIO7520(int board) {
    int	err;

    /*
     * Target register is the Clear Register
     */

    err = dm7520_writereg(board, LAS0, LAS0_DIO_STATUS, 0);
    RETERR;

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


int
ClearErrorCode7520(int board) {
    return ioctl(board, DM7520IOCCLEARECODE);
}


int
DACClockFreeRun7520(int board, int runmode) {
    unsigned char	da_clock_mode;

    /*
     * Start out assuming D/A clock will be free running
     */

    da_clock_mode = 0;

    if (runmode) {
	da_clock_mode = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_DAC_CLK_MODE, da_clock_mode);
}


int
DACClockStart7520(int board) {
    int	dummy;

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


int
DACClockStartSelect7520(int board, int data) {
    return dm7520_writereg(board, LAS0, LAS0_DAC_CLK_START, data);
}


int
DACClockStop7520(int board) {
    return dm7520_writereg(board, LAS0, LAS0_DAC_CLK_ST, 0);
}


int
DACClockStopSelect7520(int board, int data) {
    return dm7520_writereg(board, LAS0, LAS0_DAC_CLK_STOP, data);
}


int
dm7520_getFifoSize(int board, int *fifosize) {
    dm7520_request	req;
    int			ret;

    ret = ioctl(board, DM7520IOCGETFIFOSIZE, &req);

    if (ret == 0) {
	*fifosize = req.data;
    }

    return ret;
}


int
EnableAcntStop7520(int board, uint16_t enable) {
    unsigned char	about_stop;

    /*
     * Start out assuming About Counter stop will be enabled
     */

    about_stop = 0;

    if (enable) {
	about_stop = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_ACNT_STOP_ENABLE, about_stop);
}


int
EnableCGT7520(int board, uint16_t enable) {
    return dm7520_writereg(board, LAS0, LAS0_CG_CONTROL, enable);
}


int
EnableCGTDigital7520(int board, uint16_t enable) {
    unsigned char	digital_table;

    /*
     * Start out assuming digital table will be disabled
     */

    digital_table = 0;

    if (enable) {
	digital_table = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_CG_ENABLE, digital_table);
}


int
EnableCGTPause7520(int board, uint16_t enable) {
    unsigned char	pause_bit;

    /*
     * Start out assuming pause bit will be disabled
     */

    pause_bit = 0;

    if (enable) {
	pause_bit = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_CGT_PAUSE, pause_bit);
}


int
EnableDIO0Irq7520(int board, int enable) {
    int	err;
    int	reg;

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

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

    /*
     * Start out assuming digital interrupts will be disabled
     */

    reg &= ~0x10;

    if (enable) {
	reg |= 0x10;
    }

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


int
EnableSbus07520(int board, uint16_t enable) {
    unsigned char	sbus0_enable;

    /*
     * Start out assuming SyncBus 0 signal will be disabled
     */

    sbus0_enable = 0;

    if (enable) {
	sbus0_enable = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_SBUS0_ENABLE, sbus0_enable);
}


int
EnableSbus17520(int board, uint16_t enable) {
    unsigned char	sbus1_enable;

    /*
     * Start out assuming SyncBus 1 signal will be disabled
     */

    sbus1_enable = 0;

    if (enable) {
	sbus1_enable = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_SBUS1_ENABLE, sbus1_enable);
}


int
EnableSbus27520(int board, uint16_t enable) {
    unsigned char	sbus2_enable;

    /*
     * Start out assuming SyncBus 2 signal will be disabled
     */

    sbus2_enable = 0;

    if (enable) {
	sbus2_enable = 1;
    }

    return dm7520_writereg(board, LAS0, LAS0_SBUS2_ENABLE, sbus2_enable);
}


int
Get8254Count7520(int board, int counter, uint16_t *value_p) {
    int		err;
    uint32	reg, cntr;
    uint32	LSB, MSB;

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

	case TC_UTC1:
	    reg = LAS0_UTC1;
	    cntr = 1;
	    break;

	case TC_UTC2:
	    reg = LAS0_UTC2;
	    cntr = 2;
	    break;

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

    err = dm7520_writereg(board, LAS0, LAS0_UTC_CTRL, (cntr << 6));
    RETERR;

    err = dm7520_writereg(board, LAS0, LAS0_UTC_CTRL, (cntr << 6));
    RETERR;

    usleep(1000);
    err = dm7520_readreg(board, LAS0, reg, &LSB);
    RETERR;

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

    LSB &= 0x000000FF;
    MSB &= 0x000000FF;

    *value_p = ((MSB << 8) | LSB);

    return 0;
}


int
Get8254Mode7520(int board, int counter, uint8_t *mode_p) {
    int		err;
    int		reg, cntr;
    uint32_t	LSB;

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

	case TC_UTC1:
	    reg = LAS0_UTC1;
	    cntr = 0x04;
	    break;

	case TC_UTC2:
	    reg = LAS0_UTC2;
	    cntr = 0x08;
	    break;

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

    err = dm7520_writereg(board, LAS0, LAS0_UTC_CTRL, (0xE0 | cntr));
    RETERR;

    usleep(1000);
    err = dm7520_readreg(board, LAS0, reg, &LSB);
    RETERR;

    LSB &= 0x000000FF;
    *mode_p = ((LSB >> 1) & 0x7);
    return 0;
}


int
Get8254Status7520(int board, int counter, uint8_t *status_p) {
    int		err;
    uint32	reg, cntr;
    uint32	LSB;

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

	case TC_UTC1:
	    reg = LAS0_UTC1;
	    cntr = 1;
	    break;

	case TC_UTC2:
	    reg = LAS0_UTC2;
	    cntr = 2;
	    break;

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

    err = dm7520_writereg(board, LAS0, LAS0_UTC_CTRL, 0xE0 + (1 << (cntr + 1)));
    RETERR;

    usleep(1000);
    err = dm7520_readreg(board, LAS0, reg, &LSB);
    RETERR;

    *status_p = (0xFF & LSB);
    return 0;
}


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

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

	/*
	 * Add one to the counter value because of the way the counter works,
	 * i.e. the value is one less than the number of samples.  For example,
	 * if the counter value is 9, then 10 samples remain to be converted.
	 */

	*value_p = ((dummy & 0x0000FFFF) + 1);
    }

    return err;
}


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

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

    return err;
}


int
get_control_buf7520(int board, char **controlBuffer) {
    int		err;

    err = ioctl(board, DM7520IOCPREPARECONTROL);
    RETERR;

    *controlBuffer = (char *) mmap(
	NULL,
	getpagesize(),
	(PROT_READ | PROT_WRITE),
	(MAP_PRIVATE | MAP_LOCKED),
	board,
	0
    );

    if ((MAP_FAILED == *controlBuffer) || (NULL == *controlBuffer)) {
	return -1;
    }

    return 0;
}


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

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

    return err;
}


int
GetDIO0Clock7520(int board, uint8_t *source_p) {
    int	err;
    int	sts;

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &sts);
    if (err == 0) {
	*source_p = ((sts >> 5) & 0x01);
    }

    return err;
}


int
GetDIO0CompareMode7520(int board, uint8_t *mode_p) {
    int	err;
    int	sts;

    err = dm7520_readreg(board, LAS0, LAS0_DIO_STATUS, &sts);
    if (err == 0) {
	*mode_p = ((sts >> 3) & 0x01); 
    }

    return err;
}


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

    /*
     * Target register is the Compare Register
     */

    err = SelectDIO0Register7520(board, 3);
    RETERR;

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

    return err;
}


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

    /*
     * Target register is the Direction Register
     */

    err = SelectDIO0Register7520(board, 1);
    RETERR;

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

    return err;
}


int