Example #1
0
void Flash_Write(uint8_t addr, uint32_t value)
{
    uint32_t block_addr = GetBlockAddr();
    if(addr < BLOCK_SIZE / 4 - 1)
    {
        if(FirstUse)
        {
            FMC_Write(block_addr + 4 * (addr + 1), value);
            FirstUse = FALSE;
        }
        else
        {
            uint32_t i, write_addr;
            for(i = block_addr; i < block_addr + BLOCK_SIZE; i += 4)
            {
                write_addr = (i - (block_addr + 4)) / 4;
                if(write_addr != addr)
                {
                    FMC_Write(i + BLOCK_SIZE, FMC_Read(i));
                }
            }
            FMC_Write(block_addr, BLOCK_STAT_DISABLED);
            block_addr += BLOCK_SIZE;
            Block_Init(block_addr);
            FMC_Write(block_addr + (4 * (addr + 1)), value);
        }
    }
}
Example #2
0
/**
  * @brief Execute ISP command to write User Configuration.
  * @param[in] u32Config A two-word array. 
  *            u32Config[0] holds CONFIG0, while u32Config[1] holds CONFIG1. 
  * @param[in] u32Count Avaliable word count in u32Config.
  * @return Success or not.
  * @retval   0  Success.
  * @retval   -1  Invalid parameter.
  */
int32_t FMC_WriteConfig(uint32_t *u32Config, uint32_t u32Count)
{
    FMC_ENABLE_CFG_UPDATE();
    FMC_Erase(FMC_CONFIG_BASE);
    FMC_Write(FMC_CONFIG_BASE, u32Config[0]);
    FMC_Write(FMC_CONFIG_BASE+4, u32Config[1]);
    FMC_DISABLE_CFG_UPDATE();
    return 0;
}
Example #3
0
void Block_Write(uint32_t block, uint32_t* values)
{
	uint8_t i;
	uint32_t CRC = USED_SIZE;
	for (i = 0; i < USED_SIZE / 4; i++)
	{
		CRC ^= Using_Values[i];
		FMC_Write(block + i * 4, Using_Values[i]);
	}
	FMC_Write(block + USED_SIZE, CRC);
}
Example #4
0
int32_t fill_data_pattern(uint32_t u32StartAddr, uint32_t u32EndAddr, uint32_t u32Pattern)
{
    uint32_t u32Addr;

    for (u32Addr = u32StartAddr; u32Addr < u32EndAddr; u32Addr += 4) {
        FMC_Write(u32Addr, u32Pattern);
    }
    return 0;
}
Example #5
0
uint32_t FMC_ProgramPage(uint32_t u32StartAddr, uint32_t * u32Buf)
{
    uint32_t i;

    for (i = 0; i < FLASH_PAGE_SIZE/4; i++)
    {
        FMC_Write(u32StartAddr + i*4, u32Buf[i]);
    }

    return 0;
}
Example #6
0
/**
  * @brief      Write User Configuration
  *
  * @param[in]  u32Config The word buffer to store the User Configuration data.
  * @param[in]  u32Count The word count to program to User Configuration.
  *
  * @retval     0 Success
  * @retval    -1 Failed
  *
  * @details    User must enable User Configuration update before writing it.
  *             User must erase User Configuration before writing it.
  *             User Configuration is also be page erase. User needs to backup necessary data
  *             before erase User Configuration.
  */
