/************************************************************************************
 * fxnProto.h
 *
 *  synopsis: Function prototypes.
 *
 *  Damon Fasching, UW Madison                             fasching@wisconsin.cern.ch
 *  Douglas Ferguson, UW Madison   (510) 486-5230          dpferguson@lbl.gov
 ************************************************************************************/
#ifndef FUNCTION_PROTOTYPES
#define FUNCTION_PROTOTYPES

#include <csl.h>
#include <csl_timer.h>

#include "processor.h"
#include "msgBuff.h"
#include "primFuncts.h"
#include "primParams.h"
#include "eventHandler.h"
#include "txtBuffer.h"
#include "drand48.h"

#include "taskManager.h"
#if defined(I_AM_MASTER_DSP)
	#include "serialStreams.h"
#elif defined(I_AM_SLAVE_DSP)
	#include "histogram.h"
#endif

#if defined(SCT_ROD)
	#include "fxnProto_sct.h"
#elif defined(PIXEL_ROD)
	#include "fxnProto_pxl.h"
	#include "fittingRoutines.h"
#endif

//rodRun.c:
void  chipInit(void);
INT32 extInit(void);
void  mainLoop(void);

#if defined(I_AM_MASTER_DSP)
	//accessSlave.c:
	void writeSlvHPIC(UINT32, UINT32);
	void writeSlvHPIA(UINT32, UINT32);
	void writeSlvHPID(UINT32, UINT32);
	void writeSlvHPID_I(UINT32, UINT32);

	UINT32 readSlvHPIC(UINT32);
	UINT32 readSlvHPIA(UINT32);
	UINT32 readSlvHPID(UINT32);
	UINT32 readSlvHPID_I(UINT32);

	void writeSlvBlock(UINT8 slv, UINT32 *slvPtr, UINT32 *ptr, UINT32 len);
	void readSlvBlock(UINT8 slv, UINT32 *slvPtr, UINT32 *ptr, UINT32 len);
	
	//simulation.c:
	void   copySdspRegs(UINT32 sdsp, UINT32 toIdram);
	UINT32 *remapSdspPtr(UINT32 sdsp, UINT32 *sdspPtr);

	//accessFifo.c:
	INT32 accessFifo(UINT32 fifoId, UINT32 bank, UINT32 readNotWrite, UINT32 numElements,
	                  UINT32 *data, UINT32 *bytesXfrd);
	INT32 waitSerialCaptureComplete(void);
	//int extractInmemLink(void *inmemBuff, int link, void *outBuff, int size,
	//                     int *nWordsWritten, int flags);
	//int extractInmemLink(void *inmemBuff, int link, void *outBuff, int size, int flags);
	UINT8 fmtLinkToHwLink(UINT8 fmtLink);
	void  extractRawLink(int hwLink, UINT32 *dst, int extractData);
	void  resetCaptureBuffer();
	INT32 inmemCaptureNext(int fmtLink, void *dest, int extractData);

	//boc.c
	void  bocRegDecode(UINT32 id, UINT8 *bocReg, UINT8 *link);
	INT32 setBocVariable(UINT8 link, UINT8 type, UINT8 val);
	INT32 getBocVariable(UINT8 link, UINT8 type, UINT8 *val);
	INT32 configureBoc(void);

	//commTest.c:
	INT32 sdspCommTest(void *ptr);
	
	//errorCheck.c:
	INT32 moduleIndexCheck(UINT32 cfgSet, UINT32 module, UINT8 single, UINT8 checkPresent,
	                       UINT8  cfgBitfield);
	INT32 checkSdspStatus(UINT8 sdsp, UINT8 testBits, char *routineName);
	
	//flash.c:
	INT32 programFlash(INT32 len, void *base);
	INT32 flashProductInfo(void);

	//resetRod.c
    void  resetSlave(UINT8);
    INT32 resetSlaveSync(UINT8, UINT8, UINT32, UINT32, UINT8);
    void  resetRod(UINT8);
    INT32 waitPRMAck(UINT32, UINT8);
    INT32 waitRodBusy(void);

	//rodConfiguration.c:
	UINT8 getRodRev(void);
	UINT8 slvPresent(UINT8 slv);
	INT32 setSlvClk(UINT8 slv, UINT8 MHzDiv20);
	void  setLemoLink(UINT8 fmtLink);
	INT32 rodMode(UINT32 mode, UINT8 flag, UINT8 fifoSetup, UINT32 nBits, UINT32 delay,
	              UINT32 evtsPerL1A, UINT8 message);
	UINT32 atlasRunMode(void);
	
	INT32 setMaskConfig(UINT8 moduleNum, UINT8 cmdLine, UINT8 fmtLink[2]);
	void  switchLinkMasks(UINT32 maskType, UINT8  maskSet);
	void  setLinkMasks(UINT8 mod, UINT8 sp, UINT32 maskType, UINT8 storage, UINT8 maskSet);
