flash_mtd.amd.c

MTK debug flash 兼容性的code

#define RETURN_TRIGGER_PIN (44)
#define CHECK_TRIGGER_PIN (45)
#define CACHE_TRIGGER_PIN (46)

void triggerLA(void)
{
   DRV_Reg(GPIO_DOUT3) |= 0x0800; //set GPIO pin state to high
            }
static void triggerReturn(void)
      {
   DRV_Reg(GPIO_DOUT3) |= 0x1000; //set GPIO pin state to high
      }
static void deassertReturn(void)
      {
   DRV_Reg(GPIO_DOUT3) &= ~(0x1000); //set GPIO pin state to low
            }
static void triggerCheck(void)
            {
   DRV_Reg(GPIO_DOUT3) |= 0x2000; //set GPIO pin state to high
            }
static void deassertCheck(void)
      {
   DRV_Reg(GPIO_DOUT3) &= ~(0x2000); //set GPIO pin state to low
      }
void triggerDisable(void)
{
   DRV_Reg(GPIO_DOUT3) |= 0x4000; //set GPIO pin state to high
            }
void deaseertDisable(void)
      {
   DRV_Reg(GPIO_DOUT3) &= ~(0x4000); //set GPIO pin state to low
      }
#else /* defined(LA_TRIGGER_DEBUG) */

#define triggerLA(a) 
#define triggerReturn(a) 
#define deassertReturn(a) 
#define triggerCheck(a) 
#define deassertCheck(a) 
#define triggerDisable(a) 
#define deaseertDisable(a) 

#endif /* LA_TRIGGER_DEBUG */


#define EraseCommand_AMD(addr) \
   do{\
      addr[ADDR_UNLOCK_1] = CMD_UNLOCK_1;\
      addr[ADDR_UNLOCK_2] = CMD_UNLOCK_2;\
      addr[ADDR_UNLOCK_1] = CMD_SERASE;\
      addr[ADDR_UNLOCK_1] = CMD_UNLOCK_1;\
      addr[ADDR_UNLOCK_2] = CMD_UNLOCK_2;\
      addr[0]     = CMD_SERASE_END;\
      NOR_FLASH_BUSY = KAL_TRUE;\
   } while(0);

#else /* !__SINGLE_BANK_NOR_FLASH_SUPPORT__ */

#if defined(_LOW_COST_SINGLE_BANK_FLASH_)
#ifdef __MTK_TARGET__
#pragma arm section code = "SNORCODE"
#endif /* __MTK_TARGET__ */
#endif
static void EraseCommand_AMD(volatile FLASH_CELL *fp)
{
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   fp[ADDR_UNLOCK_1] = CMD_UNLOCK_1;
   fp[ADDR_UNLOCK_2] = CMD_UNLOCK_2;
   fp[ADDR_UNLOCK_1] = CMD_SERASE;
   fp[ADDR_UNLOCK_1] = CMD_UNLOCK_1;
   fp[ADDR_UNLOCK_2] = CMD_UNLOCK_2;
   fp[0]     = CMD_SERASE_END;
   RestoreIRQMask(savedMask);
}
#if defined(_LOW_COST_SINGLE_BANK_FLASH_)
#ifdef __MTK_TARGET__
#pragma arm section code
#endif /* __MTK_TARGET__ */
#endif

#endif /* __SINGLE_BANK_NOR_FLASH_SUPPORT__ */

