///////////////////////////////////////////////////////////////-*-C-*-
//
// Copyright (c) 2006 Xilinx, Inc.  All rights reserved.
//
// Xilinx, Inc.  XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION
// "AS IS" AS  A COURTESY TO YOU.  BY PROVIDING  THIS DESIGN, CODE, OR
// INFORMATION  AS  ONE   POSSIBLE  IMPLEMENTATION  OF  THIS  FEATURE,
// APPLICATION OR  STANDARD, XILINX  IS MAKING NO  REPRESENTATION THAT
// THIS IMPLEMENTATION  IS FREE FROM  ANY CLAIMS OF  INFRINGEMENT, AND
// YOU ARE  RESPONSIBLE FOR OBTAINING  ANY RIGHTS YOU MAY  REQUIRE FOR
// YOUR  IMPLEMENTATION.   XILINX  EXPRESSLY  DISCLAIMS  ANY  WARRANTY
// WHATSOEVER  WITH RESPECT  TO  THE ADEQUACY  OF THE  IMPLEMENTATION,
// INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OR REPRESENTATIONS THAT
// THIS IMPLEMENTATION  IS FREE  FROM CLAIMS OF  INFRINGEMENT, IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// 
//////////////////////////////////////////////////////////////////////

#include "hwinst.h"
#include "xparameters.h"
#include "proc.template.h"
static unsigned int hwinst_retryVal = 100;

// ------------------------------
// ------------------------------
// --- Write functions        ---
// ------------------------------

int hwinst_Write(unsigned int memName, unsigned int addr, unsigned int val) {
  // Write the address first -- NB add can overwrite mask. 
  // Assert addr < (2^20)

  int mask = (SG_SINGLEWRITE | (memName ^ addr));
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  int fslstatus;
  #endif

  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
    HWINST_NPUT_WITHSTATUS(mask,fslstatus);
    if (fslstatus) return -1;
    HWINST_NPUT_WITHSTATUS(val,fslstatus);
    if (fslstatus) return -2;
  #else
    HWINST_NPUT(mask);
    HWINST_NPUT(val);
  #endif
  return 0;
}


int hwinst_ArrayWrite(unsigned int memName,unsigned int startAddr,
            unsigned int transferLength, const unsigned int* valBuf){
	int mask;
	int regmask;
	int itemCnt;
	int	lp;
	int bank;

  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  int fslstatus;
  #endif

  if (memName==FIFO_BANK){
    // Array writes to bank 2, i.e. FIFOs, so no need for address counter.
    mask = (SG_SINGLEWRITE | (memName ^ startAddr));
  }
  else {
    mask = (SG_ARRAYWRITE | (memName ^ startAddr));
  }
  regmask = (SG_SETCOUNTER | transferLength);
	
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
    HWINST_NPUT_WITHSTATUS(regmask,fslstatus);
    if (fslstatus) return -1;
    HWINST_NPUT_WITHSTATUS(mask,fslstatus);
    if (fslstatus) return -2;
  #else
    HWINST_NPUT(regmask);
    HWINST_NPUT(mask);
  #endif

  for (lp=0; lp<transferLength;) {
    #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
      HWINST_NPUT_WITHSTATUS(valBuf[lp],fslstatus);
      if (fslstatus == 0) lp++; else break;
    #else
      HWINST_NPUT(valBuf[lp++]);
    #endif
  }
  return lp;
}


// ------------------------------
// ------------------------------
// --- Read  functions        ---
// ------------------------------

int hwinst_Read(unsigned int memName,unsigned int addr,unsigned int* val){
  int mask = (SG_SINGLEREAD | (memName ^ addr));
  #ifdef HWINST_SG_ENABLE_POLLING_FSL_DRIVERS
  unsigned int retry = 0;
  #endif
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  int fslstatus;
  #endif

  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
    HWINST_NPUT_WITHSTATUS(mask,fslstatus);
    if (fslstatus) return -1;
    #ifdef HWINST_SG_ENABLE_POLLING_FSL_DRIVERS
    do {
    #endif	 
    HWINST_NGET_WITHSTATUS(*val,fslstatus);
    #ifdef HWINST_SG_ENABLE_POLLING_FSL_DRIVERS
    } while( (fslstatus!=0) && (retry++ < hwinst_getMaxRetry()));
    #endif
    if (fslstatus) return -2;
  #else
    HWINST_NPUT(mask);
    asm("nop");
    asm("nop");	 	
    HWINST_NGET(*val);
  #endif

  return 0;
}

int hwinst_ArrayRead(unsigned int memName,unsigned int startAddr,
            unsigned int transferLength, unsigned int** valBuf) {
  int lp, mask, itemCnt;
  #ifdef HWINST_SG_ENABLE_POLLING_FSL_DRIVERS
  unsigned int retry = 0;
  #endif
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  int fslstatus;
  #endif
    
  // -- Write transferLength to memmap
  mask = (SG_WRITESTATUSREG | SG_SETCOUNTER | transferLength);
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  HWINST_NPUT_WITHSTATUS(mask,fslstatus);
  if (fslstatus) return -1;
  #else
  HWINST_NPUT(mask);
  #endif
	
  if (memName == FIFO_BANK){
    mask = (SG_SINGLEREAD | (memName ^ startAddr));
  }
  else{
    // Write command for multiple reads with addr increment
    mask = (SG_ARRAYREAD | (memName ^ startAddr));
  }
	
	
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  HWINST_NPUT_WITHSTATUS(mask,fslstatus);
  if (fslstatus) return -2;
  #else
  HWINST_NPUT(mask);
  #endif
	
  // -- copy results from FSL to buffer --
  for (lp=0; lp<transferLength; ) {
  #ifdef HWINST_SG_ENABLE_FSL_ERROR_CHECK
  #ifdef HWINST_SG_ENABLE_POLLING_FSL_DRIVERS
  do {
  #endif
  HWINST_NGET_WITHSTATUS(valBuf[lp], fslstatus);
  #ifdef HWINST_SG_ENABLE_POLLING_FSL_DRIVERS
  } while( (fslstatus!=0) && (retry++ < <hwinst>_getMaxRetry()));
  #endif
  if (fslstatus == 0) lp++; else break; 
  #else
  HWINST_NGET(valBuf[lp++]);
  #endif
  }
 
  return lp;
}


// ------------------------------
// ------------------------------
// --- Retry  settings        ---
// ------------------------------
unsigned int hwinst_getMaxRetry() {
   return hwinst_retryVal;
}

void hwinst_setMaxRetry(unsigned int val){
   hwinst_retryVal = val;
}

void hwinst_flushReadFIFO() {
   int fslstatus;
   unsigned int *val;
   do {	 
    HWINST_NGET_WITHSTATUS(val,fslstatus);
   } while (fslstatus==0);
}