#endif

//smHostListProc.c:
INT32 smHostListProc(void);
void setPausedByPrim(void);

//rodConfiguration.c (common):
void  initRodConfig(void);

#ifdef I_AM_MASTER_DSP  
	void storeReplyParams(UINT32 sdsp, UINT32 *slaveRepData);
	void initiateSlvList(UINT32 sdsp, UINT32 pauseMasterList, UINT32 getSlaveReply);
	void initiateSlvPause(UINT32 sdsp);
	void initiateSlvResume(UINT32 sdsp);
	void initiateSlvAbort(UINT32 sdsp);
	void copySlvReply(UINT32 sdsp);
void decAttendSlvReply(void);
void incAttendSlvReply(void);

void setPausedBySlave(void);
void rstPausedBySlave(void);
void abortSlvListSMs(void);
	INT32 smHostListToSlave(UINT32 sdsp);
	UINT32 slvHostListIdle(UINT32 sdsp);
	UINT32 *getReplyDest(UINT32 sdsp);
#endif

INT32 smIntrDspListProc(void);
INT32 idspListSend(UINT32 sdsp, UINT32 timeoutIn);
UINT32 intrDspListSendIdle(void);
INT32 smIntrDspListSend(void);
INT32 addMessage(UINT32 buffNum, UINT32 buffIdx, UINT32 msgId, UINT32 msgRevision,
                  UINT32 msgBodyLength, UINT32 *msgBodyPtr);
INT32 addReplyData(PrimData *primData, void *ptr, UINT32 nWords);

#ifdef I_AM_MASTER_DSP
	void initiateListSendSM(UINT32 sdsp);
UINT32 replyDataAvail(void);
#endif

#ifdef I_AM_SLAVE_DSP
void initiateListSendSM(UINT32 dummy);
#endif

void newError(INT32 *errorKeep, INT32 error, INT32 severity, char routine[],
              char message[], char file[], INT32 line);
void addError(INT32 *errorKeep, INT32 error, char routine[], char branch[],
              char file[], INT32 line);
void setErrMask(UINT32 errMask);
UINT32 getErrMask();
void addErrorInfo(char file[], INT32 line, char message[]);
void newInformation(char file[], INT32 line, char message[]);
void addInformation(char file[], INT32 line, char message[]);
void newDiagnostic(char file[], INT32 line, char message[]);
void addDiagnostic(char file[], INT32 line, char message[]);
#ifdef I_AM_MASTER_DSP
	void newXfer(char [], INT32, char []);
	void addXfer(char [], INT32, char []);
#endif

void initPrimListStructs(void);
void resetPrimListStructs(UINT32 buffNum);
INT32 readListWrapper(UINT32 buffNum, UINT32 buffIdx, UINT32 *index);
void getPrimIndex(UINT32 buffNum, UINT32 *index);
INT32 execPrim(UINT32 buffNum, UINT32 *listDone);
UINT32 replyAvailable(UINT32 buffNum);
void addListWrapper(UINT32 buffNum, UINT32 buffIdx, UINT32 listIdx);
void initPrimParams(void);

#if defined(I_AM_MASTER_DSP)
void loadSlaveList(UINT32 slaveIdx, UINT32 listLength, UINT32 *slavePrimList);
void getReplyMsg(UINT32 bfrNum, UINT32 *msgBodyPtr, UINT32 *msgBodyLength,
                 UINT32 *listDone);
#endif
UINT32 getIntrDspAck(void);

INT32 getNewListInfo(struct MSG_LIST *);

void initializePrimParams(UINT32 primIDList[],
                          struct PRIM_PARAMETERS primParams[], UINT32 *listRevision);

#if defined(I_AM_MASTER_DSP)
	//getSlaveTxtBuff.c:
	void initGetSlvTxtBuffSM(UINT32 sdsp);
	void readSlvTxtBuffAddr(UINT32 sdsp);
	INT32 getSlvTxtBuffs(UINT32 sdsp);

	//accessRegister.c:
	INT32 writeRegister( UINT32 id, UINT32 width, UINT32 offset, UINT32 value);
	INT32 readRegister( UINT32 id, UINT32 width, UINT32 offset, UINT32 *value);
	INT32 initRegisterArray(void);

	#ifndef TI_EVM
	//void initRrif(void);
	#endif
