Esempio n. 1
0
/**
 * \brief Test NVM initialization
 *
 * This function will write the default configuration to NVM
 * and returns an error in case of failure.
 *
 * \param test Current test case.
 */
static void run_nvm_init_test(const struct test_case *test)
{
	struct nvm_config config;
	enum status_code status;

	/* Get the default configuration */
	nvm_get_config_defaults(&config);

	/* Set wait state to 1 */
	config.wait_states = 1;

	/* Enable automatic page write mode */
	config.manual_page_write = false;

	/* Set the NVM configuration */
	status = nvm_set_config(&config);

	/* Validate the initialization */
	test_assert_true(test, status == STATUS_OK,
			"NVM Initialization error");

	if (status == STATUS_OK) {
		nvm_init_success = true;
	}
}
Esempio n. 2
0
static int
samd21_flash_init(void)
{
    int rc;
    struct nvm_config cfg;
    struct nvm_parameters params;
    nvm_get_config_defaults(&cfg);
    
    cfg.manual_page_write = false;
    rc = nvm_set_config(&cfg);
    if(rc != STATUS_OK) {
        return -1;
    }
    
    nvm_get_parameters(&params);    

    /* the samd21 flash doesn't use sector terminology. They use Row and 
     * page.  A row contains 4 pages. Each pages is a fixed size.  You can
     * only erase based on row. Here I will map the rows to sectors and 
     * deal with pages inside this driver.   */    
    samd21_flash_dev.hf_itf = &samd21_flash_funcs;
    samd21_flash_dev.hf_base_addr = SAMD21_FLASH_START_ADDR;
    samd21_flash_dev.hf_size = params.nvm_number_of_pages * params.page_size;
    samd21_flash_dev.hf_sector_cnt = 
            params.nvm_number_of_pages/SAMD21_FLASH_PAGES_PER_SECTOR;
    samd21_flash_dev.hf_align = 1;
    
    return 0;
}
Esempio n. 3
0
//! [setup]
void configure_nvm(void)
{
//! [setup_1]
	struct nvm_config config_nvm;
//! [setup_1]

//! [setup_2]
	nvm_get_config_defaults(&config_nvm);
//! [setup_2]

//! [setup_3]
	config_nvm.manual_page_write = false;
//! [setup_3]

//! [setup_4]
	nvm_set_config(&config_nvm);
//! [setup_4]
}
Esempio n. 4
0
otError utilsFlashInit(void)
{
    otError           error = OT_ERROR_NONE;
    struct nvm_config configNvm;

    nvm_get_config_defaults(&configNvm);

    configNvm.manual_page_write = false;

    enum status_code status;

    while ((status = nvm_set_config(&configNvm)) == STATUS_BUSY)
        ;

    if (status != STATUS_OK)
    {
        error = OT_ERROR_FAILED;
    }

    return error;
}
Esempio n. 5
0
/*---------------------------------------------------------------------------*/
static int
open(void)
{
  if (!opened) {
    struct nvm_config config_nvm;
    nvm_get_config_defaults(&config_nvm);
    nvm_set_config(&config_nvm);
    nvm_get_parameters(&parameters);

    TRACE("bootloader_number_of_pages: %ld, eeprom_number_of_pages: %ld, nvm_number_of_pages: %d, page_size: %d",
          parameters.bootloader_number_of_pages,
          parameters.eeprom_number_of_pages,
          parameters.nvm_number_of_pages,
          parameters.page_size);

    while (!nvm_is_ready());

    opened = 1;
  }

  return 1;
}
/**
 * \brief Main application
 */
