ata.c

Utils and test SD card read write cycles

#if RTK
  CLEAR_HY_RESET();
  SendMMC(2);  // 2 = SD Card
               // 1 = MMC Card
  InitUserTrap(17, &SetSupervisorMode);
  asm volatile ("TRAP 17");
#endif 

  InitCode();
  MMCInitCode();
  WaitUntillNoReset();
  SendCID(CID);
  SendCSD(CSD);
  SendOCR(0x80ff8000);                // set OCR-Register: Ready & VoltageRange
  ENABLE_INT1();
  MainLoop();
}

/*===========================================================================*/
/* MMCInitCode                                                            */
/*===========================================================================*/

static void MMCInitCode()
{
  DISABLE_FSMS();
  CLEAR_HY_CMD();
  CLEAR_HY_READ();
  CLEAR_HY_WRITE();
  CLEAR_HY_CLEAR();
  CLEAR_HY_STOP();
  CLEAR_HY_AGAIN();
  CLEAR_HY_DEBUG_CMD();
  CLEAR_HY_DEBUG_RES();
  CLEAR_WRITEPROT();
  CLEAR_DUMMY();
}

#if RTK
/*===========================================================================*/
/* InitDrivers                                                               */
/*===========================================================================*/

void InitDrivers()
{
  CreateTask (&PcmciaDriverTCB);
  CreateTask (&FlashReadyTCB);
}

void MakeIRAMTrapTable()
{
unsigned int *SRAMTrapTable = (unsigned int *)0x40000000;
unsigned int *IRAMTrapTable = (unsigned int *)0xc0000000;
unsigned int i, TrapTableInstruction;
register int GReg7 asm("G7");

  IRAMTrapTable[0] = 0;
  memcpy(&IRAMTrapTable[1], &SRAMTrapTable[1], 508);
  for (i=2; i<128; i++)
    {
      TrapTableInstruction = IRAMTrapTable[i] >> 16;
      if ((TrapTableInstruction == 0x6903) ||  // addi
	  (TrapTableInstruction == 0x6902) ||  // addi
	  (TrapTableInstruction == 0xfc80))    // br
	IRAMTrapTable[i] = ((SRAMTrapTable[i] & 0xffff) +
			   (unsigned int)&SRAMTrapTable[i+1])-GReg7;
	IRAMTrapTable[i] &= 0x00007fff;
	IRAMTrapTable[i] |= 0x18070000;        // sum pc, g7, const
    }
  UpdateMCR((3<<12), (4<<12));	// relocate trap table to IRAM
}

