/******************************************************************************
 *
 *  Title  : vmeHpiUtility.c
 *  Version 0.0
 *
 *  Description: Routines for VME and HPI access.
 *
 *  Changes: March 7, 2002 - HPI access only D32
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

/******************************************************************************
 *								Header files 								  *
 ******************************************************************************/

#include <stdio.h>

#include "errorHandler.h"
#include "vmeHpiUtility.h"
#include "threadUtility.h"
#include "globalDefinitions.h"
#include "vmeAddressMap.h"
#include "hostUtility.h"
#include <nivxi.h>

/******************************************************************************
 *                               Definitions                                  *
 ******************************************************************************/


/******************************************************************************
 *						Static Function Declarations 						  *
 ******************************************************************************/

static char *getNiVxiStatus(int status);

/******************************************************************************
 *							   Global functions 							  *
 ******************************************************************************/

/*=============================================================================
 *                               RWvmeBlock()
 *=============================================================================
 *
 *  NOTE: Must be protected by criticalSection to prevent from simultaneous multiple
 *		  access to shared VME from more threads (pause+abort bits are sent to
 *		  vmeCommandReg directly from UserInterface, not from CommunicationLoop)!!
 *
 *  - buffer - local address space;
 *	- noVmeAddressIncrement - constants defined in vmeHpiUtility.h (VME_ADDR_AUTOINCREMENT=0, NO_VME_ADDR_INCREMENT=1);
 *  - noBlockAccess -
 *  - writeNotRead - READ or WRITE constants defined in vmeHpiUtility.h (READ=0, WRITE=1)
 *
 */
ERROR_ID RWvmeBlock(int writeNotRead, UINT32 vmeAddr, UINT32 *buffer, UINT32 numberOfElements, UINT16 elementSizeInBytes, int noVmeAddressIncrement, int noBlockAccess, int vmeDma){

	int status;
	char errorMessage[500];
	ERROR_ID errorId=SUCCESS;
	int threadPriority;
	HANDLE threadHandle;
	UINT16 vmeAccessParams;
	UINT32 i;
	UINT32 relAddr;

	ENTER_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	if(noBlockAccess){  /* no block VME access - i.e. element by element R/W */
		for(i=0, relAddr=0; i<numberOfElements; ++i, relAddr+=elementSizeInBytes){

			if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL; else vmeAccessParams=A32_MOTOROLA;

			if(writeNotRead){/* write */
				status=VXIout(vmeAccessParams, vmeAddr+relAddr, elementSizeInBytes, *(UINT32*)((UINT32)buffer+relAddr));
				if(status!=0){
					errorId=FATAL_ERROR;
					programError(__FILE__, __LINE__, errorId, "VXIout()", status, getNiVxiStatus(status));
					break;
				}
			}else{  /* read */
				status=VXIin(vmeAccessParams, vmeAddr+relAddr, elementSizeInBytes, (void*)((UINT32)buffer+relAddr));
				if(status!=0){
					errorId=FATAL_ERROR;
					programError(__FILE__, __LINE__, errorId, "VXIin()", status, getNiVxiStatus(status));
					break;
				}
			}
		}

	}else{ /* block VME access */
		
		if(vmeDma){
			if(noVmeAddressIncrement){ /* no VME address increment - FIFO access */
				if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL_NO_INCREMENT_DMA; 
				else vmeAccessParams=A32_MOTOROLA_NO_INCREMENT_DMA;
			}else{					   /* no VME address autoincrement - FIFO access */
				if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL_AUTOINCREMENT_DMA; 
				else vmeAccessParams=A32_MOTOROLA_AUTOINCREMENT_DMA;
			}
		}else{
	
			if(noVmeAddressIncrement){ /* no VME address increment - FIFO access */
				if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL_NO_INCREMENT; 
				else vmeAccessParams=A32_MOTOROLA_NO_INCREMENT;
			}else{					   /* no VME address autoincrement - FIFO access */
				if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL_AUTOINCREMENT; 
				else vmeAccessParams=A32_MOTOROLA_AUTOINCREMENT;
			}
		}	
		
		if(writeNotRead){ /* write */
			status=VXImove(A32_LOCAL_INTEL, (UINT32)buffer, vmeAccessParams, vmeAddr, numberOfElements, elementSizeInBytes);
		}else{  /* read */
			status=VXImove(vmeAccessParams, vmeAddr, A32_LOCAL_INTEL, (UINT32)buffer, numberOfElements, elementSizeInBytes);
		}
	}

	if(status!=0){
		errorId=FATAL_ERROR;
		sprintf(errorMessage, "VXImove(writeNotRead=%d, vmeAddr=0x%X, numberOfElements=0x%X, elementSize=%d B)",
									   writeNotRead, vmeAddr, numberOfElements, elementSizeInBytes);
		programError(__FILE__, __LINE__, errorId, errorMessage, status, getNiVxiStatus(status));
	}

	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	return(errorId);
}
/*=============================================================================
 *                               vmeReadElement()
 *=============================================================================
 *
 *  Transfers one word(32b wide) from vmeAddr to local address
 *  NOTE: Must be protected by criticalSection to prevent from simultaneous multiple
 *		  access to shared VME from more threads (pause+abort bits are sent to
 *		  vmeCommandReg directly from UserInterface, not from CommunicationLoop)!!
 */
