ata.c

Utils and test SD card read write cycles

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
#include <ctype.h>
#if !RTK
#define  ROM_ACTIVE    1
#include "pcmrtk.h"
#else
#define  ROM_ACTIVE    0
#include <sys/hyrtk.h>
#include "myrtk.h"
#endif
#include "ata2.h"

#define LOG_TO_PHYS    256

#define MAX_CYCLING_BUFFERS     4
#define MAX_CYC_ERRORS          32


#define CYC_ERROR_PROGRAM               1
#define CYC_ERROR_ERASE                 2
#define CYC_ERROR_READ                  3
#define CYC_ERROR_COMPARE               4
#define CYC_ERROR_BUFFERS_FULL          5
#define CYC_ERROR_BUFFER_INDEX_EXCEED   6

unsigned int StartBlock;
unsigned int NumberOfBlocks;
unsigned int NumberOfCycles;
unsigned int TotalCycles;
unsigned int ErrorSector;
unsigned int index;    

unsigned char cycBuffer[MAX_CYCLING_BUFFERS][512];
unsigned int MaxBufferIndex = 0;    // how many buffers are full
unsigned int CyclingErrors = 0;     // how many errors exists
typedef struct 
{
    unsigned int    cycle;
    unsigned int    eraseSector;
    unsigned char   errorCode;
} CYC_ERROR;

CYC_ERROR cycErrorArray[MAX_CYC_ERRORS];


extern unsigned char EraseSectorBuffer[4];
register unsigned int EventFlags asm("G6");        /* for rtk and nortk */
register unsigned int BCRShadow  asm("G10");
register unsigned int FCRShadow  asm("G11");
register unsigned int MCRShadow  asm("G12");
register unsigned int OverlappedFlags asm("G13");
unsigned int NumberOfFFBytes;
unsigned int NextSectorNumber;

unsigned int SkipErase = 0;
unsigned int SkipProgram = 0;
extern unsigned char ChunkTab[4];

unsigned char CommandCode, MinorCommandCode;

char FirmwareRevision[12] = "Test Firware";

static void CycleTest();
static void CycleTestRead();
static void MMCInitCode();
extern void FlashIdle1TrapEntry(unsigned int ChipNumber);
extern unsigned int ReadSectorFromFlash(unsigned int LogSectorNumber, unsigned char *SectorBuffer);
// WriteSectorToFlash() is a macro to
extern unsigned int WriteSector(unsigned int SectorNumber, unsigned char *Buffer, unsigned char *ChunkTab, unsigned int SkipProgram, unsigned int Overhead);
extern void TerminateWriteCommand();

#if !ROM_ACTIVE
extern void FlashTrap();


/*===========================================================================*/
/* GetMinorCommandCode                                                       */
/*===========================================================================*/

unsigned int GetMinorCommandCode()
{
  return READ_SECOND_ARGUMENT() & 0x1f;
}

/*===========================================================================*/
/* GetVendorCommandCode                                                      */
/*===========================================================================*/

unsigned int GetVendorCommandCode()
{
  return READ_ADDRESS() & 0x1ff;
}


/*===========================================================================*/
/* PcmciaInterruptEntry                                                      */
/*===========================================================================*/

void PcmciaInterruptEntry()
{
int InterruptSource, LocalCode;
#if !RTK
unsigned char **p;
#define CommandCode      **p
#define MinorCommandCode (*((*p)+1))

  p = (unsigned char **)0xc00000a8;
#endif

  InterruptSource  = READ_INTREG();
  if (InterruptSource & HY_READ)
    {
      CLEAR_HY_READ();
      CLEAR_DUMMY();
      LocalCode = GetMinorCommandCode();
      MinorCommandCode = LocalCode;
      CommandCode = (LocalCode==COUNT_READ)?READ_OPC:READ_STATUS_OPC;
      SET_EVENT(CLEARGUARD_EVENT|COMMAND_EVENT);
      return;
    }
  if (InterruptSource & HY_WRITE)
    {
      CLEAR_HY_WRITE();
      CLEAR_DUMMY();
      LocalCode = GetMinorCommandCode();
      MinorCommandCode = LocalCode;
      CommandCode = (LocalCode==COUNT_WRITE)?WRITE_OPC:SPECIALWRITE_OPC;
      SET_EVENT(CLEARGUARD_EVENT|COMMAND_EVENT);
      return;
    }
  if (InterruptSource & HY_AGAIN)
    {
      CLEAR_HY_AGAIN();
      CLEAR_DUMMY();
      SET_EVENT(CLEARGUARD_EVENT|AGAIN_EVENT);
      return;
    }
  if (InterruptSource & HY_CLEAR)
    {
      CLEAR_HY_CLEAR();
      CLEAR_DUMMY();
      CommandCode = ERASE_OPC;
      SET_EVENT(CLEARGUARD_EVENT|COMMAND_EVENT);
      return;
    }
  if (InterruptSource & HY_STOP)
    {
      CLEAR_HY_STOP();
      CLEAR_DUMMY();
      SET_EVENT(CLEARGUARD_EVENT|STOP_EVENT);
      return;
    }
  if (InterruptSource & HY_CMD)
    {
      CLEAR_HY_CMD();
      CLEAR_DUMMY();
      CommandCode = VENDOR_OPC;
      MinorCommandCode = GetVendorCommandCode();
      SET_EVENT(CLEARGUARD_EVENT|COMMAND_EVENT);
      return;
    }
#if 0  
  if (InterruptSource & HY_DEBUG_CMD)
    {
      CLEAR_HY_DEBUG_CMD();
      return;
    }
  if (InterruptSource & HY_DEBUG_RES)
    {
      CLEAR_HY_DEBUG_RES();
      return;
    }
#else
  if (InterruptSource & (HY_DEBUG_CMD|HY_DEBUG_RES))
    {
      CLEAR_HY_DEBUG_INT();
      return;
    }
#endif
}
/*===========================================================================*/
/* FlashReadyInterruptEntry                                                  */
/*===========================================================================*/