#ifdef __SPANSION_NS_N__
static void DYBCMD_AMD(volatile FLASH_CELL *fp, kal_uint32 ActionFlag)
{
   kal_uint32 savedMask;

   savedMask = SaveAndSetIRQMask();
   
   if(ActionFlag == DYB_UNLOCK)
   {
      fp[ADDR_UNLOCK_1] = CMD_UNLOCK_1;
      fp[ADDR_UNLOCK_2] = CMD_UNLOCK_2;
      fp[ADDR_UNLOCK_1] = CMD_DYB_ENTER;
      fp[0] = CMD_DYB_ACT;
      fp[0] = CMD_DYB_CLR;
      fp[0] = CMD_DYB_EXIT1;
      fp[0] = CMD_DYB_EXIT2;
   }
   else
   {
      fp[ADDR_UNLOCK_1] = CMD_UNLOCK_1;
      fp[ADDR_UNLOCK_2] = CMD_UNLOCK_2;
      fp[ADDR_UNLOCK_1] = CMD_DYB_ENTER;
      fp[0] = CMD_DYB_ACT;
      fp[0] = CMD_DYB_SET;
      fp[0] = CMD_DYB_EXIT1;
      fp[0] = CMD_DYB_EXIT2;
   }
   RestoreIRQMask(savedMask);
}
#endif

/*-----------------------------------*/
#if defined(__SPANSION_GL_N__)
__inline static void DelayAWhile_AMD(void * DriveData)
{
   NOR_Flash_MTD_Data * D = DriveData;
   kal_uint32 data_cache_id = 0;
   volatile FLASH_CELL * fp = (volatile FLASH_CELL *) D->CurrAddr;
   FLASH_CELL s1 = 0, s2 = 0;
   do
   {
      data_cache_id = INT_DisableDataCache();
      s1 = fp[1];
      s2 = fp[1];
      INT_RestoreDataCache(data_cache_id);
      if(s2 & POLL_ERASE_START)
      {
         break;
      }
   }
   while(1);
}

#elif defined(__SPANSION_GL_A__)

__inline static void DelayAWhile_AMD(void * DriveData)
{
   kal_uint32 wait_count = COUNTER_05US;
   NOR_Flash_MTD_Data * D = DriveData;
   kal_uint32 data_cache_id = 0;
   volatile FLASH_CELL * fp = (volatile FLASH_CELL *) D->CurrAddr;
   FLASH_CELL s1 = 0, s2 = 0;
   do
   {
      data_cache_id = INT_DisableDataCache();
      s1 = fp[1];
      s2 = fp[1];
      INT_RestoreDataCache(data_cache_id);
      if(s2 & POLL_ERASE_START)
      {
         break;
      }
   }
   while(wait_count--);
}

#elif defined(__SPANSION_PL_N__)

__inline static void DelayAWhile_AMD(void)
{
   
#if defined(MT6205B)

   volatile kal_uint32 i;
   for (i=0;i<COUNTER_10US;i++);
   
#else

   volatile kal_uint32 CurrentTime,StartTime;
   
   StartTime = INT_GetCurrentTime(); //32KHz Fregquency Counter
   while(1)
   {
      CurrentTime = INT_GetCurrentTime();
      if((CurrentTime > StartTime) && ((CurrentTime-StartTime)>=2))
         break;
      if((CurrentTime < StartTime) && (CurrentTime>=1))
         break;
   }
#endif
     
   return;
}
#endif //__SPANSION_PL_N__

/*-----------------------------------*/
#if (defined(__SINGLE_BANK_NOR_FLASH_SUPPORT__) || defined(_LOW_COST_SINGLE_BANK_FLASH_))
#ifdef __MTK_TARGET__
#pragma arm section code = "SNORCODE"
#endif /* __MTK_TARGET__ */
#endif