unsigned int InitIRAMTrap(unsigned int TrapNumber,
			  void *Address)
{
unsigned int *IRAMTrapTable = (unsigned int *)0xc0000000;
unsigned int EntryAddress = (unsigned int)Address;
register int GReg7 asm("G7");
register int GReg8 asm("G8");

  if ((EntryAddress - (unsigned int)&IRAMTrapTable[64-TrapNumber]) < 64*1024)
    {
      IRAMTrapTable[63-TrapNumber] = 0x69020000 +  // addi pc, const
	(EntryAddress - (unsigned int)&IRAMTrapTable[64-TrapNumber]);
      return 1;
    }
  if (((EntryAddress - GReg7) < 14*1024) ||
      ((GReg7 - EntryAddress ) <= 14*1024))
    {
      IRAMTrapTable[63-TrapNumber] = 0x18070000 +  // sum pc, g7, const
	((EntryAddress - GReg7) & 0x7fff);
      return 1;
    }
  if (((EntryAddress - GReg8) < 14*1024) ||
      ((GReg8 - EntryAddress ) <= 14*1024))
    {
      IRAMTrapTable[63-TrapNumber] = 0x18080000 +  // sum pc, g8, const
	((EntryAddress - GReg8) & 0x7fff);
      return 1;
    }
  return 0;
}
#endif
/*===========================================================================*/
/* InitCode                                                                  */
/*===========================================================================*/
#if RTK
void InitCode()
{
  EventFlags = 0;
  InitUserTrap(18, &MyOwnWaitGuard);
  InitUserTrap(19, &MyOwnWaitGuardMax);
  InitUserTrap(20, &FlashTrap);
  InitUserTrap(21, &FlashIdle1TrapEntry);
  asm volatile ("ORI  SR,$20");
  asm volatile ("MOVI TPR,14<<16");

  UpdateBCR((15<<20), 0);
  UpdateMCR((1<<9), 0);      // Mem1BusHoldBreak disable

  UpdateBCR(0, (7<<11));
  UpdateBCR((1<<24)+0, (14<<24)|15);  /* Mem2: 0 setup, 2 access, 0 hold */
  UpdateBCR((1<<23), 0);              /* Mem1: 1 hold */
  /* settings for pads on hyFlash bus */
//  UpdateMCR((3<<4), 0);
  UpdateMCR(3<<24, 0);       /* Output RailToRail, Input According 5.0V */
/*  printf("BCR:%08X MCR:%08X FCR:%08X\n", GetBCR(), GetMCR(), GetFCR()); */
//  BCRShadow = GetBCR();
//  UpdateFCR(0 << 0, 1<<3);  /* switch to slow frequency */
  UpdateFCR(7 << 0, 1<<6);  /* IO1 input, interrupt disabled */
			    /* IO2 output, no Write Protect,
			       interrupt disabled */
  BCRShadow = GetBCR();
  MCRShadow = GetMCR();
  FCRShadow = GetFCR();

  InitDrivers();
  MakeIRAMTrapTable();
  if (!InitIRAMTrap(17, &SetSupervisorMode))
    printf("Cannot install interrupt 17\n");
  if (!InitIRAMTrap(18, &MyOwnWaitGuard))
    printf("Cannot install interrupt 18\n");
  if (!InitIRAMTrap(19, &MyOwnWaitGuardMax))
    printf("Cannot install interrupt 19\n");
  if (!InitIRAMTrap(20, &FlashTrap))
    printf("Cannot install interrupt 20\n");
  if (!InitIRAMTrap(21, &FlashIdle1TrapEntry))
    printf("Cannot install interrupt 21\n");
  if (!InitIRAMTrap(49, &FlashReadyInterruptEntry))
    printf("Cannot install interrupt 49\n");
  if (!InitIRAMTrap(53, &PcmciaInterruptEntry))
    printf("Cannot install interrupt 53\n");
  UpdateFCR(1<<26, 1<<26);  /* toggle Interrupt3polarity */
  UpdateBCR((0<<24)+1, (15<<24)|14);  /* Mem2: 0 setup, 1 access, 1 hold */
  //UpdateBCR((1<<24)+1, (14<<24)|14);  /* Mem2: 0 setup, 2 access, 1 hold */
  FCRShadow = GetFCR();
  return; 
}

#else

void InitCode()
{
#if !FLASH_POWEROFF && LED
  ENABLE_INT4();
#endif
  UpdateFCR(7 << 0, 1<<6);  /* IO1 input, interrupt disabled */
			    /* IO2 output, no Write Protect */
  UpdateFCR(1<<26, 1<<26);  /* toggle Interrupt3polarity */
  EventFlags = 0;
  OverlappedFlags = 0;
  UpdateBCR(0,3 | (1<<14) | (3<<16)); 
    // Set MEM2 Timing, 0 Setup, 1 Access, 0 Hold
  return;
}
#endif

/*===========================================================================*/
/* CycleTest macros                                                          */
/*===========================================================================*/

#define BUFFER_LOAD_BIT(x)              (x & (1<<4))
#define DO_NOT_READ_AND_VERIFY_BIT(x)   (x & (1<<5))
#define USE_ECC_BIT(x)                  (x & (1<<6)) // default is: ECC not in use

// (1<<9) reserved
#define ALL_ERRORS_BIT(x)               (x & (1<<10))
#define UNKNOWN_ERROR_BIT(x)            (x & (1<<11))
#define ERASE_FAILURE_ERROR_BIT(x)      (x & (1<<12))
#define PROGRAM_FAILURE_ERROR_BIT(x)    (x & (1<<13))
#define DIFF_ERROR_BIT(x)               (x & (1<<14))
#define HALT_ON_ERROR_BIT(x)            (x & (1<<22))

#define BUFFER_INDEX(x)                 ((x>>1) & 0x00000007)
#define ERROR_COUNT_LIMIT(x)            ((x>>18) & 0x00000007)


static unsigned int RegisterCycError(unsigned int page, unsigned char errorCode)
{
    if (++CyclingErrors == MAX_CYC_ERRORS)
    {
        return (1);
    }
    cycErrorArray[CyclingErrors].cycle         = TotalCycles;
    cycErrorArray[CyclingErrors].eraseSector   = page >> 5; // translate page to EG number
    cycErrorArray[CyclingErrors].errorCode     = errorCode;
    return (0);
}

/*===========================================================================*/
/* CycleTest      @yona                                                 */
/*===========================================================================*/