void FlashReadyInterruptEntry ()
{
#ifdef NORTK
  DISABLE_IO1();     // Disable FlashReady: UpdateFCR(7,0);
#else
  UpdateFCR(7,0);    // Disable FlashReady
#endif
  SET_EVENT(FLASH_EVENT|CLEARGUARD_EVENT);
  OverlappedFlags = 0;
  FlashIdle1(0);
}

/*===========================================================================*/
/* Define Interrupt-Level-Tasks                                              */
/*===========================================================================*/


void MyOwnWaitGuard(unsigned int EventBits)
{
  ClearLockFlag();
  if (EventBits & FLASH_EVENT)
    while (!EVENT(EventBits) && ((GetISR() & (1<<4)) == 0));
  else
    while (!EVENT(EventBits));
}

void MyOwnWaitGuardMax(unsigned int EventBits, unsigned long TimeUnits)
{
  ClearLockFlag();
  asm volatile ("ori   SR, $20");  /* set high global */
  asm volatile ("mov   L4, G7");   /* timer register */
  asm volatile ("add   L1, L4");   /* end time */

  asm volatile ("__MyOwnGuardMaxLab__:");
  if (EVENT(EventBits))
    return;
  asm volatile ("ori   SR, $20");  /* set high global */
  asm volatile ("mov   L4, G7");   /* timer register */
  asm volatile ("cmp   L1, L4");   /* end time */
  asm volatile ("bht   __MyOwnGuardMaxLab__");
}
#else

extern void FlashReadyInterruptEntry();
#endif

#if RTK
#define IO1         15

InterruptLevelTCBType PcmciaDriverTCB =
 {(InterruptLevelTask<<8) + INT1, PcmciaInterruptEntry, NULL, NULL};

InterruptLevelTCBType FlashReadyTCB =
 {(InterruptLevelTask<<8) + IO1, FlashReadyInterruptEntry, NULL, NULL};

void SetSupervisorMode()
{
asm volatile ("ORI    L0, 1");    /* set supervisorbit in return PC */
}
#endif



#if !ROM_ACTIVE
/*===========================================================================*/
/* WaitDRQ                                                                   */
/*===========================================================================*/

unsigned int WaitDRQ(unsigned int SectorCount)
{
  WaitGuard(PC_EVENT);
  if (EVENT(AGAIN_EVENT))
    {
      RESET_EVENT(AGAIN_EVENT);
      if ((SectorCount-1) == 0)
	{
	  SET_HY_CNT_READY();
	  return FALSE;
	}
    }
  else
    {
      RESET_EVENT(STOP_EVENT);
      return FALSE;
    }
  return TRUE;
}
/*===========================================================================*/
/* GetSectorOffset                                                           */
/*===========================================================================*/

unsigned int GetSectorOffset()
{
  return READ_ADDRESS() & 0x1ff;
}

/*===========================================================================*/
/* GetSectorLength                                                           */
/*===========================================================================*/

unsigned int GetSectorLength()
{
  return (READ_SECOND_ARGUMENT() >> 5) & 0x1ff;
}
/*===========================================================================*/
/* SendOCR                                                                   */
/*===========================================================================*/

void SendOCR(unsigned int OCR)
{
  outpw2r(OCR_ADDR , OCR)
}

/*===========================================================================*/
/* SendCSD                                                                   */
/*===========================================================================*/

void SendCSD(unsigned int *Buffer)
{
unsigned int i;

  for (i=5; i<9; i++)
    outpw2r(FPGA_REGADDR | (i<<13), *Buffer++)
}

/*===========================================================================*/
/* SendCID                                                                   */
/*===========================================================================*/

void SendCID(unsigned int *Buffer)
{
unsigned int i;

  for (i=1; i<5; i++)
    outpw2r(FPGA_REGADDR | (i<<13), *Buffer++)
}

/*===========================================================================*/
/* SendMMC                                                                   */
/*===========================================================================*/

void SendMMC(unsigned int MMC)
{
  outpw2r(MMCREG_ADDR, MMC)
}
/*===========================================================================*/
/* TerminateWriteCommand                                                     */
/*===========================================================================*/

void TerminateWriteCommand()
{