#if (defined(__SINGLE_BANK_NOR_FLASH_SUPPORT__))
/* ------------------------------------------------------------------ */
kal_int32 CheckReadyAndResume_AMD(kal_uint32 addr,kal_uint16 data) /* for program operation only */
{
   kal_uint32 data_cache_id;
   static kal_uint16 check_data = 0;
   static kal_uint16 toggle_data = 0;
   kal_uint32 savedMask;
   kal_int32   status = RESULT_FLASH_BUSY;
   #if defined(MT6205B)
   kal_uint16 irq_sts = 0;
   #endif

   triggerCheck();

   #ifndef MT6205B
   savedMask = SaveAndSetIRQMask();
   #endif
   CHECK_LOG_START(sla_id[22])

   if(NOR_FLASH_SUSPENDED)
   {
      #if !defined(__PRODUCTION_RELEASE__)
      SNOR_MTD_ASSERT(NOR_FLASH_BUSY, *(volatile kal_uint16*)addr, *(volatile kal_uint16*)addr, addr);
      #endif
      *(volatile kal_uint16*)addr = CMD_RESU_SEC_ERASE;
      NOR_FLASH_SUSPENDED = KAL_FALSE;
   }

   data_cache_id = INT_DisableDataCache();
   check_data = *(volatile kal_uint16*)addr;

   toggle_data = *(volatile kal_uint16*)addr;

   if( ((check_data & POLL_BUSY) != (data & POLL_BUSY)) ||
       ((check_data ^ toggle_data) & TOGGLE_BUSY) )
   {
#ifndef __SST_NOR__
      if( check_data & POLL_TIMEOUT )
      {

         check_data = *(volatile kal_uint16*)addr;

         if( check_data == data ) /* in case that DQ5 of data happens to be "1" */
         {
            NOR_FLASH_BUSY = KAL_FALSE;
            status = RESULT_FLASH_DONE;
         }
         else
         {
            #ifdef __PRODUCTION_RELEASE__
            *(volatile kal_uint16*)addr = CMD_RESET;
            INT_RestoreDataCache(data_cache_id);
            #endif
            SNOR_MTD_ASSERT(0,check_data,data,addr);
         }
      }
      else if( check_data & TOGGLE_BUFFER_ABORT )
      {
         check_data = *(volatile kal_uint16*)addr;
         if( check_data!= data)
   {
         #ifdef __PRODUCTION_RELEASE__
            *(((volatile kal_uint16*)addr)+ADDR_UNLOCK_1) = CMD_UNLOCK_1;
            *(((volatile kal_uint16*)addr)+ADDR_UNLOCK_2) = CMD_UNLOCK_2;
            *(((volatile kal_uint16*)addr)+ADDR_UNLOCK_1) = CMD_RESET;
         #endif
            INT_RestoreDataCache(data_cache_id);
            SNOR_MTD_ASSERT(0,check_data,data,addr);
         }
         NOR_FLASH_BUSY = KAL_FALSE;
         status = RESULT_FLASH_DONE;
      }
      else
#endif /* __SST_NOR__ */
      {
         check_data = *(volatile kal_uint16*)addr;
         toggle_data = *(volatile kal_uint16*)addr;

         if( (check_data == data) && !((toggle_data^check_data)&TOGGLE_BUSY) )
         {
            NOR_FLASH_BUSY = KAL_FALSE;
            status = RESULT_FLASH_DONE;
         }
         }
      }
      else
   {
      NOR_FLASH_BUSY = KAL_FALSE;
      check_data = *(volatile kal_uint16*)addr;

      if(check_data == data)
      {
         status = RESULT_FLASH_DONE;
      }
      else
      {
         status = RESULT_FLASH_FAIL;
      }
}

   INT_RestoreDataCache(data_cache_id);

   CHECK_LOG_STOP(sla_id[22])
   #ifndef MT6205B
   RestoreIRQMask(savedMask);
   #endif

   deassertCheck();
   return status;
}
#endif /* __SINGLE_BANK_NOR_FLASH_SUPPORT__ */