ERROR_ID vmeReadElement(UINT32 vmeAddr, void *value, UINT16 elementSizeInBytes){

	int status;
	char errorMessage[500];
	ERROR_ID errorId=SUCCESS;
	int threadPriority;
	HANDLE threadHandle;
	UINT16 vmeAccessParams;

	ENTER_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL; else vmeAccessParams=A32_MOTOROLA;

	status=VXIin(vmeAccessParams, vmeAddr, elementSizeInBytes, value);
	if(status!=0){
		errorId=FATAL_ERROR;
		sprintf(errorMessage, "VXIin(vmeAddr=0x%X, *value=0x%X, elementSize=%d B)",
									 vmeAddr, *(UINT32*)value, elementSizeInBytes);
		programError(__FILE__, __LINE__, errorId, errorMessage, status, getNiVxiStatus(status));
	}

	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	return(errorId);
}

/*=============================================================================
 *                               vmeWriteElement()
 *=============================================================================
 *
 *  Transfers one word(32b wide) passed by value to vmeAddr.
 *  NOTE: Must be protected by criticalSection to prevent from simultaneous multiple
 *		  access to shared VME from more threads (pause+abort bits are sent to
 *		  vmeCommandReg directly from UserInterface, not from CommunicationLoop)!!
 */
ERROR_ID vmeWriteElement(UINT32 value, UINT32 vmeAddr, UINT16 elementSizeInBytes) {

	int status;
	char errorMessage[500];
	ERROR_ID errorId=SUCCESS;
	int threadPriority;
	HANDLE threadHandle;
	UINT16 vmeAccessParams;

	ENTER_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	if(global.option.intelNotMotorola) vmeAccessParams=A32_INTEL; else vmeAccessParams=A32_MOTOROLA;

	status=VXIout(vmeAccessParams, vmeAddr, elementSizeInBytes, value);
	if(status!=0){
		errorId=FATAL_ERROR;
		sprintf(errorMessage, "VXIout(value=0x%X, vmeAddr=0x%X, elementSize=%d B)",
									  value, vmeAddr, elementSizeInBytes);
		programError(__FILE__, __LINE__, errorId, errorMessage, status, getNiVxiStatus(status));
	}

	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	return(errorId);
}

/*=============================================================================
 *                               RWmaster() - 32 bit master access
 *=============================================================================
 *
 *
 *  Read or write master memory:
 *
 *	  -- dspAddr - starting address in master DSP internal memory space;
 *	  -- buffer - local memory space for data;
 *    -- wordCount - block length (32b words);
 *
 *    -- writeNotRead - READ or WRITE constants defined in vmeHpiUtility.h (0=read, 1=write);
 *	  -- noAddressIncrement = uses only HPID register for data block transfer (useful for Slave access);
 */