#endif 

void setRunningBit(void);

INT32 initialize(void);
INT32 checkMemBound(void);

/* initEmif.c */
  INT32 initEmif(void);
  #ifdef I_AM_MASTER_DSP
    INT32 initSlvEmif(UINT8 slv);
  #endif

#if defined(I_AM_MASTER_DSP)
INT32 loadCode(void);
void setSlaveConfig(UINT32 sdsp, UINT32 commOnOff, UINT32 slaveType);
UINT32 numSlaves(void);
INT32 slaveIsOn(UINT32 sdsp);
UINT32 slaveIsMemType(UINT32 sdsp);
void initHostListToSlaveSM(UINT32 sdsp);
#endif

void initSerialPorts(void);

#ifdef I_AM_MASTER_DSP
void setCalibrationParams(UINT32 numPulses, UINT32 period, UINT32 tCalToL1,
                          UINT32 tL1ToL1);
#endif

void initSendTxtBuffSM(void);
INT32 sendTxtBuffs(void);
INT32 txtBuffSMIdle(UINT32);

void startHeartbeatTimer(UINT32 period);
TIMER_Handle startUserTimer(UINT32 period);

//utilities.c:
UINT32 calculateChecksum(UINT32 *baseAddress, INT32 checksumWC);
INT32 setMem(void *dst, UINT32 len, UINT32 val);
INT32 copyMem(void *src, void *dst, UINT32 len);
void  setLedState(UINT8, UINT8);
UINT8 getLedState(UINT8);
#ifdef I_AM_MASTER_DSP
  INT32 parseInmem(UINT8 inmem, UINT32 linkFieldHi, UINT32 linkFieldLow,
                   UINT32 *linkBufferBase);
  INT32 chkSlaves(UINT8, UINT8 *, UINT32, UINT8);
#endif
void waitRegister(UINT32, UINT8, UINT8);
void codeVersion(void);

//validate.c:
INT32 pass_validate(UINT32 revision, PrimData *primData);
INT32 startTask_validate(UINT32 revision, PrimData *primData);

//rodConfiguration.c:
UINT32 boardClockInMHz(void);
UINT32 DSPClockInMHz(void);

//accessCommRegs.c:
void initCommRegs(void);
void setRunning(void);
void initListComRegs(void);
void setBusy(void);
void rstBusy(void);
void setExecuting(void);
void rstExecuting(void);
void setPaused(void);
void rstPaused(void);
void assignOutListRdy(UINT32 outListRdy);
void setDspAck(void);
void rstDspAck(void);
void setTxtBuffNE(UINT32 txtBuffNum);
void rstTxtBuffNE(UINT32 txtBuffNum);
void setTxtBuffProc(UINT32 txtBuffNum);
void rstTxtBuffProc(UINT32 txtBuffNum);
void setListFatal(UINT32 error);
void setListError(UINT32 error, UINT32 count);
void loadPrimListIndex(UINT32 value);
void loadPrimIndex(UINT32 value);
UINT32 getInListRdy(void);
UINT32 getPause(void);
UINT32 getResume(void);
UINT32 getAbort(void);
UINT32 getTxtBuffRR(UINT32 txtBuffNum);
#ifdef I_AM_SLAVE_DSP
UINT32 getSlvID(void);
#endif

#if defined(I_AM_MASTER_DSP)
	void setSlvInListRdy(UINT32 sdsp);
	void rstSlvInListRdy(UINT32 sdsp);
	void setSlvPause(UINT32 sdsp);
	void rstSlvPause(UINT32 sdsp);
	void setSlvAbort(UINT32 sdsp);
	void rstSlvAbort(UINT32 sdsp);
	void toggleSlvResume(UINT32 sdsp);
	void setSlvID(UINT32 sdsp);
	void setSlvTxtBuffRR(UINT32 sdsp, UINT32 buffer);
	void rstSlvTxtBuffRR(UINT32 sdsp, UINT32 buffer);
	UINT32 getSlvRunning(UINT32 sdsp);
	UINT32 getSlvPaused(UINT32 sdsp);
	UINT32 getSlvAck(UINT32 sdsp);
	UINT32 getSlvOutListRdy(UINT32 sdsp);
	UINT32 getSlvResume(UINT32 sdsp);
	UINT32 getSlvTxtBuffNE(UINT32 sdsp, UINT32 buffer);

	void   initSdspRegAddr(void);

	void   setSlvRegBit(UINT32 sdsp, UINT32 regAddress, UINT32 bitNum);
	void   rstSlvRegBit(UINT32 sdsp, UINT32 regAddress, UINT32 bitNum);
	UINT32 getSlvRegBit(UINT32 sdsp, UINT32 regAddress, UINT32 bitNum);
	void   setSlvReg(UINT32 sdsp, UINT32 regAddress, UINT32 val);
	UINT32 getSlvReg(UINT32 sdsp, UINT32 regAddress);
