#include <userint.h>

/******************************************************************************
 *
 *  Title  : fpgaUir.c
 *  Version 0.0, 6 July 2000,
 *
 *  Description: fpgaUir.uir callback functions.
 *  Related files: fpgaUir.uir
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

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

#include <stdio.h>
#include <stdlib.h>
#include "fpgaUir.h"
#include "flashUtility.h"
#include "uirUtility.h"
#include "fileUtility.h"
#include "vmeAddressMap.h"
#include "globalDefinitions.h"
#include "vmeHpiUtility.h"
#include "vmeAddressMap.h"
#include "hostUtility.h"

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

#define NUMBER_OF_FPGA_CONTROL_REGS 8 /* number of fpga control status registers */
#define NUMBER_OF_FPGA_STATUS_REGS 8  /* number of fpga control status registers */

/******************************************************************************
 *                                 Macros                                     *
 ******************************************************************************/


/******************************************************************************
 *                           Type definitions                                 *
 ******************************************************************************/

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

static ERROR_ID eraseFlash(unsigned char slotNumber, unsigned int flashBottomRelAddress, const char flashName[], int newFlashLoc);
static ERROR_ID readFlash(unsigned char slotNumber, unsigned int flashBottomRelAddress,  const char flashName[], int newFlashLoc);

/******************************************************************************
 *                        LW_CVI callback functions                           *
 ******************************************************************************/

/*=============================================================================
 *                               pickFileName()
 *=============================================================================
 *
 *   Selects file name.
 *
 */

