comemlif.cpp

The Lite Evaluation/Demonstration Kit is intended to illustrate use of the AN3042. The AN3042 is c

//////////////////////////////////////////////////////////////////////
//
// File: comemL_if.cpp 
//
// $Archive: /ComemL/Host/ComemLif/ComemLif.cpp $
//
//  
// Copyright (c) 1997 Anchor Chips, Inc.  May not be reproduced without
// permission.  See the license agreement for more details.
//
//////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include "comemDevice.h"

#define DEBUG 1

#ifdef DEBUG
DWORD fakedata[0x100];
#endif

int serial_device_addr = 0x50;
DWORD faked_data[0x10];


static FILE *simple_fp = NULL;
static FILE *verilog_fp = NULL;

// Write data from the host to the co-mem
errcodeE writeComemL(DWORD addr, DWORD data, DWORD comemID)
{
	CComemDevice *dev = comemDevL[comemID];

	if (dev->linBAR[0])
	    *((DWORD *) (dev->linBAR[0]+addr)) = data;

	// TBD -- fakedata is still used to save our state to the cfg file.  Keep writing it.
	fakedata[addr] = data;
    return(NO_MAPPER_ERROR);
}


// Read data from the co-mem to the host
DWORD readComemL(DWORD addr, DWORD comemID)
{
	CComemDevice *dev = comemDevL[comemID];
	
	if (dev->linBAR[0])
	    return(*((DWORD *) (dev->linBAR[0]+addr)));
	else 
		return fakedata[addr];
}


errcodeE wait_eeprom(int type, DWORD comemID)
{
   int readdata;

   for (timeout(2, FOREGROUND_TIMER); 
		!timeout(0, FOREGROUND_TIMER);)
			;
   for (readdata = 0, timeout(ONE_SECOND, FOREGROUND_TIMER); 
      (!(readdata & SERIAL_REG2_DONE_BIT));
      readdata = readComemL(ADDR_NVSTAT, comemID))
         if (timeout(0, FOREGROUND_TIMER))
            {
            // timed out -- try to read one more time, then report failure.
            readdata = readComemL(ADDR_NVSTAT, comemID);
            if (!(readdata & SERIAL_REG2_DONE_BIT))
              {
               return(ERROR_EEPROM_TIMEOUT);
              }
            }

   // Now check to see if we received three ACKs -- one for device address, one for device data, one for value
   int mask;
   if (type == EEPROM_READ)
      mask = SERIAL_WRITE_ACK_MASK;
   else
      mask = SERIAL_READ_ACK_MASK;

   if (readdata & mask)
      {
      report_error("Missed ACK -- Could be caused by an address beyond the eeprom boundaries or by more than one master device on the EEPROM bus.  If there is more than one master device, add retry code on missing ACKs.");
      return(ERROR_EEPROM_MISSED_ACK);
      }
   return(NO_MAPPER_ERROR);
}

// Write a block of memory to the eeprom
errcodeE writeEepromL(DWORD addr, unsigned char *blockptr, DWORD size, DWORD comemID)
{
   errcodeE error;
   if (addr + size > MAX_EEPROM_ADDR)
      report_error("writeEeprom() passed bad address.  Start = 0x%x, size = 0x%x", addr, size);

   while (size--)
     {
     int readdata = 0;

     writeComemL(ADDR_NVCMD, 
         (serial_device_addr << (24)) |
         ((addr & (EEPROM_ADDR_MASK-1)) << 16) |   // This may overlap the device address in large devices
         (*blockptr) << 8 |
         EEPROM_WRITE_ENABLE, comemID);

      // Wait for the device to be done
      error = wait_eeprom(EEPROM_READ, comemID);

      if (error == ERROR_EEPROM_TIMEOUT)
         report_error("Timed out writing address 0x%x in EEPROM.", addr);

	  if (error != NO_MAPPER_ERROR)
		  return error;
      blockptr++;
      addr++;
     }
   return(NO_MAPPER_ERROR);
}

// Read a block of memory from the eeprom
// The user is responsible for determining if the address is within the EEPROM, since this software
// must support very large devices.
errcodeE readEepromL(DWORD addr, unsigned char *blockptr, DWORD size, DWORD comemID) 
{ 
   errcodeE error;
   char *byteptr;
   DWORD inData;

   while (size)
     {
      writeComemL(ADDR_NVCMD, 
         (serial_device_addr << (24)) |
         ((addr & (EEPROM_ADDR_MASK-1)) << 16) |   // This may overlap the device address in large devices
         EEPROM_4READ_ENABLE, comemID);

      // Wait for the device to be done
      error = wait_eeprom(EEPROM_READ, comemID);

      if (error == ERROR_EEPROM_TIMEOUT)
         report_error("Timed out reading address 0x%x in EEPROM.", addr);


	   if (error != NO_MAPPER_ERROR)
		  return error;
      // TBD -- processing blocks that span multiple EEPROMs.

      // Save the data that was requested.  Be careful to only store the requested data.
      // The EEPROM address may be misalined.  The EEPROM doesn't care.
      inData = readComemL(ADDR_NVREAD, comemID);

      byteptr = (char *) &inData;
      for (int i = 0; i < 4 && size; i++, size--)
        {
        *blockptr++ = *byteptr++;
        }
      addr += 4;
     }
   return(NO_MAPPER_ERROR);
}

errcodeE fake_write(DWORD addr, DWORD data, DWORD comemID) 
{
   faked_data[(addr & 0xf)/4] = data;
   return NO_MAPPER_ERROR;
}