int main(void)
{
	uint32_t len;
	uint32_t curr_prog_addr;
	uint32_t tmp_len;
	uint8_t buff[NVMCTRL_PAGE_SIZE];
	struct nvm_config config;

	/* Check switch state to enter boot mode or application mode */
	check_boot_mode();

	/*
	 * Application to be programmed from APP_START_ADDRESS defined in
	 * conf_bootloader.h
	 */
	curr_prog_addr = APP_START_ADDRESS;

	/* Initialize system */
	system_init();


	/* Configure the SPI slave module */
	configure_spi();

	/* Get NVM default configuration and load the same */
	nvm_get_config_defaults(&config);
	config.manual_page_write = false;
	nvm_set_config(&config);

	/* Turn on LED */
	port_pin_set_output_level(BOOT_LED, false);
	/* Get the length to be programmed */
	len = get_length();

	do {
		/* Get remaining or NVMCTRL_PAGE_SIZE as block length */
		tmp_len = min(NVMCTRL_PAGE_SIZE, len);

		/* Acknowledge last received data */
		send_ack();

		/* Read data from SPI master */
		fetch_data(buff, tmp_len);

		/* Program the data into Flash */
		program_memory(curr_prog_addr, buff, tmp_len);

		/* Increment the current programming address */
		curr_prog_addr += tmp_len;

		/* Update the length to remaining length to be programmed */
		len -= tmp_len;

		/* Do this for entire length */
	} while (len != 0);

	/* Acknowledge last block */
	send_ack();

	/* Reset module and boot into application */
	NVIC_SystemReset();

	while (1) {
		/* Inf loop */
	}

}
Esempio n. 7
0
/**
 * \brief Main application
 */
int main(void)
{
	char test_file_name[] = "0:sd_image.bin";
	FRESULT res;
	FATFS fs;
	FIL file_object;
	uint32_t len=0;
	uint32_t curr_prog_addr=APP_START_ADDRESS;
	struct nvm_config config;
	UINT iRead=0;
    
	check_boot_mode();
	system_init();
	delay_init();

	irq_initialize_vectors();
	cpu_irq_enable();

	/* Initialize SD MMC stack */
	sd_mmc_init();
	
	nvm_get_config_defaults(&config);
	nvm_set_config(&config);
		/* Turn ON  LED */
	port_pin_set_output_level(BOOT_LED, false);
#ifdef __DEBUG_PRINT__	
    serial_port_init();
	printf("\x0C\n\r-- SD/MMC Card FatFs Boot Loader --\n\r");
	printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
	printf("Please plug an SD/MMC card in slot.\n\r");
#endif	

		/* Wait card present and ready */
	sd_mmc_ready();
	memset(&fs, 0, sizeof(FATFS));
	res = f_mount(LUN_ID_SD_MMC_0_MEM, &fs);
	if (FR_INVALID_DRIVE == res) {
		#ifdef __DEBUG_PRINT__	
		printf("[FAIL] Mounting SD card failed result= %d\r\n", res);
		#endif
			
	}
	#ifdef __DEBUG_PRINT__	
	printf("Mounting the SD card successful...\r\n");
	#endif
   
	res =f_open(&file_object,(const char *)test_file_name,FA_READ);
	if(res != FR_OK) error_fatal(FILE_OPEN_ERROR);
	do {
		if(file_object.fsize > MAX_CODE_SIZE) error_fatal(MAX_SIZE_ERROR);
		res = f_read(&file_object, (void *) buff, MAX_BUF_SIZE, &iRead);
		if(res != FR_OK) error_fatal(FILE_READ_ERROR);
	
		/* Program the read data into Flash */
		if(iRead)
		{
			program_memory(curr_prog_addr, buff,iRead);
			#ifdef __DEBUG_PRINT__
			printf("*");
			#endif
		}

		/* Increment the current programming address */
		curr_prog_addr += iRead;
		len += iRead;
	
		if(len > MAX_CODE_SIZE)
		error_fatal(MAX_SIZE_ERROR);

		/* Do this till end of file */
	} while (iRead != 0);

#ifdef __DEBUG_PRINT__		
printf("\r\n[PROGRAMMING COMPLETED]..Resetting !!!!\r\n");
#endif
		// Intentionally not closing the file object to reduce code size !!!.
		start_application();
		while(1);
		 // Should have reset by now !!!.		
}