#define SELECT_FLASH_FILE(controlName) \
	case controlName##_FILE:\
		status=FileSelectPopup(global.fpgaDataDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1,fileName);\
		if(status==VAL_NO_FILE_SELECTED){\
			break;\
		}\
		errorId=getFileSize (fileName, &fileSize);\
		ERROR_CHECK(errorId, getFileSize());\
		if(errorId!=SUCCESS){\
			return(errorId);\
		}\
		SetCtrlVal(panel, controlName##_SIZE, fileSize);\
		SetCtrlVal(panel, control, fileName);\
		GetCtrlVal(panel, controlName##_START_ADDR, &address);\
		/* last addr */\
		if(fileSize>0) address+=fileSize-1;\
		SetCtrlVal(panel, controlName##_END_ADDR, address);\
	break;


int CVICALLBACK pickFileName(int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	int status;
	unsigned char slotNumber;
	unsigned int numSectors;
	unsigned int fileSize;
	UINT32 address;
	UINT32 mdspAddr;
	ERROR_ID errorId;
	char fileName[PATHNAME_LENGTH];

	if(event==EVENT_LEFT_CLICK){

		GetCtrlVal(panel, PAN_FLASH_SLOT_NUMBER,&slotNumber);
		switch(control){
			SELECT_FLASH_FILE(PAN_FLASH_LOCATION);
			SELECT_FLASH_FILE(PAN_FLASH_RRIF);
			SELECT_FLASH_FILE(PAN_FLASH_FORM);
			SELECT_FLASH_FILE(PAN_FLASH_EFB);
			SELECT_FLASH_FILE(PAN_FLASH_ROUTER);
			case PAN_FLASH_DSP_PRG_FILE:
				status=FileSelectPopup(global.dspPrgDataDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1,fileName);
				if(status==VAL_NO_FILE_SELECTED){
					break;
				}
				errorId=getFileSize (fileName, &fileSize);
				ERROR_CHECK(errorId, getFileSize());
				if(errorId!=SUCCESS){
					return(errorId);
				}
				SetCtrlVal(panel, PAN_FLASH_DSP_PRG_SIZE, fileSize);
				SetCtrlVal(panel, control, fileName);
				GetCtrlVal(panel, PAN_FLASH_DSP_PRG_START_ADDR, &mdspAddr);
				/* last addrr */
				mdspAddr+=fileSize-1;
				SetCtrlVal(panel, PAN_FLASH_DSP_PRG_END_ADDR, mdspAddr);

				break;

			default:

				break;
		}
	}
	return 0;
}

/*=============================================================================
 *                               flashButtons()
 *=============================================================================
 *
 *  Flash buttons callback function.
 *
 */
#define READ_WRITE_FLASH_FILE(controlName, textMessage) \
	case controlName##_WRITE:\
		GetCtrlVal(panel, controlName##_SIZE, &fileSize);\
		GetCtrlVal(panel, controlName##_FILE, fileName);\
		if(fileName=='\0'){\
			break; /*no file selected */\
		}\
		errorId=getFileSize (fileName, &fileSizeReal);\
		ERROR_CHECK(errorId, getFileSize());\
		if(errorId!=SUCCESS) return(errorId);\
		if(fileSizeReal!=fileSize){\
			ERROR_CHECK(PROGRAM_ERROR, Wrong file size!);\
			return(PROGRAM_ERROR);\
		}\
		/* write data */\
		buffer= calloc(fileSize,sizeof(UINT8));\
		errorId= readFromBinFile(fileName, buffer, fileSize);\
		ERROR_CHECK(errorId, readFromBinFile());\
		if(errorId!=SUCCESS) return(errorId);\
		numSectors= ((fileSize-1)/sectorSize)+1;\
		status= SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_MAX_VALUE, numSectors);\
		UIR_STATUS_CHECK(status, SetCtrlAttribute());\
		SetCtrlVal(global.panel.flashInfo, FLASH_INFO_FLASH_NAME, textMessage##" - writing...");\
		status= InstallPopup(global.panel.flashInfo);\
		UIR_STATUS_CHECK(status, InstallPopup());\
		GetCtrlVal(panel, controlName##_START_ADDR, &address);\
		errorId= writeBlockToFlash(slotNumber, address, buffer, fileSize, newFlashLoc);\
		ERROR_CHECK(errorId, writeBlockToFlash());\
		free(buffer);\
		status= RemovePopup(1);\
		UIR_STATUS_CHECK(status, RemovePopup());\
		break;\
	case controlName##_READ:\
		status = FileSelectPopup (global.fpgaDataDir, "*.bin", "*.bin", "",VAL_SAVE_BUTTON, 0, 0, 1, 0, fileName);\
		switch(status){\
			case 0: /* no file selected */\
				break;\
			case 1: /* existing file selected */\
				/* no break here */\
			case 2: /* new file selected */\
				GetCtrlVal(panel, controlName##_SIZE, &fileSize);\
				buffer= calloc(fileSize,sizeof(UINT8));\
				GetCtrlVal(panel, controlName##_START_ADDR, &address);\
				numSectors= ((fileSize-1)/sectorSize)+1;\
				SetCtrlVal(global.panel.flashInfo, FLASH_INFO_FLASH_NAME, textMessage##"- reading...");\
				status= SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_MAX_VALUE, numSectors);\
				UIR_STATUS_CHECK(status, SetCtrlAttribute());\
				status= InstallPopup(global.panel.flashInfo);\
				UIR_STATUS_CHECK(status, InstallPopup());\
				errorId= readBlockFromFlash(slotNumber, address, buffer, fileSize, newFlashLoc);\
				ERROR_CHECK(errorId, readBlockFromFlash());\
				errorId= writeToBinFile(fileName, 0, buffer, fileSize);\
				ERROR_CHECK(errorId, writeToBinFile());\
				free(buffer);\
				status= RemovePopup(1);\
				UIR_STATUS_CHECK(status, RemovePopup());\
				if(errorId != SUCCESS) return(-1);\
				errorId= viewBinFile(fileName);\
				ERROR_CHECK(errorId, viewBinFile());\
				break;\
				default: /* error */\
			break;\
		}\
		break;



#define CHANGE_ADDRESS(controlName) \
	case controlName##_START_ADDR:\
		GetCtrlVal(panel, control, &address);\
		address=(address/FLASH_SECTOR_SIZE_revE)*FLASH_SECTOR_SIZE_revE; /* align on sector boundary!!*/\
		SetCtrlVal(panel, control, address);\
		GetCtrlVal(panel, controlName##_SIZE, &fileSize);\
		/* last VME addr */\
		if(fileSize>0) address+=fileSize-1;\
		SetCtrlVal(panel, controlName##_END_ADDR, address);\
		break;


int CVICALLBACK flashButtons (int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	int status;
	unsigned char slotNumber;
	char fileName[300];
	unsigned int fileSize;
	unsigned int fileSizeReal;
	unsigned int address;
	unsigned int numSectors;
	unsigned int sector;
	ERROR_ID errorId;
	void *buffer;
	UINT32 hpicVmeAddr, hpic;
	char textMessage[100];
	UINT32 fpgaStatusReg6;
	int newFlashLoc;
	unsigned int sectorSize;

	if(event==EVENT_COMMIT){

		GetCtrlVal(panel, PAN_FLASH_SLOT_NUMBER, &slotNumber);
		if(slotNumber==0){
			status = MessagePopup ("Warning", "Choose slot number, please.");
			return(0);
		}
		
		/* read revision */
		errorId=RWvmeBlock(READ, BASE_ADDRESS(slotNumber)+FPGA_STATUS_6_REL_ADDR, &fpgaStatusReg6, 1, sizeof(UINT32), VME_ADDR_AUTOINCREMENT, BLOCK_ACCESS, 0);
		ERROR_CHECK(errorId, RWvmeBlock(READ));
		if(errorId!=SUCCESS) {
			return(-1);
		}

		//dpsf: modify to handle both Revision E & F RODs
		if (  (((fpgaStatusReg6 & 0xFF0000) >> 16) == 0xE) 
		    ||(((fpgaStatusReg6 & 0xFF0000) >> 16) == 0xF) ) {
			newFlashLoc= 1;
			sectorSize= FLASH_SECTOR_SIZE_revE;
		}
		else {
			newFlashLoc= 0;
			sectorSize= FLASH_SECTOR_SIZE;
		}

		switch(control){

			READ_WRITE_FLASH_FILE(PAN_FLASH_LOCATION, "Location file");
			READ_WRITE_FLASH_FILE(PAN_FLASH_RRIF, "RRIF");
			READ_WRITE_FLASH_FILE(PAN_FLASH_FORM, "Formatter");
			READ_WRITE_FLASH_FILE(PAN_FLASH_EFB,  "EFB");
			READ_WRITE_FLASH_FILE(PAN_FLASH_ROUTER, "Router");

			case PAN_FLASH_CLEAR_FLASH_0:
				eraseFlash(slotNumber, FPGA_FLASH_0_BOTTOM_REL_ADDR, "FLASH 0", newFlashLoc);
				break;
			case PAN_FLASH_CLEAR_FLASH_1:
				eraseFlash(slotNumber, FPGA_FLASH_1_BOTTOM_REL_ADDR, "FLASH 1", 0);
				break;
			case PAN_FLASH_CLEAR_FLASH_2:
				eraseFlash(slotNumber, FPGA_FLASH_2_BOTTOM_REL_ADDR, "FLASH 2", 0);
				break;

			case PAN_FLASH_CLEAR_FLASH_DSP:

				status= ConfirmPopup ("", "Erase FLASH DSP?");
					if(status != 1){
					break;
				}

				/* set little endian */
				errorId= setHpicMaster(slotNumber);
				ERROR_CHECK(errorId, setHpic());
				if(errorId != SUCCESS) return(errorId);

				SetCtrlVal(global.panel.flashInfo, FLASH_INFO_FLASH_NAME, "FLASH DSP - erasing ...");
				status= SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_VISIBLE, 0);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
				status= InstallPopup(global.panel.flashInfo);
				UIR_STATUS_CHECK(status, InstallPopup());

				errorId= chipEraseHpi(slotNumber);
				ERROR_CHECK(errorId, chipErase());

				status= RemovePopup(1);
				UIR_STATUS_CHECK(status, RemovePopup());

				status= SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_VISIBLE, 1);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
				break;

			case PAN_FLASH_READ_FLASH_0:
				errorId= readFlash(slotNumber, FPGA_FLASH_0_BOTTOM_REL_ADDR,  "FLASH 0", newFlashLoc);
				ERROR_CHECK(errorId, readFlash());
				break;
			case PAN_FLASH_READ_FLASH_1:
				errorId= readFlash(slotNumber, FPGA_FLASH_1_BOTTOM_REL_ADDR,  "FLASH 1", 0);
				ERROR_CHECK(errorId, readFlash());
				break;
			case PAN_FLASH_READ_FLASH_2:
				errorId= readFlash(slotNumber, FPGA_FLASH_2_BOTTOM_REL_ADDR,  "FLASH 2", 0);
				ERROR_CHECK(errorId, readFlash());
				break;
			case PAN_FLASH_DSP_PRG_WRITE:
				/* set little endian */
				errorId= setHpicMaster(slotNumber);
				ERROR_CHECK(errorId, setHpic());
				GetCtrlVal(panel, PAN_FLASH_DSP_PRG_FILE, fileName);
				if(fileName=='\0'){
					break; /*no file selected */
				}
				errorId=getFileSize (fileName, &fileSize);
				ERROR_CHECK(errorId, getFileSize());
				if(errorId!=SUCCESS) return(errorId);
				
				/* write data */
				buffer=calloc(fileSize,sizeof(UINT8));
				errorId=readFromBinFile(fileName, buffer, fileSize);
				ERROR_CHECK(errorId, readFromBinFile());
				if(errorId!=SUCCESS){
					status=RemovePopup(1);
					UIR_STATUS_CHECK(status, RemovePopup());
					break;
				}
				
				GetCtrlVal(panel, PAN_FLASH_DSP_PRG_START_ADDR, &address); 
				/* find number of sectors */
				numSectors=((fileSize-1)/FLASH_SECTOR_SIZE)+1;
 
				SetCtrlVal(panel, PAN_FLASH_DSP_PRG_SIZE, fileSize);
				SetCtrlVal(panel, PAN_FLASH_DSP_PRG_END_ADDR, (address+fileSize-1));
				
				status=SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_MAX_VALUE, numSectors);
				UIR_STATUS_CHECK(status, SetCtrlAttribute());
				SetCtrlVal(global.panel.flashInfo, FLASH_INFO_FLASH_NAME, "FLASH DSP - writing...");
				status=InstallPopup(global.panel.flashInfo);
				UIR_STATUS_CHECK(status, InstallPopup());
				errorId=writeBlockToFlashHpi(slotNumber, address, buffer, fileSize);
				ERROR_CHECK(errorId, writeBlockToFlash());
				free(buffer);
				status=RemovePopup(1);
				UIR_STATUS_CHECK(status, RemovePopup());

				break;


			default:
				break;

		}


	} else{
		if(event==EVENT_VAL_CHANGED){
			GetCtrlVal(panel, PAN_FLASH_SLOT_NUMBER, &slotNumber);
			switch(control){

				CHANGE_ADDRESS(PAN_FLASH_LOCATION);
				CHANGE_ADDRESS(PAN_FLASH_RRIF);
				CHANGE_ADDRESS(PAN_FLASH_FORM);
				CHANGE_ADDRESS(PAN_FLASH_EFB);
				CHANGE_ADDRESS(PAN_FLASH_ROUTER);

				default:

				break;
			}

		}
	}
	return 0;
}

/*=============================================================================
 *                               fpgaRegButtons()
 *=============================================================================
 *
 *
 *
 */
#define DISPLAY_BIT(regValue, bitIndex, controlId) \
	bitValue=(int) READ_BIT(regValue, bitIndex);\
	SetCtrlVal(panel, controlId##bitIndex, bitValue);



#define SET_CTRL_BIT(slotNumber, regIndex, bitIndex) \
	case PANEL_FPGA_COM##regIndex##_BUTT_##bitIndex:\
		fpgaControlReg[regIndex]=0; /*clear register */\
		SET_BIT(fpgaControlReg[regIndex], bitIndex);\
		errorId=vmeWriteElement(fpgaControlReg[regIndex], BASE_ADDRESS(slotNumber)+FPGA_CONTROL_##regIndex##_REL_ADDR, sizeof(UINT32));\
		ERROR_CHECK(errorId, vmeWriteElement());\
		fpgaRegButtons(panel, PANEL_FPGA_READ_REG, event, callbackData, eventData1, eventData2); /*update the screen, same as after pressing the 'READ ALL REGISTERS' button*/\
		break;

#define SET_CTRL_BIT_COM2(slotNumber, regIndex, bitIndex) \
	case PANEL_FPGA_COM##regIndex##_BUTT_##bitIndex:\
		fpgaControlReg[regIndex]=0; /*clear register */\
		SET_BIT(fpgaControlReg[regIndex], bitIndex);\
		GetCtrlVal(panel, PANEL_FPGA_COM2_BUTT_0, &value);\
		if(value) SET_BIT(fpgaControlReg[2], 0);\
		errorId=vmeWriteElement(fpgaControlReg[regIndex], BASE_ADDRESS(slotNumber)+FPGA_CONTROL_##regIndex##_REL_ADDR, sizeof(UINT32));\
		ERROR_CHECK(errorId, vmeWriteElement());\
		fpgaRegButtons(panel, PANEL_FPGA_READ_REG, event, callbackData, eventData1, eventData2); /*update the screen, same as after pressing the 'READ ALL REGISTERS' button*/\
		break;



int CVICALLBACK fpgaRegButtons (int panel, int control, int event, void *callbackData, int eventData1, int eventData2){

	int status;
	unsigned char slotNumber;
	UINT32 fpgaControlReg[NUMBER_OF_FPGA_CONTROL_REGS]; /* see vme memory map */
	UINT32 fpgaStatusReg[NUMBER_OF_FPGA_STATUS_REGS]; /* see vme memory map */
	ERROR_ID errorId;
	int bitValue, bitIndex;
	UINT32 regValue;
	int value;

	if((event==EVENT_VAL_CHANGED)||(event==EVENT_KEYPRESS)||(event==EVENT_COMMIT)){

		GetCtrlVal(panel, PANEL_FPGA_SLOT_NUMBER, &slotNumber);

		switch(control){
			SET_CTRL_BIT(slotNumber, 0, 0);
			SET_CTRL_BIT(slotNumber, 0, 1);
			SET_CTRL_BIT(slotNumber, 0, 2);
			SET_CTRL_BIT(slotNumber, 0, 3);
			SET_CTRL_BIT(slotNumber, 0, 4);
			SET_CTRL_BIT(slotNumber, 0, 5);
			/*SET_CTRL_BIT(slotNumber, 0, 6);Cnfg Ovrd - alternating value feature:*/
			case PANEL_FPGA_COM0_BUTT_6:
				errorId=vmeReadElement(BASE_ADDRESS(slotNumber)+FPGA_CONTROL_0_REL_ADDR, &fpgaControlReg[0], sizeof(UINT32));
				ERROR_CHECK(errorId, vmeReadBlock());
				if(errorId!=SUCCESS) {
					break;
				}
				if((int)READ_BIT(fpgaControlReg[0],6)) {
					fpgaControlReg[0]=0; /*clear register */
				} else {
					fpgaControlReg[0]=0; /*clear register */
					SET_BIT(fpgaControlReg[0], 6);
				}
				errorId=vmeWriteElement(fpgaControlReg[0], BASE_ADDRESS(slotNumber)+FPGA_CONTROL_0_REL_ADDR, sizeof(UINT32));
				ERROR_CHECK(errorId, vmeWriteElement());
				fpgaRegButtons(panel, PANEL_FPGA_READ_REG, event, callbackData, eventData1, eventData2); /*update the screen, same as after pressing the 'READ ALL REGISTERS' button*/
			break;

			SET_CTRL_BIT(slotNumber, 0, 7);

			SET_CTRL_BIT(slotNumber, 1, 0);
			SET_CTRL_BIT(slotNumber, 1, 1);
			SET_CTRL_BIT(slotNumber, 1, 2);
			SET_CTRL_BIT(slotNumber, 1, 3);
			SET_CTRL_BIT(slotNumber, 1, 4);
			SET_CTRL_BIT(slotNumber, 1, 5);
			case PANEL_FPGA_COM1_BUTT_6:
				errorId=vmeReadElement(BASE_ADDRESS(slotNumber)+FPGA_CONTROL_1_REL_ADDR, &fpgaControlReg[1], sizeof(UINT32));
				ERROR_CHECK(errorId, vmeReadBlock());
				if(errorId!=SUCCESS) {
					break;
				}
				if((int)READ_BIT(fpgaControlReg[1],6)) {
					fpgaControlReg[1]=0;
				} else {
					fpgaControlReg[1]=0;
					SET_BIT(fpgaControlReg[1], 6);
				}
				errorId=vmeWriteElement(fpgaControlReg[1], BASE_ADDRESS(slotNumber)+FPGA_CONTROL_1_REL_ADDR, sizeof(UINT32));
				ERROR_CHECK(errorId, vmeWriteElement());
				fpgaRegButtons(panel, PANEL_FPGA_READ_REG, event, callbackData, eventData1, eventData2); /*update the screen, same as after pressing the 'READ ALL REGISTERS' button*/
			break;
/*			SET_CTRL_BIT(slotNumber, 1, 6);*/
			SET_CTRL_BIT(slotNumber, 1, 7);


			//SET_CTRL_BIT(slotNumber, 2, 0);
			case PANEL_FPGA_COM2_BUTT_0:
				fpgaControlReg[2]=0; /*clear register */
				GetCtrlVal(panel, PANEL_FPGA_COM2_BUTT_0, &value);
				if(value) SET_BIT(fpgaControlReg[2], 0);
				
				errorId=vmeWriteElement(fpgaControlReg[2], BASE_ADDRESS(slotNumber)+FPGA_CONTROL_2_REL_ADDR, sizeof(UINT32));
				ERROR_CHECK(errorId, vmeWriteElement());
				fpgaRegButtons(panel, PANEL_FPGA_READ_REG, event, callbackData, eventData1, eventData2); /*update the screen, same as after pressing the 'READ ALL REGISTERS' button*/
			break;
			SET_CTRL_BIT_COM2(slotNumber, 2, 1);
			SET_CTRL_BIT_COM2(slotNumber, 2, 2);
			SET_CTRL_BIT_COM2(slotNumber, 2, 3);
			SET_CTRL_BIT_COM2(slotNumber, 2, 4);
			SET_CTRL_BIT_COM2(slotNumber, 2, 5);
			SET_CTRL_BIT_COM2(slotNumber, 2, 6);
			SET_CTRL_BIT_COM2(slotNumber, 2, 7);


			case PANEL_FPGA_READ_REG:

				/* read control regs */
				errorId=RWvmeBlock(READ, BASE_ADDRESS(slotNumber)+FPGA_CONTROL_0_REL_ADDR, fpgaControlReg, NUMBER_OF_FPGA_CONTROL_REGS, sizeof(UINT32), VME_ADDR_AUTOINCREMENT, BLOCK_ACCESS, 0);
				ERROR_CHECK(errorId, RWvmeBlock(READ));
				if(errorId!=SUCCESS) {
					break;
				}

				/* display control regs. */
				SetCtrlVal(panel, PANEL_FPGA_CONTROL_0, *(UINT8*)&fpgaControlReg[0]);
				//bitValue=(int) READ_BIT(fpgaControlReg[0], 0);
				//SetCtrlVal(panel, PANEL_FPGA_CONTROL_0_BIT_0, bitValue);
				DISPLAY_BIT(fpgaControlReg[0], 0, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 1, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 2, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 3, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 4, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 5, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 6, PANEL_FPGA_CONTROL_0_BIT_);
				DISPLAY_BIT(fpgaControlReg[0], 7, PANEL_FPGA_CONTROL_0_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_CONTROL_1, *(UINT8*)&fpgaControlReg[1]);
				DISPLAY_BIT(fpgaControlReg[1], 0, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 1, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 2, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 3, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 4, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 5, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 6, PANEL_FPGA_CONTROL_1_BIT_);
				DISPLAY_BIT(fpgaControlReg[1], 7, PANEL_FPGA_CONTROL_1_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_CONTROL_2, *(UINT8*)&fpgaControlReg[2]);
				SetCtrlVal(panel, PANEL_FPGA_COM2_BUTT_0, READ_BIT(fpgaControlReg[2], 0));
				DISPLAY_BIT(fpgaControlReg[2], 0, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 1, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 2, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 3, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 4, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 5, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 6, PANEL_FPGA_CONTROL_2_BIT_);
				DISPLAY_BIT(fpgaControlReg[2], 7, PANEL_FPGA_CONTROL_2_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_CONTROL_3, *(UINT8*)&fpgaControlReg[3]);
				DISPLAY_BIT(fpgaControlReg[3], 0, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 1, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 2, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 3, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 4, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 5, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 6, PANEL_FPGA_CONTROL_3_BIT_);
				DISPLAY_BIT(fpgaControlReg[3], 7, PANEL_FPGA_CONTROL_3_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_CONTROL_4, fpgaControlReg[4]);

				/* read status regs */
				errorId=RWvmeBlock(READ, BASE_ADDRESS(slotNumber)+FPGA_STATUS_0_REL_ADDR, fpgaStatusReg, NUMBER_OF_FPGA_STATUS_REGS, sizeof(UINT32), VME_ADDR_AUTOINCREMENT, BLOCK_ACCESS, 0);
				ERROR_CHECK(errorId, RWvmeBlock(READ));
				if(errorId!=SUCCESS) {
					break;
				}

				/* display status regs. */
				SetCtrlVal(panel, PANEL_FPGA_STAT_0, *(UINT8*)&fpgaStatusReg[0]);
				DISPLAY_BIT(fpgaStatusReg[0], 0, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 1, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 2, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 3, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 4, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 5, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 6, PANEL_FPGA_STAT_0_BIT_);
				DISPLAY_BIT(fpgaStatusReg[0], 7, PANEL_FPGA_STAT_0_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_STAT_1, *(UINT8*)&fpgaStatusReg[1]);
				DISPLAY_BIT(fpgaStatusReg[1], 0, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 1, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 2, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 3, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 4, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 5, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 6, PANEL_FPGA_STAT_1_BIT_);
				DISPLAY_BIT(fpgaStatusReg[1], 7, PANEL_FPGA_STAT_1_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_STAT_2, *(UINT8*)&fpgaStatusReg[2]);
				DISPLAY_BIT(fpgaStatusReg[2], 0, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 1, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 2, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 3, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 4, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 5, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 6, PANEL_FPGA_STAT_2_BIT_);
				DISPLAY_BIT(fpgaStatusReg[2], 7, PANEL_FPGA_STAT_2_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_STAT_3, *(UINT8*)&fpgaStatusReg[3]);
				DISPLAY_BIT(fpgaStatusReg[3], 0, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 1, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 2, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 3, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 4, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 5, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 6, PANEL_FPGA_STAT_3_BIT_);
				DISPLAY_BIT(fpgaStatusReg[3], 7, PANEL_FPGA_STAT_3_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_STAT_4, *(UINT8*)&fpgaStatusReg[4]);
				DISPLAY_BIT(fpgaStatusReg[4], 0, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 1, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 2, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 3, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 4, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 5, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 6, PANEL_FPGA_STAT_4_BIT_);
				DISPLAY_BIT(fpgaStatusReg[4], 7, PANEL_FPGA_STAT_4_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_STAT_5, *(UINT8*)&fpgaStatusReg[5]);
				DISPLAY_BIT(fpgaStatusReg[5], 0, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 1, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 2, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 3, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 4, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 5, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 6, PANEL_FPGA_STAT_5_BIT_);
				DISPLAY_BIT(fpgaStatusReg[5], 7, PANEL_FPGA_STAT_5_BIT_);

				SetCtrlVal(panel, PANEL_FPGA_STAT_6, fpgaStatusReg[6]&0x1FF); /* ROD serial number, 9 bits */

				SetCtrlVal(panel, PANEL_FPGA_STAT_7, (fpgaStatusReg[6]&0xFF0000)/0x10000); /* ROD revision */

				SetCtrlVal(panel, PANEL_FPGA_STAT_8, (fpgaStatusReg[6]&0x200)/0x200); /* InMem Size */

				SetCtrlVal(panel, PANEL_FPGA_STAT_9, (fpgaStatusReg[6]&0xFF000000)/0x1000000); /*  ROD ID*/

				SetCtrlVal(panel, PANEL_FPGA_STAT_10, (fpgaStatusReg[6]&0xF000)/0x1000); /* Prim Version */


				SetCtrlVal(panel, PANEL_FPGA_CONTROL_8, *(UINT8*)&fpgaStatusReg[7]);

			break;

			default:

			break;
		}
	}
	return 0;
}

/*=============================================================================
 *                               flashMenu()
 *=============================================================================
 *
 *
 *
 */
void CVICALLBACK flashMenu (int menuBar, int menuItem, void *callbackData,int panel){

	int status;
	char fpgaSettingsFile[260];
	ERROR_ID errorId;
	long fileSize;
	char fileName[PATHNAME_LENGTH];

	switch(menuItem){
		case FLASH_MENU_GOTO_MAIN:
			status=SetActivePanel(global.panel.main);
			UIR_STATUS_CHECK(status, SetActivePanel());
			break;
		case FLASH_MENU_CLOSE_WINDOW:
			status=HidePanel(panel);
			UIR_STATUS_CHECK(status, HidePanel());
			break;
		case FLASH_MENU_VIEW_BIN_FILE:
			status=FileSelectPopup(global.commonDataDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1,fileName);
			if(status==VAL_NO_FILE_SELECTED){
				break;
			}
			errorId=viewBinFile(fileName);
			ERROR_CHECK(errorId, viewBinFile());
			break;
		case FLASH_MENU_SAVE_SETTINGS:

			status = FileSelectPopup (global.fpgaDataDir, "*.cfg", "*.cfg", "",
									  VAL_SAVE_BUTTON, 0, 0, 1, 0,
									  fpgaSettingsFile);
				switch(status){
					case 0: /* no file selected */
						break;
					case 1: /* existing file selected */
						// no break here
					case 2: /* new file selected */
						status = SavePanelState(panel, fpgaSettingsFile, 0); ;
						//error check
						break;
					default:
						UIR_STATUS_CHECK(status, FileSelectPopup);
						break;

				}
			break;

		case FLASH_MENU_LOAD_SETTINGS:
			status=FileSelectPopup(global.fpgaDataDir, "*.cfg","*.cfg","Pick file", VAL_SELECT_BUTTON,0,0,1,1,fpgaSettingsFile);\
			if(status==VAL_NO_FILE_SELECTED){
				break;
			}
			status = RecallPanelState (panel, fpgaSettingsFile, 0);
			break;
	}
}

/*=============================================================================
 *                               fpgaMenu()
 *=============================================================================
 *
 *
 *
 */
void CVICALLBACK fpgaMenu (int menuBar, int menuItem, void *callbackData,int panel){

	int status;

	switch(menuItem){
		case FPGA_MENU_GOTO_MAIN:
			status=SetActivePanel(global.panel.main);
			UIR_STATUS_CHECK(status, SetActivePanel());
			break;
		case FPGA_MENU_CLOSE_WINDOW:
			status=HidePanel(panel);
			UIR_STATUS_CHECK(status, HidePanel());
			break;
	}
	return;
}



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

/*=============================================================================
 *                               eraseFlash()
 *=============================================================================
 *
 *
 *
 */
static ERROR_ID eraseFlash(unsigned char slotNumber, unsigned int flashBottomRelAddress,  const char flashName[], int newFlashLoc){

	int status;
	char text[50]="Erase ";
	ERROR_ID errorId;


	strcat(text, flashName);
	strcat(text, "?");

	status = ConfirmPopup ("", text);
	if(status!=1){
		return(SUCCESS);
	}

	strcpy(text, flashName);
	strcat(text," - erasing...");

	SetCtrlVal(global.panel.flashInfo, FLASH_INFO_FLASH_NAME, text);
	status=SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_VISIBLE, 0);
	UIR_STATUS_CHECK(status, SetCtrlAttribute());

	status=InstallPopup(global.panel.flashInfo);
	UIR_STATUS_CHECK(status, InstallPopup());

	errorId=chipErase(slotNumber, flashBottomRelAddress, newFlashLoc);
	ERROR_CHECK(errorId, chipErase());

	status=RemovePopup(1);
	UIR_STATUS_CHECK(status, RemovePopup());

	status=SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_VISIBLE, 1);
	UIR_STATUS_CHECK(status, SetCtrlAttribute());
	
	return(errorId);

}

/*=============================================================================
 *                               eraseFlash()
 *=============================================================================
 *
 *
 *
 */

static ERROR_ID readFlash(unsigned char slotNumber, unsigned int flashBottomRelAddress, const char flashName[50], int newFlashLoc){

	int status;
	char text[50];
	char fileName[PATHNAME_LENGTH];
	void *buffer;
	ERROR_ID errorId;
	int sectorSize;
	int flashSize;
	int numSectors;

	status = FileSelectPopup (global.fpgaDataDir, "*.bin", "*.bin", "",VAL_SAVE_BUTTON, 0, 0, 1, 0, fileName);
	switch(status){
		case 0: /* no file selected */
			break;
		case 1: /* existing file selected */
				/* no break here! */
		case 2: /* new file selected */
		
			if (newFlashLoc) {
				sectorSize= FLASH_SECTOR_SIZE_revE;
				flashSize=  FLASH_MEMORY_SIZE_revE;
				numSectors= NUMBER_OF_SECTORS_revE;
			} 
			else {
				sectorSize= FLASH_SECTOR_SIZE;
				flashSize=  FLASH_MEMORY_SIZE;
				numSectors= NUMBER_OF_SECTORS;
			}
		
		    strcpy(text, flashName);
		    strcat(text, " - reading...");
			SetCtrlVal(global.panel.flashInfo, FLASH_INFO_FLASH_NAME, text);
			status=SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_MIN_VALUE, 0);
			UIR_STATUS_CHECK(status, SetCtrlAttribute());
			status=SetCtrlAttribute(global.panel.flashInfo, FLASH_INFO_SECTOR, ATTR_MAX_VALUE, numSectors);
			UIR_STATUS_CHECK(status, SetCtrlAttribute());
			status=InstallPopup(global.panel.flashInfo);
			UIR_STATUS_CHECK(status, InstallPopup());
			buffer=calloc(flashSize, sizeof(UINT8));

			errorId=readBlockFromFlash(slotNumber, flashBottomRelAddress, buffer, flashSize, sectorSize);
			ERROR_CHECK(errorId, readBlockFromFlash());

			if(errorId!=SUCCESS){
				status=RemovePopup(1);
				UIR_STATUS_CHECK(status, RemovePopup());
				free(buffer);
				return(errorId);
			}

			errorId=writeToBinFile(fileName, 0, buffer, flashSize);
			free(buffer);
			ERROR_CHECK(errorId, writeToBinFile());
			if(errorId!=SUCCESS) return(errorId);

			status=RemovePopup(1);
			UIR_STATUS_CHECK(status, RemovePopup());

			errorId=viewBinFile(fileName);
			ERROR_CHECK(errorId, viewBinFile());

			break;
		default:
			break;
	}

	return(SUCCESS);
}

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