int32_t FMC_WriteConfig(uint32_t *u32Config, uint32_t u32Count)
{
    int32_t i;

    for(i = 0; i < u32Count; i++)
    {
        FMC_Write(FMC_CONFIG_BASE + i * 4, u32Config[i]);
        if(FMC_Read(FMC_CONFIG_BASE + i * 4) != u32Config[i])
            return -1;
    }

    return 0;
}
Example #7
0
bool flash_io_driver_write(__ROM void* address, const void* data, uint16_t length)
{
  if(is_range_valid(address) == false)
  {
    return false;
  }

  uint32_t _address = (uint32_t)address;
  uint32_t* _data = (uint32_t*)data;
  
  length /= sizeof(uint32_t); // number of bytes -> number of whole words
  
  // write
  for(uint16_t i = 0; i < length; i++)
  {
    UNLOCKREG();
    if(FMC_Write(_address, *_data++) != E_FMC_OK)
    {
      LOCKREG();
      return false;
    }
    LOCKREG();
    
    _address += sizeof(uint32_t);
  }
  
  // verify
  uint32_t* source = (uint32_t*)address;
  _data = (uint32_t*)data;
  
  for(uint16_t i = 0; i < length; i++)
  {
    uint32_t s = *source++;
    uint32_t t = *_data++;
    if(s != t)
    {
      return false;
    }
  }
  
  return true;
}
Example #8
0
//============================================================================
// DATA FLASH OPERATION
// u32addr : 0-1024 (For 4KBytes Data Flash)
// u32data : 0-0xFFFFFFFF (4Bytes)
//============================================================================
void DATA_FLASH_Write(uint32_t u32addr,uint32_t u32data)
{
    uint32_t i=0;
#ifdef M451
    SYS_UnlockReg();
    FMC_Open();

    for(i=0; i<PAGE_SIZE; i++)
        data_buff[i] = FMC_Read(DATA_Flash_Start_ADD+i*4+ u32addr/PAGE_SIZE*2048);

    FMC_Erase(DATA_Flash_Start_ADD+u32addr/PAGE_SIZE*2048);
    data_buff[u32addr%PAGE_SIZE]=u32data;

    for(i=0; i<PAGE_SIZE; i++)
        FMC_Write(DATA_Flash_Start_ADD+i*4+ u32addr/PAGE_SIZE*2048, data_buff[i]);

    FMC_Close();
    SYS_LockReg();
#else
    uint32_t data_buff[PAGE_SIZE];
    __set_PRIMASK(1);//Avoid interrupt

    UNLOCKREG();
    DrvFMC_EnableISP();

    for(i=0; i<PAGE_SIZE; i++)
        DrvFMC_Read(DATA_Flash_Start_ADD+i*4+ u32addr/128*512, &data_buff[i]);

    DrvFMC_Erase(DATA_Flash_Start_ADD+u32addr/128*512);

    data_buff[u32addr%128]=u32data;

    for(i=0; i<PAGE_SIZE; i++)
        DrvFMC_Write(DATA_Flash_Start_ADD+i*4+ u32addr/128*512, data_buff[i]);

    DrvFMC_DisableISP();
    LOCKREG();
    __set_PRIMASK(0);
#endif

}
Example #9
0
void write_impl_less(uint8_t * addressE, const uint8_t * data, int size)
{
	uint32_t buf[PAGE_SIZE_32B];
	int i;
	uint32_t * p_adr_start = (uint32_t*) (((int)addressE) & (~(PAGE_SIZE - 1)));
	uint8_t * p_adr_pos =  ((uint8_t*)buf) + (((int)addressE) & (PAGE_SIZE - 1));

	for(i=0; i<PAGE_SIZE_32B; i++)
		buf[i] = p_adr_start[i];

	for(i=0; i<size; i++)
		p_adr_pos[i] = ((uint8_t*)data)[i];


    // Erase page
    FMC_Erase((uint32_t)p_adr_start);

	for(i = 0; i < PAGE_SIZE_32B; i++)
		 FMC_Write((uint32_t)&p_adr_start[i], buf[i]);

}
Example #10
0
static int  LoadImage(uint32_t u32ImageBase, uint32_t u32ImageLimit, uint32_t u32FlashAddr, uint32_t u32MaxSize)
{
    uint32_t   i, j, u32Data, u32ImageSize, *pu32Loader;

    u32ImageSize = u32MaxSize;

    printf("Program image to flash address 0x%x...", u32FlashAddr);
    pu32Loader = (uint32_t *)u32ImageBase;
    for(i = 0; i < u32ImageSize; i += FMC_FLASH_PAGE_SIZE)
    {
        FMC_Erase(u32FlashAddr + i);
        for(j = 0; j < FMC_FLASH_PAGE_SIZE; j += 4)
        {
            FMC_Write(u32FlashAddr + i + j, pu32Loader[(i + j) / 4]);
        }
    }
    printf("OK.\n");

    printf("Verify ...");

    /* Verify loader */
    for(i = 0; i < u32ImageSize; i += FMC_FLASH_PAGE_SIZE)
    {
        for(j = 0; j < FMC_FLASH_PAGE_SIZE; j += 4)
        {
            u32Data = FMC_Read(u32FlashAddr + i + j);

            if(u32Data != pu32Loader[(i + j) / 4])
            {
                printf("data mismatch on 0x%x, [0x%x], [0x%x]\n", u32FlashAddr + i + j, u32Data, pu32Loader[(i + j) / 4]);
                return -1;
            }

            if(i + j >= u32ImageSize)
                break;
        }
    }
    printf("OK.\n");
    return 0;
}
Example #11
0
void Block_Init(uint32_t addr)
{
    FMC_Write(addr, BLOCK_STAT_ENABLED);
}
Example #12
0
/*---------------------------------------------------------------------------------------------------------*/
int32_t main(void)
{
    int32_t  i32Err = 0;
    uint32_t u32Data, u32ImageSize, i, j, *pu32Loader;

    /* Init system, IP clock and multi-function I/O */
    SYS_Init();

    /* Init UART0 for printf */
    UART0_Init();

    /* Init GPIO P2.0 (output) and P3.2 (EINT0) */
    GPIO_Init();

    /* Init SPI0 and LCD */
    LCD_Init();
    LCD_EnableBackLight();
    LCD_ClearScreen();


    /* 
        This sample shows how to switch between APROM and LDROM. 
        Target: 
            Smpl_FMC
                Smpl_FMC is the code for APROM. It will program the firmware to LDROM and
                user can press SW_INT to change to boot from LDROM. 
                In APROM, the LED blanking interval is 200ms.
            Smpl_LDROM
                Smpl_LDROM is the code for LDROM. User can press SW_INT to change to boot from APROM.
                In LDROM, the LED blanking interval is 1000ms.
    */
    LCD_Print(0, "Boot from APROM");
    LCD_Print(1, "Press SW_INT   ");
    while (1)
    {
        if(g_u8IsPress)
        {
            g_u8IsPress = FALSE;

            /* Unlock protected registers to write ISP Control Register (ISPCON) */
            SYS_UnlockReg();

            /* Program sample LD code to LDROM */

            /* Enable ISP LDROM update function */
            FMC->ISPCON = FMC_ISPCON_LDUEN_Msk | FMC_ISPCON_ISPEN_Msk;

            /* Page Erase LDROM */
            for (i = 0;i < 4096;i += PAGE_SIZE)
                FMC_Erase(LDROM_BASE + i);


            /* Erase Verify */
            i32Err = 0;
            for (i = LDROM_BASE; i < (LDROM_BASE + 4096); i += 4)
            {
                u32Data = FMC_Read(i);

                if (u32Data != 0xFFFFFFFF)
                {
                    i32Err = 1;
                }
            }


            u32ImageSize = (uint32_t)&g_u32LoaderImageLimit - (uint32_t)&g_u32LoaderImageBase;

            pu32Loader = (uint32_t *)&g_u32LoaderImageBase;
            for (i = 0;i < u32ImageSize;i += PAGE_SIZE)
            {
                FMC_Erase(LDROM_BASE + i);
                for (j = 0;j < PAGE_SIZE;j += 4)
                {
                    FMC_Write(LDROM_BASE + i + j, pu32Loader[(i + j) / 4]);
                }
            }

            /* Verify loader */
            i32Err = 0;
            for (i = 0;i < u32ImageSize;i += PAGE_SIZE)
            {
                for (j = 0;j < PAGE_SIZE;j += 4)
                {
                    u32Data = FMC_Read(LDROM_BASE + i + j);
                    if (u32Data != pu32Loader[(i+j)/4])
                        i32Err = 1;

                    if (i + j >= u32ImageSize)
                        break;
                }


            }

            if(i32Err)
            {
                LCD_ClearScreen();
                LCD_Print(0,"LDROM write fail");
            }
            else
            {
                /* Switch to boot from LDROM */
                FMC->ISPCON = FMC_ISPCON_BS_LDROM;
                _SYS_RESET_CPU();
            }

            while (1);
        }
        else
        {
            /* LED blanking for 200ms */
            P2->DOUT ^= 1;
            SYS_SysTickDelay(100000);
        }

        

    }
}
Example #13
0
/**
  * @brief  Main funcion
  * @param  None
  * @retval 0: Success; <0: Failed
  */