static void CycleTest()
{
    unsigned int Overhead;
    unsigned int Argument;
    
    Overhead = 0;
    WRITE_BACK_PTR(Overhead, 0);
    Argument = READ_ADDRESS();
    StartBlock     = (*(unsigned int *) (SECTOR_BUFFER)) + LOG_TO_PHYS;
    NumberOfBlocks =  *(unsigned int *) (SECTOR_BUFFER + 4);
    NumberOfCycles =  *(unsigned int *) (SECTOR_BUFFER + 8);
#if RTK
    printf("cmd56 Argument = 0x%X\n", Argument);
    printf("StartBlock = 0x%X\n", StartBlock);
    printf("NumberOfBlocks = %d\n", NumberOfBlocks);
    printf("NumberOfCycles = %d\n", NumberOfCycles);
#endif

    ErrorSector = 0xFFFFFFFF;
    TotalCycles = 0;

    // load a new buffer (actually - save it in the program buffer)
    // assumption: the host sends the buffers sequentially and it is saved
    // in an incremental order
    if (BUFFER_LOAD_BIT(Argument))
    {
        if (MaxBufferIndex == MAX_CYCLING_BUFFERS)
        {
            // all the buffers are full
            ErrorSector = CYC_ERROR_BUFFERS_FULL;
            // and return TotalCycles=0 and ErrorSector as above
        }
        else
        {
            for (index=0; index<512; index++)
                cycBuffer[MaxBufferIndex][index] = *(SECTOR_BUFFER + index);
            // and return TotalCycles=0 and ErrorSector=0xFFFFFFFF
        }
        MaxBufferIndex++;    
        return;     
    }

//    ReadSectorFromFlash(PatternBlock, SECTOR_BUFFER); no need any more

    while ( TotalCycles < NumberOfCycles )
    {
        if ( EVENT(STOP_EVENT) )
        {
            RESET_EVENT(STOP_EVENT);
            break;
        }

        for ( index=0; index<NumberOfBlocks; index+=32 )    
        {
            if (EraseBlock(StartBlock+index))    // erase 32 pages, an EG
               if (RegisterCycError(StartBlock + index - LOG_TO_PHYS, CYC_ERROR_PROGRAM))
                   return;
        }

        if ( EVENT(STOP_EVENT) )
        {
            RESET_EVENT(STOP_EVENT);
            break;
        }

        for ( index=0; index<NumberOfBlocks; index++ )
            WriteSectorToFlash(StartBlock+index, cycBuffer[0], Overhead);
            // WriteSectorToFlash(StartBlock+i, SECTOR_BUFFER, Overhead);

        if ( EVENT(STOP_EVENT) )
        {
            RESET_EVENT(STOP_EVENT);
            break;
        }

        if ( ! PROGRAM_FAILURE_ERROR_BIT(Argument) )
        {
            for ( index=0; index<NumberOfBlocks; index++ )
            {
                if (ReadSectorFromFlash(StartBlock+index, EraseSectorBuffer))
                    if (RegisterCycError(StartBlock+index-LOG_TO_PHYS, CYC_ERROR_READ))
                        return;

                // compare the two buffers
                if ( CheckSector((unsigned int *) EraseSectorBuffer, (unsigned int *) cycBuffer[0]) == ERROR )
                    if (RegisterCycError(StartBlock+index-LOG_TO_PHYS, CYC_ERROR_COMPARE))
                        return;
            }
        }
        TotalCycles++;
    }
} // end of CycleTest

/*===========================================================================*/
/* CycleTestRead                                                             */
/*===========================================================================*/

static void CycleTestRead()
{
    unsigned int i, Argument;

    Argument = READ_ADDRESS();

    // a buffer unload (read a program buffer and send it to the host)
    if (BUFFER_LOAD_BIT(Argument))
    {
        if (BUFFER_INDEX(Argument) < MaxBufferIndex )
        {
            for (i=0; i<512; i++)
                cycBuffer[BUFFER_INDEX(Argument)][i] = *(SECTOR_BUFFER + i);
            // and return TotalCycles=0 and ErrorSector=0xFFFFFFFF

        }
        else
        {
            // all the buffers are full
            ErrorSector = CYC_ERROR_BUFFER_INDEX_EXCEED;
            // and return TotalCycles=0 and ErrorSector as above
        }
    } // end of new buffer to load

    * (unsigned int *) SECTOR_BUFFER = TotalCycles;
    * (unsigned int *) (SECTOR_BUFFER+4) = ErrorSector;

} // end of CycleTestRead