ERROR_ID RWmaster(int writeNotRead, UINT8 slotNumber, UINT32 dspAddr, UINT32 *buffer, UINT32 wordCount, int noAddressIncrement, int vmeDma){

	UINT32 hpiaData;
	char errorMessage[500];
	ERROR_ID errorId=SUCCESS;
	UINT32 hpidAddr;
	const UINT32 hpiaAddr=BASE_ADDRESS(slotNumber)+HPIA_REL_ADDR;
	UINT32 endAddr;
	UINT32 i;

	UINT32 dspAddrLocal;
	int threadPriority;
	HANDLE threadHandle;

	ENTER_CRITICAL_SECTION(&global.vmeAccessCriticalSection);


    /* Note: HPIC is already set to little endian when ROD is initialized [see rodInit() in rodInit.c]!!! */

    if((wordCount==1)||noAddressIncrement){
    	hpidAddr=BASE_ADDRESS(slotNumber)+HPID_NO_AUTOINC_REL_ADDR;
    }else{
    	hpidAddr=BASE_ADDRESS(slotNumber)+HPID_AUTOINC_REL_ADDR;
    }

    /* write init HPIA addr  */
    errorId=vmeWriteElement(dspAddr, hpiaAddr, sizeof(UINT32));
    if(errorId!=SUCCESS){
    	ERROR_CHECK(errorId, vmeWriteElement());
    	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
		return(errorId);
	}

	/* read/write data from/to Master HPID */
    errorId=RWvmeBlock(writeNotRead, hpidAddr, buffer, wordCount, sizeof(UINT32), NO_VME_ADDR_AUTOINCREMENT, BLOCK_ACCESS, vmeDma);
	if(errorId!=SUCCESS) {
		sprintf(errorMessage, "FATAL VME ERROR: Master HPID(writeNotRead=%d) - not successful", writeNotRead);
		programError(__FILE__, __LINE__, FATAL_ERROR, "RWvmeBlock()", errorId, errorMessage);
		LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
		return(FATAL_ERROR);
	}

	/* check HPIA after transfer */
    errorId=vmeReadElement(hpiaAddr, &hpiaData, sizeof(UINT32));
    ERROR_CHECK(errorId, vmeReadElement());
    if(errorId!=SUCCESS){
    	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
		return(errorId);
	}

    if((wordCount==1)||noAddressIncrement){
    	endAddr=dspAddr;
    }else{
    	endAddr=dspAddr+wordCount*4;
    	if(writeNotRead) endAddr-=4; /* write */
    }

    if(hpiaData!=endAddr){
		errorId=FATAL_ERROR;
		sprintf(errorMessage,"RWmaster() - hpiaStart=0x%X, hpiaStop=0x%X, wordCount=0x%X.", dspAddr, hpiaData, wordCount);
		programError(__FILE__, __LINE__, errorId, "RWmaster()", errorId, errorMessage);
	}

	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);

	return(errorId);


}

/*=============================================================================
 *                               RWslave() - 32 bit slave access
 *=============================================================================
 *
 *  Read or write slave memory:
 *
 *	  -- dspAddr - starting address in slave DSP internal memory space;
 *	  -- buffer - local memory space for data;
 *    -- wordCount - block length (32b words);
 *
 *    -- writeNotRead - READ or WRITE constants defined in vmeHpiUtility.h (READ=0, WRITE=1)
 *
 */
