addaboardone.c

vxworks下adda板驱动原码

/* Included Files */
#include <vxWorks.h>
#include <logLib.h>
#include <iv.h>
#include <ioLib.h>
#include <iosLib.h>
#include <semLib.h>
#include <stdlib.h>
#include <stdio.h>
#include <sysLib.h>
#include <taskLib.h>
#include <vmeUniverse.h>
#include "../../../include/drv/addaBoard/Board.h"
#include "../../../include/drv/addaBoard/ppc6VmeIntVec.h"
#include "../../../include/drv/addaBoard/addaBoard.h"
#include "../../../include/drv/addaBoard/GC4016.h"
#include "../../../include/drv/addaBoard/GC4116.h"
#include "../../../include/drv/addaBoard/AD9777.h"
#include "../../../include/drv/addaBoard/AD9956.h"

/* define some macro */

/* Global Variables */
static int  DriverNumber = 0;    /* driver number specified by iosDrvInstall() */
static int  NumberOfDevices = 0; /* number of devices created */

/* Forward Declaration */
LOCAL int AddaBrdOpen(ADDABRD_DEV *pAddaBrdDev);
LOCAL int AddaBrdClose(ADDABRD_DEV *pAddaBrdDev);
LOCAL int AddaBrdRead(ADDABRD_DEV *pAddaBrdDev, char *pRevBuf, int iNum);
LOCAL int AddaBrdWrite(ADDABRD_DEV *pAddaBrdDev, char *pSrcBuf, int iNum);
LOCAL int AddaBrdIoctl (ADDABRD_DEV *pAddaBrdDev, int iFunCode, int iParam);
LOCAL void AddaBrdADCIntHandle(ADDABRD_DEV *pAddaBrdDev);
LOCAL void AddaBrdDACIntHandle(ADDABRD_DEV *pAddaBrdDev);
LOCAL void AddaBrdDMAIntHandle(ADDABRD_DEV *pAddaBrdDev);
LOCAL STATUS VmeBoardSearch (ADDABRD_DEV *pAddaBrdDev);
unsigned long vmeReadLong(int iVmeAddr);
void vmeWriteLong(int iVmeAddr, unsigned long ulData);
STATUS addaDDSRegWrite(ADDABRD_DEV *pAddaBrdDev, int iRegNum, int *pArray, int iList);
STATUS addaDDSRegRead(ADDABRD_DEV *pAddaBrdDev, int iRegNum, int *pArray, int iList);
STATUS addaDDSGlobalReset(ADDABRD_DEV *pAddaBrdDev);
STATUS addaDDSIOReset(ADDABRD_DEV *pAddaBrdDev);
STATUS addaDACRegWrite(ADDABRD_DEV *pAddaBrdDev, int iRegNum, unsigned long ulData, int iList);
STATUS addaDACRegRead(ADDABRD_DEV *pAddaBrdDev, int iRegNum, unsigned long *pRegData, int iList);

/******************************************************************************
TITLE:  	HFCtlDrv
DESC:   	setup routine of AD/DA VME board
PARAM:  	none
RETURN: 	DriverNumber   - driver number for AD/DA VME board's driver

NOTE:    the routine should run only one time.
******************************************************************************/
int AddaBrdDrv (void)
{
   if (DriverNumber > 0) 
      {
      return (DriverNumber);
      }
   DriverNumber = iosDrvInstall((FUNCPTR) NULL, (FUNCPTR) NULL,
                                 AddaBrdOpen, AddaBrdClose,
                                 AddaBrdRead, AddaBrdWrite,
                                 AddaBrdIoctl);
   return(DriverNumber);
}