#endif

UINT32 getTimerCnt(void);
#if defined(I_AM_MASTER_DSP)
	void yellowBop(void);
	INT32 setupRouter(UINT32, UINT32, UINT32, UINT32, UINT32, RouterTrapParams[]);
	
	
	/* serialStreams.c */
	void interleave(UINT32 [], UINT32 *[],  UINT32 **, UINT32 *);
	void serialOut(UINT8 sp);
	//void serialOut(CmdBuff *cb);
	void serialStreamOut(UINT32, TransData *, UINT32);
	/*void serialStreamOut(unsigned char, UINT32 *[], UINT32 []);*/
	
	void initCmdBuffer(UINT8 sp);
	void initCmdBuff(CmdBuff *cmd, UINT32 *data[], UINT32 *ilBuff, UINT32 size,
                          UINT8 sp, UINT8 module[]);
	INT32 makeStreamSet(struct CmdList *cmdList0, struct CmdList *cmdList1, UINT8 init,
	                    UINT8 chip, UINT8 fibre, UINT32 dataLen, UINT32 *data,
	                    UINT32 **ptr, UINT32 *nSets, UINT8 doInterleave);
#endif

#if defined(I_AM_SLAVE_DSP)

	void initExtPinGpio(void);

	//eventHandler.c:
	INT32  initiateTrapping(void);
	void   stopTrapping(void);
	INT32  initEvtMgrStructs(void);
	INT32 initEventManager(UINT32 numberOfEvents,      UINT32 releaseFrames,
	                       UINT32 permitBackPressure,  UINT32 dataMode,   UINT32 sLink,
	                       UINT32 format,              UINT32 trapStray,
	                       RouterTrapParams traps[2]);
	
	struct EventData *getNextEvent(void);
	void   copyEvent(struct EventData *, UINT32 *);
	UINT32 getFramePtr(unsigned char);
	unsigned char getNextFrame(struct EventData *, unsigned char,unsigned char);
	void processEvent(struct EventData *, unsigned char);

	#if defined(TI_EVM)
		//void clearRegisters(void);
		//void getRegisters(void);
	#endif

	#if defined(REV_E)
		void cacheOn(void);
		void cacheOff(void);
		void flushL2Range(UINT32 *ptr, UINT32 len);
	#endif

#endif

//task routine files:
#if   (defined(I_AM_MASTER_DSP))
	INT32 histoCtrlTask(TaskInput *, TaskOutput *, UINT32);
	INT32 mirrorTask   (TaskInput *, TaskOutput *, UINT32);
	INT32 trapReqTask  (TaskInput *, TaskOutput *, UINT32);

#elif (defined(I_AM_SLAVE_DSP))
	INT32 histogramTask(TaskInput *, TaskOutput *, UINT32);
	INT32 trapTask     (TaskInput *, TaskOutput *, UINT32);
	INT32 errorTask    (TaskInput *, TaskOutput *, UINT32);
	INT32 occupancyTask(TaskInput *, TaskOutput *, UINT32);
	INT32 resynchTask  (TaskInput *, TaskOutput *, UINT32);
#endif

//taskManager.c:
INT32 initTaskManager(void);
void setTaskState(UINT8 taskType, UINT8 state);	
UINT8 getTaskState(UINT8 taskType);	
TaskOutput *getTaskData(UINT8 taskType);
INT32 insertTask(UINT32, UINT32, UINT32, UINT32, TaskInput *);
INT32 taskOp(UINT8, UINT8, UINT32, UINT32);
INT32 taskManager(void);
INT32 currentTask(UINT8);

//txtBuffer.c:
INT32 txtNewBufferEntry(struct TXTBUFFER *buffer, char *file, 
					    INT32 line, char *txtMessage);
INT32 txtAddBufferEntry(struct TXTBUFFER *buffer, char *file, 
					    INT32 line, char *txtMessage);
INT32 txtMarkBufferRead(struct TXTBUFFER *buffer);

#endif  //Multiple inclusion protection