ERROR_ID RWslave(int writeNotRead, UINT8 slotNumber, UINT8 slaveNumber, UINT32 dspAddr, UINT32 *buffer, UINT32 wordCount, int vmeDma){

	ERROR_ID errorId=SUCCESS;
	char errorMessage[200];
	UINT32 slaveHpidAddr;
	const UINT32 slaveHpiaAddr=SLAVE_HPI_BASE_ADDR(slaveNumber)+SLAVE_HPIA_OFFSET;
	UINT32 endAddr;
	UINT32 hpiaData;
	UINT32 i;
	int status;
	UINT32 wordCountTemp;

	/* set little endian */
	errorId=setHpicMaster(slotNumber);
	ERROR_CHECK(errorId, setHpicMaster());
	if(errorId!=SUCCESS) {
		return(errorId);
	}	
	errorId=setHpicSlave(slotNumber, slaveNumber);
	ERROR_CHECK(errorId, setHpicSlave());
		if(errorId!=SUCCESS) {
		return(errorId);
	}	
	
	ENTER_CRITICAL_SECTION(&global.vmeAccessCriticalSection);         
		                                                           
	/* turn master-slave communication OFF */
	errorId=dmaAccessSwitch(slotNumber, ON, 5.0);
	if(errorId!=SUCCESS) {
		ERROR_CHECK(errorId, dmaAccessSwitch(ON) Error!!); 
		LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);  
		return(errorId);
	}	
		
	/* write starting address to Slave HPIA */
	errorId=RWmaster(WRITE, slotNumber, slaveHpiaAddr, &dspAddr, 1, NO_HPIA_AUTOINCREMENT, 0);
	if(errorId!=SUCCESS){
		ERROR_CHECK(errorId,  RWmaster());
		status=dmaAccessSwitch(slotNumber, OFF, 0.0);
		ERROR_CHECK(status, dmaAccessSwitch(OFF) Error!!);
		LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
		return(errorId);
	}

	if(wordCount==1){
		slaveHpidAddr=SLAVE_HPI_BASE_ADDR(slaveNumber)+SLAVE_HPID_OFFSET;
		wordCountTemp=1;
	}else{
		slaveHpidAddr=SLAVE_HPI_BASE_ADDR(slaveNumber)+SLAVE_HPID_AUTOINC_OFFSET;
		if(writeNotRead) wordCountTemp=wordCount-1;
		else wordCountTemp=wordCount;
	}

	/* write or read to/from Slave memory space (resp slave HPID/++) over Master HPID */
	errorId=RWmaster(writeNotRead, slotNumber, slaveHpidAddr, buffer, wordCountTemp, NO_HPIA_AUTOINCREMENT, vmeDma); /* no address increment - only HPID */
	if(errorId!=SUCCESS) {
		sprintf(errorMessage, "FATAL HPI ERROR: Slave HPID(writeNotRead=%d) - not successful", writeNotRead);
		programError(__FILE__, __LINE__, FATAL_ERROR, "RWmaster()", errorId, errorMessage);
		status=dmaAccessSwitch(slotNumber, OFF, 0.0);
		ERROR_CHECK(status, dmaAccessSwitch(OFF) Error!!);
		LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
		return(FATAL_ERROR);
	}

	if(writeNotRead&&(wordCount>1)){
		/* for write repeat last word to HPID */
		errorId=RWmaster(writeNotRead, slotNumber, SLAVE_HPI_BASE_ADDR(slaveNumber)+SLAVE_HPID_OFFSET, buffer+wordCountTemp, 1, NO_HPIA_AUTOINCREMENT, 0);
		if(errorId!=SUCCESS) {
			sprintf(errorMessage, "FATAL HPI ERROR: Slave HPID(writeNotRead=%d) - not successful", writeNotRead);
			programError(__FILE__, __LINE__, FATAL_ERROR, "RWmaster()", errorId, errorMessage);
			status=dmaAccessSwitch(slotNumber, OFF, 0.0);
			ERROR_CHECK(status, dmaAccessSwitch(OFF) Error!!);
			LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
			return(FATAL_ERROR);
		}
	}	
	
	/* check HPIA after transfer */
	errorId=RWmaster(READ, slotNumber, slaveHpiaAddr, &hpiaData, 1, NO_HPIA_AUTOINCREMENT, 0);
	ERROR_CHECK(errorId, RWmaster());
    if(errorId!=SUCCESS) {
		status=dmaAccessSwitch(slotNumber, OFF, 0.0);
		ERROR_CHECK(status, dmaAccessSwitch(OFF) Error!!);
		LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection);
    	return(errorId);
    }	
    
    if(wordCount==1){
    	endAddr=dspAddr;
    }else{
    	endAddr=dspAddr+wordCount*4;
    	if(writeNotRead) endAddr-=4; /* write */
    }
	 
    if(hpiaData!=endAddr){
		errorId=FATAL_ERROR;
		printf("error\n");
		sprintf(errorMessage,"RWslave() - hpiaStart=0x%X, hpiaStop=0x%X, wordCount=0x%X.",dspAddr, hpiaData, wordCount);
		programError(__FILE__, __LINE__, errorId, "RWslave()", errorId, errorMessage);
	}
	
	/* turn master-slave communication ON */
	status=dmaAccessSwitch(slotNumber, OFF, 0.0);
	ERROR_CHECK(status, dmaAccessSwitch(OFF) Error!!);

	LEAVE_CRITICAL_SECTION(&global.vmeAccessCriticalSection); 
	
	return(errorId);

}
/*=============================================================================
 *                               setHpicMaster()
 *=============================================================================
 *
 *   Init value for MasterDSP HPIC register - INTEL byte order
 *
 */