/******************************************************************************
TITLE:  	AddaBrdCreate
DESC:   	device initialization of AD/DA VME board
PARAM:  	name        - device name
         pAddaBrdDev - pointer to ADDABRD_DEV device structure
RETURN: 	OK          - device initialize successfully
         ERROR       - device initialize failed with error
******************************************************************************/
int AddaBrdCreate (char *name, ADDABRD_DEV *pAddaBrdDev)
{
   int i;
   int iVmeIntVec = 0;
   int iStatus;
   int pRegData[2];
   unsigned long ulRegDataWr;

   VOIDFUNCPTR  pFuncPtr;

   if (DriverNumber <= 0)     /* driver not installed */
      {
      errnoSet(S_ioLib_NO_DRIVER);
      return(ERROR);
      }

   if (NumberOfDevices >= AD_DA_BOARD_MAX_DEV)     /* too many devices created */
      {
      errnoSet(AD_DA_BOARD_ALLOCATE_DEVICE_FAILED);
      return(ERROR);
      }
   if ((iosDevAdd(&(pAddaBrdDev->devHdr), name, DriverNumber)) != OK)
      {
      /* Specified device already exists */
      errnoSet(AD_DA_BOARD_DEVICE_ALREADY_CREATED);
      return(ERROR);
      }

      /* search the card and read the base addr registers */
   if (VmeBoardSearch(pAddaBrdDev) == ERROR)
      {
      errnoSet(AD_DA_BOARD_HARDWARE_INIT_FAILED);
      return(ERROR);
      }

/***************************/
   /* creaete semphore for driver */
   pAddaBrdDev->semADCdata = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
   if (pAddaBrdDev->semADCdata == NULL)
      {
      errnoSet(AD_DA_BOARD_SEMAPHORE_CREATE_FAILED);
      return (ERROR);
      }

   pAddaBrdDev->semDACdata = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
   if (pAddaBrdDev->semDACdata == NULL)
      {
      errnoSet(AD_DA_BOARD_SEMAPHORE_CREATE_FAILED);
      semDelete(pAddaBrdDev->semDACdata);
      return (ERROR);
      }

   pAddaBrdDev->semDMAdone = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY);
   if (pAddaBrdDev->semDMAdone == NULL)
      {
      errnoSet(AD_DA_BOARD_SEMAPHORE_CREATE_FAILED);
      semDelete(pAddaBrdDev->semDACdata);
      semDelete(pAddaBrdDev->semADCdata);
      return (ERROR);
      }
   /* end of semphore creation */
/***************************/


/***************************/
   /* configure the board */
   
#if 0
   /* configure DDS registers */
   pRegData[0] = 0x00184007;
   pRegData[1] = 0x00000000;
   iStatus = addaDDSRegWrite(pAddaBrdDev, 1, pRegData, 0);
   taskDelay(1);

   pRegData[0] = 0x00000000;
   pRegData[1] = 0x00008000;
   iStatus = addaDDSRegWrite(pAddaBrdDev, 7, pRegData, 0);
#else
#if 1
   for(i = 0; i < 1; i++)
      {
      /* reset DDS */
      iStatus = addaDDSGlobalReset(pAddaBrdDev);
      taskDelay(1);
      
      iStatus = addaDDSIOReset(pAddaBrdDev);
      taskDelay(1);
   
      /* configure DDS registers */
      /* 1. Configure DDS control register 1(CFR1) */
      pRegData[0] = 0x00000000;
      pRegData[1] = 0x00000000;
      iStatus = addaDDSRegWrite(pAddaBrdDev, 0, pRegData, 1);
      taskDelay(5);
   
      /* 1. Configure DDS control register 2(CFR2) */
      pRegData[0] = 0x00180020;
      pRegData[1] = 0x00000000;
      iStatus = addaDDSRegWrite(pAddaBrdDev, 1, pRegData, 1);
      taskDelay(5);
      }
#endif /* if 0 */
#endif /* if 0 */
   taskDelay(1);

   /* configure DAC registers */
   /* 1. write register 2 to 0x40 */
   ulRegDataWr = 0x42;     /* bit 2: I/Q swap */
   iStatus = addaDACRegWrite(pAddaBrdDev, 2, ulRegDataWr, 0);
   taskDelay(1);


   /* 2. write register 4 to 0x80 */
   ulRegDataWr = 0x80;
   iStatus = addaDACRegWrite(pAddaBrdDev, 4, ulRegDataWr, 0);
   taskDelay(1);

   /* 3. write register 1 to 0xe0 */
   ulRegDataWr = 0xe0;
   iStatus = addaDACRegWrite(pAddaBrdDev, 1, ulRegDataWr, 0);
   taskDelay(1);

   /* 4. write register 5 to 0x00 */
   ulRegDataWr = 0x00;
   iStatus = addaDACRegWrite(pAddaBrdDev, 5, ulRegDataWr, 0);
   taskDelay(1);

   /* 5. write register 9 to 0x00 */
   ulRegDataWr = 0x00;
   iStatus = addaDACRegWrite(pAddaBrdDev, 9, ulRegDataWr, 0);
   taskDelay(1);

   /* 6. write register 6 to 0x0F */
   ulRegDataWr = 0x0F;
   iStatus = addaDACRegWrite(pAddaBrdDev, 6, ulRegDataWr, 0);
   taskDelay(1);

   /* 7. write register A to 0x00 */
   ulRegDataWr = 0x00;
   iStatus = addaDACRegWrite(pAddaBrdDev, 0xa, ulRegDataWr, 0);
   taskDelay(1);

   /* 7. write register 7 to 0x80 */
   ulRegDataWr = 0x80;
   iStatus = addaDACRegWrite(pAddaBrdDev, 7, ulRegDataWr, 0);
   taskDelay(1);

   /* end of board configuration */