/*-----------------------------------*/
//#if (defined(__TOSHIBA_TV__) || defined(__TOSHIBA_TY__))
static int ProgramData_TOSHIBA_TV_PBP(void * DriveData, void * Address, void * Data, kal_uint32 Length)
{
   kal_uint32 savedMask;
#ifndef __NOR_FDM5__
   NOR_Flash_MTD_Data * D = DriveData;
   volatile FLASH_CELL *bp = (volatile FLASH_CELL *) (D->CurrAddr);
   ASSERT((~D->Signature == (kal_uint32)D->RegionInfo));
#else
   NOR_MTD_DATA *D= DriveData;
   NORLayoutInfo * Layout = D->LayoutInfo;
   volatile FLASH_CELL *bp = (volatile FLASH_CELL *)((kal_uint32)Address&(~((Layout->BlkSize-1))));
   ASSERT(D->Signature == ~((kal_uint32)D->LayoutInfo));
#endif   
   
   #ifdef DEBUG
   //can't write zero bytes into flash
   ASSERT(Length != 0);
   #endif

   switch (Length)
   {
      case sizeof(FLASH_CELL):
         #if defined(DEBUG)
            //Misaligned write into flash
            ASSERT(!(((kal_uint32)Address) % sizeof(FLASH_CELL)));
         #endif

         #ifdef DEBUG
         //Attempt to set bits in flash!
         ASSERT(!(~((volatile FLASH_CELL*)Address)[0] & ((FLASH_CELL*)Data)[0]));
         #endif

         savedMask = SaveAndSetIRQMask();
         bp[ADDR_UNLOCK_1] = CMD_UNLOCK_1;
         bp[ADDR_UNLOCK_2] = CMD_UNLOCK_2;
         bp[ADDR_UNLOCK_1] = CMD_PROG;
         ((volatile FLASH_CELL*)Address)[0] = ((FLASH_CELL*)Data)[0];
#ifdef _LOW_COST_SINGLE_BANK_FLASH_
         WaitReady_AMD((kal_uint32)Address, *(kal_uint16*)Data);
         RestoreIRQMask(savedMask);         
#elif defined(__SINGLE_BANK_NOR_FLASH_SUPPORT__)

         NOR_FLASH_BUSY = KAL_TRUE;

         #if defined(MT6205B)
         if( kal_query_systemInit() || INT_QueryExceptionStatus() )
         {
            while(!CheckReadyAndResume_AMD((kal_uint32)Address, *(kal_uint16*)Data));
         }
         else
         {
            while(!CheckReadyAndResume_AMD((kal_uint32)Address, *(kal_uint16*)Data))
            {
               savedMask = CHECK_PENDING_IRQ(savedMask, (kal_uint32)Address);
            }
         }

         CHECK_LOG_STOP(sla_id[5])
         RestoreIRQMask(savedMask);

         #else /* !MT6205B */

         RestoreIRQMask(savedMask);
         while(!CheckReadyAndResume_AMD((kal_uint32)Address, *(kal_uint16*)Data));

         CHECK_LOG_STOP(sla_id[5])
         #endif /* MT6205B */
#else
         RestoreIRQMask(savedMask);
         WaitReady_AMD((kal_uint32)Address, *(kal_uint16*)Data);
#endif
         break;

      case 1:
      {
         volatile FLASH_CELL *fp;
         kal_uint32 ofs = ((kal_uint32) Address) & (sizeof(FLASH_CELL)-1);
         FLASH_CELL Cell;
         kal_uint8 *b = (kal_uint8*) &Cell;

         fp   = (void*) (((kal_uint32) Address) & ~(sizeof(FLASH_CELL)-1)); // round it down
         Cell = fp[0];

         b[ofs] = ((kal_uint8*)Data)[0];

         #ifdef DEBUG
         //Attempt to set bits in flash!
         ASSERT(!((~fp[0]) & Cell))
         #endif

         savedMask = SaveAndSetIRQMask();
         bp[ADDR_UNLOCK_1] = CMD_UNLOCK_1;
         bp[ADDR_UNLOCK_2] = CMD_UNLOCK_2;
         bp[ADDR_UNLOCK_1] = CMD_PROG;
         fp[0]     = Cell;
#ifdef _LOW_COST_SINGLE_BANK_FLASH_
         WaitReady_AMD((kal_uint32)fp, (kal_uint16)Cell);
         RestoreIRQMask(savedMask);
#elif defined(__SINGLE_BANK_NOR_FLASH_SUPPORT__)

         NOR_FLASH_BUSY = KAL_TRUE;