int32_t main (void)
{
	int32_t  i32Err;
	uint32_t u32Data, i, u32ImageSize, j, *pu32Loader;
    uint8_t ch;

	UNLOCKREG();

	/* Enable FMC ISP function */
	FMC_Init();

	/* Read Company ID */
	u32Data = 0;
	FMC_ReadCID(&u32Data);
	if (u32Data != 0xda)
	{
		printf("Wrong CID: 0x%x\n", u32Data);
        goto lexit;
	}

    /* Check the signature to check if Simple LD code is finished or not */
    if (inpw(KEY_ADDR) == SIGNATURE)
    {
        /* Just clear SIGNATURE and finish the sample code if Simple LD code has been executed. */
        outpw(KEY_ADDR, 0);
        
		/* Read BS */
        printf("  Boot Mode .................................. ");
        if (FMC_GetBootSelect() == E_FMC_APROM)
            printf("[APROM]\n");
        else
        {
            printf("[LDROM]\n");
            printf("  WARNING: The driver sample code must execute in AP mode!\n");
        }
        goto lexit;
    }
    
    printf("\n\n");
    printf("+-------------------------------------------------------------------------+\n");
    printf("|            NANO1xx Flash Memory Controller Driver Sample Code           |\n");
    printf("+-------------------------------------------------------------------------+\n");
	printf("  NOTE: This sample must be applied to NANO1xx series equipped with 16KB RAM.\n");

    /* Read BS */
    printf("  Boot Mode .................................. ");
    if (FMC_GetBootSelect() == E_FMC_APROM)
        printf("[APROM]\n");
    else
    {
        printf("[LDROM]\n");
        printf("  WARNING: The driver sample code must execute in AP mode!\n");
        goto lexit;
    }

	/* Read Data Flash base address */
	u32Data = FMC_ReadDataFlashBaseAddr();
	printf("  Data Flash Base Address .................... [0x%08x]\n", u32Data);

    /* Check the data in LD ROM to avoid overwrite them */
    FMC_Read(LDROM_BASE, &u32Data);
    if (u32Data != 0xFFFFFFFF)
    {
        printf("\n  WARNING: There is code in LD ROM.\n  If you proceed, the code in LD ROM will be corrupted.\n");
        printf("  Continue? [y/n]:");
        ch = getchar();
        putchar(ch);
        if (ch != 'y')
            goto lexit;
        printf("\n\n");
    }

	/* Enable LDROM update */
	FMC_EnableLDUpdate();

    printf("  Erase LD ROM ............................... ");
	/* Page Erase LDROM */
    for (i = 0; i < 4096; i += PAGE_SIZE)
        FMC_Erase(LDROM_BASE + i);
	
	/* Erase Verify */
    i32Err = 0;
	for (i = LDROM_BASE; i < (LDROM_BASE+4096); i += 4) 
    {     
		FMC_Read(i, &u32Data);
        if(u32Data != 0xFFFFFFFF)
        {
        	printf(" u32Data = 0x%x\n", u32Data);
            i32Err = 1;
        }         
    }
    if (i32Err)
        printf("[FAIL]\n");
    else
        printf("[OK]\n");
	

    printf("  Program LD ROM test ........................ ");
	
	/* Program LD ROM and read out data to compare it */
    for (i = LDROM_BASE; i < (LDROM_BASE+4096); i += 4) 
    {
        FMC_Write(i, i);
    }

    i32Err = 0;
    for (i = LDROM_BASE; i < (LDROM_BASE+4096); i += 4) 
    {
		FMC_Read(i, &u32Data);
        if(u32Data != i)
        { 
           i32Err = 1;
        }        
    }
    if (i32Err)
        printf("[FAIL]\n");
    else
        printf("[OK]\n");


    /* Check LD image size */
    u32ImageSize = (uint32_t)&loaderImageLimit - (uint32_t)&loaderImageBase;
    if (u32ImageSize == 0)
    {
        printf("  ERROR: Loader Image is 0 bytes!\n");
        goto lexit;
    }

    if (u32ImageSize > 4096)
    {
        printf("  ERROR: Loader Image is larger than 4KBytes!\n");
        goto lexit;    
    }


    printf("  Program Simple LD Code ..................... ");
    pu32Loader = (uint32_t *)&loaderImageBase;
    for (i = 0; i < u32ImageSize; i += PAGE_SIZE)
    {
        FMC_Erase(LDROM_BASE + i);    
        for (j = 0; j < PAGE_SIZE; j += 4)
        {
            FMC_Write(LDROM_BASE + i + j, pu32Loader[(i + j) / 4]);
        }
    }

    /* Verify loader */
    i32Err = 0;
    for (i = 0; i < u32ImageSize; i += PAGE_SIZE)
    {
        for(j = 0; j < PAGE_SIZE; j += 4)
        {
            FMC_Read(LDROM_BASE + i + j, &u32Data);
            if (u32Data != pu32Loader[(i+j)/4])
                i32Err = 1;
            
            if (i + j >= u32ImageSize)
                break;
        }
    }

    if(i32Err)
    {
        printf("[FAIL]\n");
    }
    else
    {
        printf("[OK]\n");
        
        /* Reset CPU to boot to LD mode */
        printf("\n  >>> Reset to LD mode <<<\n");
        FMC_BootSelect(E_FMC_LDROM);
        GCR->IPRST_CTL1 = GCR_IPRSTCTL1_CPU;
    }


lexit:

 	/* Disable FMC ISP function */
	FMC_DeInit();

	/* Lock protected registers */
	LOCKREG();
    
	printf("\nFMC Sample Code Completed.\n");

}
Example #14
0
void FMC_LDROM_Test(void)
{
    int32_t  i32Err;
    uint32_t u32Data, i, j, *pu32Loader;

    /* Enable LDROM Update */
    _FMC_ENABLE_LD_UPDATE();

    printf("  Erase LD ROM ............................... ");
    
    /* Page Erase LDROM */
    for (i = 0; i < FMC_LDROM_SIZE; i += FMC_FLASH_PAGE_SIZE)
        FMC_Erase(FMC_LDROM_BASE + i);
    
    /* Erase Verify */
    i32Err = 0;

    for (i = FMC_LDROM_BASE; i < (FMC_LDROM_BASE+FMC_LDROM_SIZE); i += 4) 
    {     
        u32Data = FMC_Read(i);
        
        if (u32Data != 0xFFFFFFFF)
        { 
            i32Err = 1;
        }
    }
    
    if (i32Err)
        printf("[FAIL]\n");
    else
        printf("[OK]\n");
    
    printf("  Program LD ROM test ........................ ");
    
    /* Program LDROM and read out data to compare it */
    for(i = FMC_LDROM_BASE; i < (FMC_LDROM_BASE+FMC_LDROM_SIZE); i += 4) 
    {
        FMC_Write(i, i);
    }

    i32Err = 0;
    
    for(i = FMC_LDROM_BASE; i < (FMC_LDROM_BASE+FMC_LDROM_SIZE); i += 4) 
    {
        u32Data = FMC_Read(i);
        
        if (u32Data != i)
        { 
           i32Err = 1;
        }        
    }
    
    if (i32Err)
        printf("[FAIL]\n");
    else
        printf("[OK]\n");

    printf("  Program Simple LD Code ..................... ");
    pu32Loader = (uint32_t *)&loaderImageBase;
    
    for (i=0;i<g_u32ImageSize;i+=FMC_FLASH_PAGE_SIZE)
    {
        FMC_Erase(FMC_LDROM_BASE + i);
        
        for (j=0;j<FMC_FLASH_PAGE_SIZE;j+=4)
        {
            FMC_Write(FMC_LDROM_BASE + i + j, pu32Loader[(i + j) / 4]);
        }
    }

    /* Verify loader */
    i32Err = 0;
    
    for (i=0;i<g_u32ImageSize;i+=FMC_FLASH_PAGE_SIZE)
    {
        for (j=0;j<FMC_FLASH_PAGE_SIZE;j+=4)
        {
            u32Data = FMC_Read(FMC_LDROM_BASE + i + j);
            if (u32Data != pu32Loader[(i+j)/4])
                i32Err = 1;
            
            if (i + j >= g_u32ImageSize)
                break;
        }
    }

    if (i32Err)
    {
        printf("[FAIL]\n");
    }
    else
    {
        printf("[OK]\n");
        
        /* Reset CPU to boot to LD mode */
        printf("\n  >>> Reset to LD mode <<<\n");
        
        /* Make sure message has printed out */
        _UART_WAIT_TX_EMPTY(UART0);

        FMC->ISPCON |= FMC_ISPCON_BS_LDROM;
        
        /* CPU Reset */
        _SYS_RESET_CPU();
    }
}
Example #15
0
_Bool Flash_Read(uint8_t addr, uint32_t* dist)
{
	if (addr < USED_SIZE / 4)
	{
		if (ReadRequed)
		{
			uint8_t i;
			uint32_t CRC = USED_SIZE;
			Block_Read(NEW_BLOCK_ADDR);
			for (i = 0; i < USED_SIZE / 4; i++)
			{
				CRC ^= Using_Values[i];
			}
			if (CRC == FMC_Read(NEW_BLOCK_ADDR + USED_SIZE))
			{
				*dist = FMC_Read(NEW_BLOCK_ADDR + addr * 4);
				/*if (*dist == 0xffff)
				 {
				 return FALSE;
				 }*/
				ReadRequed = FALSE;
				return TRUE;
			}
			else
			{
				FMC_Erase(NEW_BLOCK_ADDR);
				Flash_Init();

				DPRINTF(("Area 1 error! \n"));

			}
			Block_Read(BAK_BLOCK_ADDR);
			for (i = 0; i < USED_SIZE / 4; i++)
			{
				CRC ^= Using_Values[i];
			}
			if (CRC == FMC_Read(BAK_BLOCK_ADDR + USED_SIZE))
			{
				Block_Clear(NEW_BLOCK_ADDR);
				for (i = 0; i < USED_SIZE / 4; i++)
				{
					FMC_Write(NEW_BLOCK_ADDR + i * 4, Using_Values[i]);
				}
				FMC_Write(NEW_BLOCK_ADDR + USED_SIZE, CRC);
				*dist = FMC_Read(BAK_BLOCK_ADDR + addr * 4);
				/*if (*dist == 0xffff)
				 {
				 return FALSE;
				 }*/
				ReadRequed = FALSE;
				return TRUE;
			}
			else
			{
				FMC_Erase(BAK_BLOCK_ADDR);
				Flash_Init();
				DPRINTF(("Area 2 CRC error! \n"));
			}
		}
		else
		{
			*dist = Using_Values[addr];
			return TRUE;
		}
	}
	else
	{
		DPRINTF(("Err: Addr: %d  overrange!\n", addr));
	}
	return FALSE;
}