/***************************/


/***************************/
   /* interrupt clear and install */
#ifdef BOARD_PPC6
   iVmeIntVec = AD_DA_BOARD_ADC_INT_VME_VECTOR;
   pFuncPtr = (VOIDFUNCPTR)AddaBrdADCIntHandle;
#else

#endif
   /* end of interrupt install */
/***************************/

   NumberOfDevices++;
   #ifdef AddaBoard_Debug
      {
      fprintf(stderr, "\n\rNumberOfDevices = 0x%d\n", NumberOfDevices);
      }
   #endif
   pAddaBrdDev->devCreated = 1;    /* device created */
   pAddaBrdDev->devBusy = 0;       /* device available to be used */
   return (OK);
}

/******************************************************************************
TITLE:  	AddaBrdOpen
DESC:   	routine to open a AD_DA board device
PARAM:  	pAddaBrdDev    - pointer to ADDABRD_DEV device structure
RETURN: 	pAddaBrdDev    - file descriptor for opened device
         ERROR          - device cannot be open with error
******************************************************************************/
int AddaBrdOpen(ADDABRD_DEV *pAddaBrdDev)
{
   if (pAddaBrdDev->devCreated == 0)
      {
      errnoSet(AD_DA_BOARD_DEVICE_NOT_CREATED);
      return(ERROR);
      }

   if (pAddaBrdDev->devBusy)
      {
      errnoSet(AD_DA_BOARD_DEVICE_IN_USE);
      return(ERROR);
      }

   pAddaBrdDev->devBusy = 1;
   return((int)pAddaBrdDev);
}

/******************************************************************************
TITLE:  	AddaBrdClose
DESC:   	routine to close a AD_DA board device
PARAM:  	pAddaBrdDev    - pointer to ADDABRD_DEV device structure
RETURN: 	OK          - close the device successfully
         ERROR       - close the device failed with error
******************************************************************************/
int AddaBrdClose(ADDABRD_DEV *pAddaBrdDev)
{
   if (pAddaBrdDev->devCreated == 0)
      {
      errnoSet(AD_DA_BOARD_DEVICE_NOT_CREATED);
      return(ERROR);
      }

   if (!(pAddaBrdDev->devBusy))
      {
      errnoSet(AD_DA_BOARD_DEVICE_NOT_IN_USE);
      return(ERROR);
      }

   pAddaBrdDev->devBusy = 0;

   return(OK);
}

/******************************************************************************
TITLE:  	AddaBrdRead
DESC:   	routine to read data from AD_DA board device
PARAM:  	pAddaBrdDev - pointer to ADDABRD_DEV device structure
         pRevBuf     - pointer to receive buffer
         iNum        - bytes number to read, should be multiple of 4
RETURN: 	iNum        - bytes number have been read
******************************************************************************/
int AddaBrdRead(ADDABRD_DEV *pAddaBrdDev, char *pRevBuf, int iNum)
{
   int i;
   int iTmpNum;
   register unsigned int *lbuffer = (unsigned int *)pRevBuf;
   register unsigned int *source = (unsigned int *)(pAddaBrdDev->iVmeBaseAddr);

   if (pAddaBrdDev->iWhichFIFO == AD_DA_BOARD_ACCESS_DDC_FIFO)
      {
         source = (unsigned int *)(pAddaBrdDev->iVmeBaseAddr);
      }
   else
      {
         source = (unsigned int *)(pAddaBrdDev->iVmeBaseAddr + DUC_REG_OFFSET_TO_DDC_REG);
      }

   iTmpNum = iNum / 4;
   for(i = 0; i < iTmpNum; i++)
      {
         *lbuffer = *source;
         lbuffer++;
         source++;
      }
   return(iNum);

}

/******************************************************************************
TITLE:  	AddaBrdWrite
DESC:   	routine to write data to AD_DA board device
PARAM:  	pAddaBrdDev - pointer to ADDABRD_DEV device structure
         pSrcBuf     - pointer to source buffer
         iNum        - bytes number to write, should be multiple of 4
RETURN: 	iNum        - bytes number have been written
******************************************************************************/
int AddaBrdWrite(ADDABRD_DEV *pAddaBrdDev, char *pSrcBuf, int iNum)
{
   int i;
   int iTmpNum;
   register unsigned int *lbuffer = (unsigned int *)pSrcBuf;
   register unsigned int *destination = (unsigned int *)(pAddaBrdDev->iVmeBaseAddr);

   if (pAddaBrdDev->iWhichFIFO == AD_DA_BOARD_ACCESS_DDC_FIFO)
      {
         destination = (unsigned int *)(pAddaBrdDev->iVmeBaseAddr);
      }
   else