// Initialise all registered device. Any device that fails to // initialise we leave dev->init as false. Then sort the devices into // ascending order of address and put them into a linked list. Lastly // check if we have any overlap of the addresses. __externC int cyg_flash_init(cyg_flash_printf *pf) { int err; struct cyg_flash_dev * dev; CYG_ASSERT(&(cyg_flashdevtab[CYGHWR_IO_FLASH_DEVICE]) == &cyg_flashdevtab_end, "incorrect number of flash devices"); // In case the printf function has changed. if (NULL != pf) cyg_flash_set_global_printf(pf); if (init) { return CYG_FLASH_ERR_OK; } for (dev = &cyg_flashdevtab[0]; dev != &cyg_flashdevtab_end; dev++) { LOCK_INIT(dev); err = dev->funs->flash_init(dev); if (err != CYG_FLASH_ERR_OK) { continue; } CYG_ASSERT(dev->funs, "No flash functions"); CYG_ASSERT(dev->num_block_infos, "No number of block infos"); CYG_ASSERT(dev->block_info, "No block infos"); CYG_ASSERT(!(((cyg_flashaddr_t)dev->block_info >= dev->start) && ((cyg_flashaddr_t)dev->block_info < dev->end)), "Block info is in the flash"); CYG_ASSERT(dev->funs->flash_erase_block, "No erase function"); CYG_ASSERT(dev->funs->flash_program, "No program function"); #ifdef CYGDBG_USE_ASSERTS { int i; cyg_flashaddr_t addr = dev->start; for (i = 0; i < dev->num_block_infos; i++) { addr += dev->block_info[i].block_size * dev->block_info[i].blocks; } CYG_ASSERT(dev->end == addr-1, "Invalid end address"); } #endif dev->init = true; } #if (1 == CYGHWR_IO_FLASH_DEVICE) // Make sure there is one device, otherwise we could end up // accessing a non-existent cyg_flash_dev structure. if (&(cyg_flashdevtab[0]) == &cyg_flashdevtab_end) { return CYG_FLASH_ERR_INVALID; } #else // Place the devices on a sorted linked list and check that there // are no overlaps in the address space. if (! flash_sort_and_check() ) { return CYG_FLASH_ERR_INVALID; } #endif // Only mark the flash subsystem as initialized if the world is // consistent. init = true; return CYG_FLASH_ERR_OK; }
/** * Initialize flash library and data storage in flash * We use two blocks in flash for data storage. One block is used for the * default data that will be restored. The default parameters are stored * at address CO_OD_Flash_Default_Param. The data that will be loaded at * startup or saved if user modifies data is store at CO_OD_Flash_Adress. */ void CO_FlashInit(void) { int i = 0; // // Initialize flash library // int Result = cyg_flash_init(0); CHECK_FLASH_RESULT(Result); #ifdef CYGDBG_IO_CANOPEN_DEBUG cyg_flash_set_global_printf(diag_printf); #endif // // Read info about flash device (number of blocks. block size) // Result = cyg_flash_get_info(0, &flash_info); CHECK_FLASH_RESULT(Result); CO_DBG_PRINT("Flash info dev %d: 0x%x - 0x%x, %d blocks\n", 0, flash_info.start, flash_info.end, flash_info.num_block_infos); const cyg_flash_block_info_t* block_info = flash_info.block_info; for (i = 0; i < flash_info.num_block_infos; ++i) { CO_DBG_PRINT("Block %d: block size: %d blocks: %d\n", i, block_info->block_size, block_info->blocks); block_info++; } // // Calculate addresses for flash data and default flash data // block_info = &flash_info.block_info[flash_info.num_block_infos - 1]; CO_DBG_PRINT("Last block - block size: %d blocks: %d\n", block_info->block_size, block_info->blocks); CO_OD_Flash_Adress = flash_info.end + 1 + (CYGNUM_CANOPEN_FLASH_DATA_BLOCK * block_info->block_size); CO_DBG_PRINT("CO_OD_Flash_Adress 0x%8x\n", CO_OD_Flash_Adress); CO_OD_Flash_Default_Param = CO_OD_Flash_Adress - block_info->block_size; CO_DBG_PRINT("CO_OD_Flash_Default_Param 0x%8x\n", CO_OD_Flash_Default_Param); // // Before we can access the data, we need to make sure, that the flash // block are properly initialized. We do this by reading the block into // a local sCO_OD_ROM variable and verifying the FirstWord and LastWord // members // cyg_flashaddr_t ErrorAddress; struct sCO_OD_ROM DefaultObjDicParam; Result = cyg_flash_read(CO_OD_Flash_Default_Param, &DefaultObjDicParam, sizeof(DefaultObjDicParam), &ErrorAddress); CHECK_FLASH_RESULT(Result); // // If the default parameters are not present in flash, then we know that // we need to create them for later restore // if ((DefaultObjDicParam.FirstWord != CO_OD_FIRST_LAST_WORD) ||(DefaultObjDicParam.LastWord != CO_OD_FIRST_LAST_WORD)) { storeParameters(CO_OD_Flash_Adress, OD_H1010_STORE_PARAM_ALL); storeParameters(CO_OD_Flash_Default_Param, OD_H1010_STORE_PARAM_ALL); } else { restoreParameters(CO_OD_Flash_Adress, OD_H1010_STORE_PARAM_ALL); } }
void cyg_user_start(void) { int ret; cyg_flashaddr_t flash_start=0, flash_end=0; cyg_flash_info_t info; cyg_uint32 i=0; cyg_uint32 j; int block_size=0, blocks=0; cyg_flashaddr_t prog_start; unsigned char * ptr; CYG_TEST_INIT(); cyg_flash_set_global_printf((cyg_flash_printf *)&diag_printf); ret=cyg_flash_init(NULL); CYG_TEST_PASS_FAIL((ret == CYG_FLASH_ERR_OK),"flash_init"); do { ret = cyg_flash_get_info(i, &info); if (ret == CYG_FLASH_ERR_OK) { diag_printf("INFO: Nth=%d, start=%p, end=%p\n", i, (void *) info.start, (void *) info.end); if (i == 0) { flash_start = info.start; flash_end = info.end; block_size = info.block_info[0].block_size; blocks = info.block_info[0].blocks; } for (j=0;j < info.num_block_infos; j++) { diag_printf("INFO:\t block_size %zd, blocks %u\n", info.block_info[j].block_size, info.block_info[j].blocks); } } i++; } while (ret != CYG_FLASH_ERR_INVALID); /* Erase the whole flash. Not recommended on real hardware since this will probably erase the bootloader etc!!! */ ret=cyg_flash_erase(flash_start,block_size * blocks,NULL); CYG_TEST_PASS_FAIL((ret == CYG_FLASH_ERR_OK),"flash_erase1"); /* check that its actually been erased, and test the mmap area */ for (ptr=(unsigned char *)flash_start,ret=0; ptr <= (unsigned char *)flash_end; ptr++) { if (*ptr != 0xff) { ret++; } } CYG_TEST_PASS_FAIL((ret == 0),"flash empty check"); ret = cyg_flash_program(flash_start,©right,sizeof(copyright),NULL); CYG_TEST_PASS_FAIL((ret == CYG_FLASH_ERR_OK),"flash_program1"); /* Check the contents made it into the flash */ CYG_TEST_PASS_FAIL(!strncmp((void *)flash_start, copyright,sizeof(copyright)), "flash program contents"); /* .. and check nothing else changed */ for (ptr=(unsigned char *)flash_start+sizeof(copyright),ret=0; ptr < (unsigned char *)flash_end; ptr++) { if (*ptr != 0xff) { ret++; } } CYG_TEST_PASS_FAIL((ret == 0),"flash program overrun check"); /* Program over a block boundary */ prog_start = flash_start + block_size - sizeof(copyright)/2; ret = cyg_flash_program(prog_start,©right,sizeof(copyright),NULL); CYG_TEST_PASS_FAIL((ret == CYG_FLASH_ERR_OK),"flash_program2"); /* Check the first version is still OK */ CYG_TEST_PASS_FAIL(!strncmp((void *)flash_start, copyright, sizeof(copyright)), "Original contents"); CYG_TEST_PASS_FAIL(!strncmp((void *)prog_start, copyright, sizeof(copyright)), "New program contents"); /* Check the bit in between is still erased */ for (ptr=(unsigned char *)flash_start+sizeof(copyright),ret=0; ptr < (unsigned char *)prog_start; ptr++) { if (*ptr != 0xff) { ret++; } } CYG_TEST_PASS_FAIL((ret == 0),"flash erase check1"); /* Erase the second block and make sure the first is not erased */ ret=cyg_flash_erase(flash_start+block_size,block_size,NULL); CYG_TEST_PASS_FAIL((ret == CYG_FLASH_ERR_OK),"flash_erase2"); /* Check the erase worked */ for (ptr=(unsigned char *)flash_start+block_size,ret=0; ptr < (unsigned char *)flash_start+block_size*2; ptr++) { if (*ptr != 0xff) { ret++; } } CYG_TEST_PASS_FAIL((ret == 0), "flash erase check2"); /* Lastly check the first half of the copyright message is still there */ CYG_TEST_PASS_FAIL(!strncmp((void *)prog_start, copyright, sizeof(copyright)/2), "Block 1 OK"); #if 0 /* This test is be fatal! Its not run by default! Check the flash is read only, by trying to write to it. We expect to get an exception */ *(char *)flash_start = 'a'; #endif CYG_TEST_PASS_FINISH("flash2"); }