ERROR_ID setHpicMaster(UINT8 slotNumber){

	const UINT32 hpicVmeAddr=BASE_ADDRESS(slotNumber)+HPIC_REL_ADDR;
	UINT32 hpic;
	UINT32 data;
	ERROR_ID errorId;
	UINT16 value;

	/* set little endian */
    hpic=0x00010001;
  	errorId=vmeWriteElement(hpic, hpicVmeAddr, sizeof(UINT32));
    ERROR_CHECK(errorId, vmeWriteElement());

	return(errorId);

}

/*=============================================================================
 *                               setHpicSlave()
 *=============================================================================
 *
 *    Init value for SlaveDSP HPIC register - INTEL byte order
 *
 */

ERROR_ID setHpicSlave(UINT8 slotNumber, UINT8 slaveNumber){

	const UINT32 hpicMasterAddr=SLAVE_HPI_BASE_ADDR(slaveNumber)+SLAVE_HPIC_OFFSET;
	UINT32 hpic;
	UINT32 data;
	ERROR_ID errorId;

	/* set little endian */
    hpic=0x00010001;
	errorId=RWmaster(WRITE, slotNumber, hpicMasterAddr, &hpic, 1, NO_HPIA_AUTOINCREMENT, 0);
    ERROR_CHECK(errorId, RWmaster());

	return(errorId);
}


/******************************************************************************
 *							   Static functions 							  *
 ******************************************************************************/

/*=============================================================================
 *                               getNiVxiStatus()
 *=============================================================================
 *
 *
 *
 */
static char *getNiVxiStatus(int status){

 	static char errorMessage[100];

 	switch(status){
 		case 0: strcpy(errorMessage, "Successful");
 			break;
 		case -1: strcpy(errorMessage, "Bus Error occurred");
 			break;
 		case -2: strcpy(errorMessage, "Invalid Access Parameters");
 			break;
 		case -3: strcpy(errorMessage, "Invalid Address Offset");
 			break;
 		case -4: strcpy(errorMessage, "Invalid Value Size");
 			break;
 		case -5: strcpy(errorMessage, "Byte order not supported");
 			break;
 		case -6: strcpy(errorMessage, "Address not accessible with this hardware");
 			break;
 		case -7: strcpy(errorMessage, "Privilege not supported");
 			break;
 		case -8: strcpy(errorMessage, "Timeout, DMA aborted");
 			break;
 		case -9: strcpy(errorMessage, "Element Size not supported");
 			break;
 		default: strcpy(errorMessage, "Non known VME/VXI error!");
 			break;

 	}

 	return(errorMessage);
 }


/******************************************************************************/