OSStatus mico_platform_init( void ) { #if defined(__CC_ARM) platform_log("Platform initialised, build by RVMDK"); #elif defined (__IAR_SYSTEMS_ICC__) platform_log("Platform initialised, build by IAR"); #endif if ( true == platform_watchdog_check_last_reset() ) { platform_log( "WARNING: Watchdog reset occured previously. Please see platform_watchdog.c for debugging instructions." ); } #ifdef USES_RESOURCE_FILESYSTEM platform_filesystem_init(); #endif #ifndef BOOTLOADER #ifdef USE_MiCOKit_EXT micokit_ext_init(); #endif #ifdef USE_MiCOKit_STMEMS micokit_STmems_init(); #endif #endif return kNoErr; }
OSStatus mico_platform_init( void ) { platform_log( "Platform initialised" ); if ( true == watchdog_check_last_reset() ) { platform_log( "WARNING: Watchdog reset occured previously. Please see watchdog.c for debugging instructions." ); } return kNoErr; }
OSStatus platform_i2c_init( const platform_i2c_t* i2c, const platform_i2c_config_t* config ) { UNUSED_PARAMETER(i2c); UNUSED_PARAMETER(config); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_adc_init( const platform_adc_t* adc, uint32_t sample_cycle ) { UNUSED_PARAMETER(adc); UNUSED_PARAMETER(sample_cycle); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_spi_init( const platform_spi_t* spi, const platform_spi_config_t* config ) { UNUSED_PARAMETER(spi); UNUSED_PARAMETER(config); platform_log("unimplemented"); return kUnsupportedErr; }
bool platform_i2c_probe_device( const platform_i2c_t* i2c, const platform_i2c_config_t* config, int retries ) { UNUSED_PARAMETER(i2c); UNUSED_PARAMETER(config); UNUSED_PARAMETER(retries); platform_log("unimplemented"); return false; }
OSStatus mico_platform_init( void ) { #ifdef DEBUG #if defined(__CC_ARM) platform_log("Build by Keil"); #elif defined (__IAR_SYSTEMS_ICC__) platform_log("Build by IAR"); #endif #endif platform_log( "Mico platform initialised" ); if ( true == watchdog_check_last_reset() ) { platform_log( "WARNING: Watchdog reset occured previously. Please see watchdog.c for debugging instructions." ); } return kNoErr; }
OSStatus platform_spi_init( platform_spi_driver_t* driver, const platform_spi_t* peripheral, const platform_spi_config_t* config ) { UNUSED_PARAMETER(driver); UNUSED_PARAMETER(peripheral); UNUSED_PARAMETER(config); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_adc_take_sample_stream( const platform_adc_t* adc, void* buffer, uint16_t buffer_length ) { UNUSED_PARAMETER(adc); UNUSED_PARAMETER(buffer); UNUSED_PARAMETER(buffer_length); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_i2c_transfer( const platform_i2c_t* i2c, const platform_i2c_config_t* config, platform_i2c_message_t* messages, uint16_t number_of_messages ) { UNUSED_PARAMETER(i2c); UNUSED_PARAMETER(config); UNUSED_PARAMETER(messages); UNUSED_PARAMETER(number_of_messages); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_spi_transfer( const platform_spi_t* spi, const platform_spi_config_t* config, const platform_spi_message_segment_t* segments, uint16_t number_of_segments ) { UNUSED_PARAMETER(spi); UNUSED_PARAMETER(config); UNUSED_PARAMETER(segments); UNUSED_PARAMETER(number_of_segments); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_i2c_init_rx_message( platform_i2c_message_t* message, void* rx_buffer, uint16_t rx_buffer_length, uint16_t retries ) { UNUSED_PARAMETER(message); UNUSED_PARAMETER(rx_buffer); UNUSED_PARAMETER(rx_buffer_length); UNUSED_PARAMETER(retries); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus mico_platform_init( void ) { platform_log( "Platform initialised" ); // Initialise EasyLink buttons MicoGpioInitialize( (mico_gpio_t)EasyLink_BUTTON, INPUT_PULL_UP ); mico_init_timer(&_button_EL_timer, RestoreDefault_TimeOut, _button_EL_Timeout_handler, NULL); MicoGpioEnableIRQ( (mico_gpio_t)EasyLink_BUTTON, IRQ_TRIGGER_BOTH_EDGES, _button_EL_irq_handler, NULL ); return kNoErr; }
OSStatus internalFlashInitialize( void ) { platform_log_trace(); uint32_t ul_rc; ul_rc = flash_init(FLASH_ACCESS_MODE_128, 6);//TBD! 3-4 wait in 128bit, 1 in 64bit if (ul_rc != FLASH_RC_OK) { platform_log("flash err:%d",ul_rc); return kGeneralErr; } return kNoErr; }
OSStatus internalFlashErase(uint32_t start_address, uint32_t end_address) { platform_log_trace(); OSStatus err = kNoErr; uint32_t page_addr = start_address; uint32_t page_off = page_addr % (IFLASH_PAGE_SIZE*16); uint32_t rc, erased = 0; uint32_t size = end_address - start_address; if (page_off) { platform_log("flash: erase address must be 16 page aligned"); page_addr = page_addr - page_off; platform_log("flash: erase from %x", (unsigned)page_addr); } for (erased = 0; erased < size;) { rc = flash_erase_page((uint32_t)page_addr, IFLASH_ERASE_PAGES_16); erased += IFLASH_PAGE_SIZE*16; page_addr += IFLASH_PAGE_SIZE*16; if (rc != FLASH_RC_OK) { platform_log("flash: %x erase error", (unsigned)page_addr); return kGeneralErr; } } return err; }
void platform_mcu_enter_standby(uint32_t secondsToWakeup) { platform_rtc_time_t time; uint32_t currentSecond; RTC_AlarmTypeDef RTC_AlarmStructure; PWR_WakeUpPinCmd(ENABLE); if(secondsToWakeup == MICO_WAIT_FOREVER) PWR_EnterSTANDBYMode(); platform_log("Wake up in %d seconds", secondsToWakeup); platform_rtc_get_time(&time); currentSecond = time.hr*3600 + time.min*60 + time.sec; currentSecond += secondsToWakeup; RTC_AlarmStructure.RTC_AlarmTime.RTC_H12 = RTC_HourFormat_24; RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours = currentSecond/3600%24; RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = currentSecond/60%60; RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = currentSecond%60; RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31; RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date; RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ; RTC_AlarmCmd(RTC_Alarm_A, DISABLE); /* Disable the Alarm A */ RTC_ITConfig(RTC_IT_ALRA, DISABLE); /* Clear RTC Alarm Flag */ RTC_ClearFlag(RTC_FLAG_ALRAF); RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure); /* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from STANDBY mode (RTC Alarm IT not enabled in NVIC) */ RTC_ITConfig(RTC_IT_ALRA, ENABLE); /* Enable the Alarm A */ RTC_AlarmCmd(RTC_Alarm_A, ENABLE); PWR_EnterSTANDBYMode(); }
OSStatus internalFlashWrite(volatile uint32_t* flash_address, uint32_t* data ,uint32_t data_length) { platform_log_trace(); OSStatus err = kNoErr; //page write length IFLASH_PAGE_SIZE uint32_t rc ; mem_flash_op_enter(); #if SAMG55 rc = flash_write((*flash_address), data, data_length, false); #else rc = flash_write((*flash_address), data, data_length, true); #endif mem_flash_op_exit(); if (rc != FLASH_RC_OK) { platform_log("flash err: %d",rc); return kGeneralErr; } *flash_address += data_length; exit: return err; }
void UART_DRV_CompleteSendData(uint32_t instance) { // assert(instance < HW_UART_UART_APP_INDEX_COUNT); mico_uart_t uart; if(instance == BOARD_APP_UART_INSTANCE) uart = MICO_UART_1; else uart = MICO_UART_2; uint32_t baseAddr = g_uartBaseAddr[instance]; uart_state_t * uartState = (uart_state_t *)g_uartStatePtr[instance]; platform_log("CompleteSend"); /* Disable the transmitter data register empty interrupt */ UART_HAL_SetTxDataRegEmptyIntCmd(baseAddr, false); /* Signal the synchronous completion object. */ if (uartState->isTxBlocking) { OSA_SemaPost(&uartState->txIrqSync); mico_rtos_set_semaphore(&uart_interfaces[uart].tx_complete); } /* Update the information of the module driver state */ uartState->isTxBusy = false; }
void init_platform_bootloader( void ) { uint32_t BootNvmInfo; OSStatus err; MicoGpioInitialize( BOOT_SEL, INPUT_PULL_UP ); MicoGpioInitialize( MFG_SEL, INPUT_PULL_UP ); #ifdef MICO_ATE_START_ADDRESS MicoGpioInitialize( EasyLink_BUTTON, INPUT_PULL_UP ); #endif /* Check USB-HOST is inserted */ err = MicoGpioInitialize( (mico_gpio_t)USB_DETECT, INPUT_PULL_DOWN ); require_noerr(err, exit); mico_thread_msleep_no_os(2); require_string( MicoGpioInputGet( (mico_gpio_t)USB_DETECT ) == true, exit, "USB device is not inserted" ); //platform_log("USB device inserted"); if( HardwareInit(DEV_ID_USB) ){ FolderOpenByNum(&RootFolder, NULL, 1); FileBrowse(RootFolder.FsContext); } /* Check last firmware update is success or not. */ NvmRead(UPGRADE_NVM_ADDR, (uint8_t*)&BootNvmInfo, 4); if(false == UpgradeFileFound) { if(BootNvmInfo == UPGRADE_SUCC_MAGIC) { /* * boot up check for the last time */ platform_log("[UPGRADE]:upgrade successful completely"); } else if(BootNvmInfo == (uint32_t)UPGRADE_ERRNO_NOERR) { platform_log("[UPGRADE]:no upgrade, boot normallly"); } else if(BootNvmInfo == (uint32_t)UPGRADE_ERRNO_CODBUFDAT) { platform_log("[UPGRADE]:upgrade successful partly, data fail"); } else { platform_log("[UPGRADE]:upgrade error, errno = %d", (int32_t)BootNvmInfo); } } else { if(BootNvmInfo == (uint32_t)UPGRADE_ERRNO_NOERR) { platform_log("[UPGRADE]:found upgrade ball, prepare to boot upgrade"); BootNvmInfo = UPGRADE_REQT_MAGIC; NvmWrite(UPGRADE_NVM_ADDR, (uint8_t*)&BootNvmInfo, 4); //if you want PORRESET to reset GPIO only,uncomment it //GpioPorSysReset(GPIO_RSTSRC_PORREST); NVIC_SystemReset(); while(1);;; } else if(BootNvmInfo == UPGRADE_SUCC_MAGIC) { BootNvmInfo = (uint32_t)UPGRADE_ERRNO_NOERR; NvmWrite(UPGRADE_NVM_ADDR, (uint8_t*)&BootNvmInfo, 4); platform_log("[UPGRADE]:found upgrade ball file for the last time, re-plugin/out, if you want to upgrade again"); } else { platform_log("[UPGRADE]:upgrade error, errno = %d", (int32_t)BootNvmInfo); if( BootNvmInfo == -9 ) { platform_log("[UPGRADE]:Same file, no need to update"); goto exit; } BootNvmInfo = (uint32_t)UPGRADE_ERRNO_NOERR; NvmWrite(UPGRADE_NVM_ADDR, (uint8_t*)&BootNvmInfo, 4); BootNvmInfo = UPGRADE_REQT_MAGIC; NvmWrite(UPGRADE_NVM_ADDR, (uint8_t*)&BootNvmInfo, 4); //if you want PORRESET to reset GPIO only,uncomment it //GpioPorSysReset(GPIO_RSTSRC_PORREST); NVIC_SystemReset(); } } exit: return; }
OSStatus host_platform_spi_transfer( bus_transfer_direction_t dir, uint8_t* buffer, uint16_t buffer_length ) { OSStatus result; uint8_t *junk; MCU_CLOCKS_NEEDED(); #ifdef USE_OWN_SPI_DRV pdc_packet_t pdc_spi_packet; pdc_spi_packet.ul_addr = (uint32_t)buffer; pdc_spi_packet.ul_size = buffer_length; pdc_tx_init(spi_m_pdc, &pdc_spi_packet, NULL); if ( dir == BUS_READ ) { pdc_spi_packet.ul_addr = (uint32_t)buffer; pdc_spi_packet.ul_size = buffer_length; } if ( dir == BUS_WRITE ) { junk = malloc(buffer_length); pdc_spi_packet.ul_addr = (uint32_t)junk; pdc_spi_packet.ul_size = buffer_length; } pdc_rx_init(spi_m_pdc, &pdc_spi_packet, NULL); #if 0 if ( dir == BUS_WRITE ) { spi_enable_interrupt(SPI_MASTER_BASE, SPI_IER_ENDTX); NVIC_EnableIRQ(SPI_IRQn); } else { spi_enable_interrupt(SPI_MASTER_BASE, SPI_IER_ENDRX); NVIC_EnableIRQ(SPI_IRQn); } #endif //platform_log("dir = %d, len = %d",dir, buffer_length);//TBD #ifndef HARD_CS_NSS0 mico_gpio_output_low( MICO_GPIO_15 ); #endif /* Enable the RX and TX PDC transfer requests */ pdc_enable_transfer(spi_m_pdc, PERIPH_PTCR_TXTEN | PERIPH_PTCR_RXTEN);//pdc buffer address increase automatic. //platform_log("pdc status = 0x%x",pdc_read_status(spi_m_pdc)); #ifndef NO_MICO_RTOS result = mico_rtos_get_semaphore( &spi_transfer_finished_semaphore, 100 ); #else /* Waiting transfer done*/ while((spi_read_status(SPI_MASTER_BASE) & SPI_SR_RXBUFF) == 0) { __asm("wfi"); } #endif if ( dir == BUS_WRITE ) { if (junk) free(junk); } /* Disable the RX and TX PDC transfer requests */ pdc_disable_transfer(spi_m_pdc, PERIPH_PTCR_RXTDIS | PERIPH_PTCR_TXTDIS); #ifndef HARD_CS_NSS0 mico_gpio_output_high( MICO_GPIO_15 ); #endif #if 1 //clear PDC Perph Status flags pdc_spi_packet.ul_addr = NULL; pdc_spi_packet.ul_size = 3; pdc_tx_init(spi_m_pdc, &pdc_spi_packet, NULL); pdc_rx_init(spi_m_pdc, &pdc_spi_packet, NULL); #endif #else //spi_master_vec : tx_dscr[0].data = buffer; tx_dscr[0].length = buffer_length; tx_dscr[1].data = NULL; tx_dscr[1].length = 0; //if ( dir == BUS_READ ) { rx_dscr[0].data = buffer; rx_dscr[0].length = buffer_length; //} else { // rx_dscr[0].data = &junk; // rx_dscr[0].length = 0; //} rx_dscr[1].data = NULL; rx_dscr[1].length = 0; #ifndef HARD_CS_NSS0 mico_gpio_output_low( MICO_GPIO_15 ); #endif if (spi_master_vec_transceive_buffer_wait(&spi_master, tx_dscr, rx_dscr) != STATUS_OK) { platform_log("STATUS = -1"); return kGeneralErr; } #ifndef HARD_CS_NSS0 mico_gpio_output_high( MICO_GPIO_15 ); #endif #endif /* USE_OWN_SPI_DR */ MCU_CLOCKS_NOT_NEEDED(); #ifdef USE_OWN_SPI_DRV return result; #else return 0; #endif }
OSStatus platform_adc_deinit( const platform_adc_t* adc ) { UNUSED_PARAMETER(adc); platform_log("unimplemented"); return kNotPreparedErr; }
OSStatus platform_rtc_init(void) { platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_spi_deinit( platform_spi_driver_t* driver ) { UNUSED_PARAMETER(driver); platform_log("unimplemented"); return kUnsupportedErr; }
OSStatus platform_rtc_get_time( platform_rtc_time_t* time) { UNUSED_PARAMETER(time); platform_log("unimplemented"); return kUnsupportedErr; }
void init_platform_bootloader( void ) { OSStatus err = kNoErr; MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); /* Specific operations used in EMW3165 production */ #define NEED_RF_DRIVER_COPY_BASE ((uint32_t)0x08008000) #define TEMP_RF_DRIVER_BASE ((uint32_t)0x08040000) #define TEMP_RF_DRIVER_END ((uint32_t)0x0807FFFF) const uint8_t isDriverNeedCopy = *(uint8_t *)(NEED_RF_DRIVER_COPY_BASE); const uint32_t totalLength = ( DRIVER_FLASH_SIZE < 0x40000)? DRIVER_FLASH_SIZE:0x40000; const uint8_t crcResult = *(uint8_t *)(TEMP_RF_DRIVER_END); uint8_t targetCrcResult = 0; uint32_t copyLength; uint32_t destStartAddress_tmp = DRIVER_START_ADDRESS; uint32_t sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; uint32_t i; if ( isDriverNeedCopy != 0x0 ) return; platform_log( "Bootloader start to copy RF driver..." ); /* Copy RF driver to SPI flash */ err = MicoFlashInitialize( (mico_flash_t)MICO_FLASH_FOR_DRIVER ); require_noerr(err, exit); err = MicoFlashInitialize( (mico_flash_t)MICO_INTERNAL_FLASH ); require_noerr(err, exit); err = MicoFlashErase( MICO_FLASH_FOR_DRIVER, DRIVER_START_ADDRESS, DRIVER_END_ADDRESS ); require_noerr(err, exit); platform_log( "Time: %d", mico_get_time_no_os() ); for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = MicoFlashRead( MICO_INTERNAL_FLASH, &sourceStartAddress_tmp, data , copyLength ); require_noerr( err, exit ); err = MicoFlashWrite( MICO_FLASH_FOR_DRIVER, &destStartAddress_tmp, data, copyLength); require_noerr(err, exit); } printf("\r\n"); /* Check CRC-8 check-sum */ platform_log( "Bootloader start to verify RF driver..." ); sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; destStartAddress_tmp = DRIVER_START_ADDRESS; for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = MicoFlashRead( MICO_FLASH_FOR_DRIVER, &destStartAddress_tmp, data, copyLength ); require_noerr( err, exit ); targetCrcResult = CRC8_Table(targetCrcResult, data, copyLength); } printf("\r\n"); //require_string( crcResult == targetCrcResult, exit, "Check-sum error" ); if( crcResult != targetCrcResult ){ platform_log("Check-sum error"); while(1); } /* Clear RF driver from temperary storage */ platform_log("Bootloader start to clear RF driver temporary storage..."); err = MicoFlashInitialize( (mico_flash_t)MICO_INTERNAL_FLASH ); require_noerr(err, exit); /* Clear copy tag */ err = MicoFlashErase(MICO_INTERNAL_FLASH, NEED_RF_DRIVER_COPY_BASE, NEED_RF_DRIVER_COPY_BASE); require_noerr(err, exit); exit: MicoFlashFinalize( MICO_INTERNAL_FLASH ); MicoFlashFinalize( MICO_FLASH_FOR_DRIVER ); }
OSStatus host_platform_sdio_transfer( bus_transfer_direction_t direction, sdio_command_t command, sdio_transfer_mode_t mode, sdio_block_size_t block_size, uint32_t argument, /*@null@*/ uint32_t* data, uint16_t data_size, sdio_response_needed_t response_expected, /*@out@*/ /*@null@*/ uint32_t* response ) { UNUSED_PARAMETER(mode); OSStatus result = kNoErr; uint16_t attempts = 0; uint8_t response_full[6]; uint32_t blockNumber, blockIdx; bool status; check_string(!((command == SDIO_CMD_53) && (data == NULL)), "Bad args" ); if ( response != NULL ) { *response = 0; } MCU_CLOCKS_NEEDED(); restart: // SDIO->ICR = (uint32_t) 0xFFFFFFFF; ++attempts; /* Check if we've tried too many times */ if (attempts >= (uint16_t) BUS_LEVEL_MAX_RETRIES) { result = kGeneralErr; platform_log("SDIO error!"); mico_thread_sleep(0xFFFFFFFF); goto exit; } /* Prepare the data transfer register */ if ( command == SDIO_CMD_53 ) { if ( direction == BUS_READ ) { if(mode == SDIO_BYTE_MODE) SdioStartReciveData((uint8_t*)data, data_size); else SdioStartReciveData((uint8_t*)data, block_size); //require_noerr_quiet(SdioSendCommand(command, argument, 2), restart); SdioDataInterruptEn(); waiting = true; status = SdioSendCommand(command, argument, 1); if(status != 0){ goto restart; } result = mico_rtos_get_semaphore( &sdio_transfer_finished_semaphore, (uint32_t) 50 ); waiting = false; if ( result != kNoErr ) { printf("@@, %d", data_size); //SdioDataInterruptDis(); goto restart; } //while(!SdioIsDatTransDone()); if(mode == SDIO_BLOCK_MODE){ blockNumber = argument & (uint32_t) ( 0x1FF ) ; for( blockIdx = 1; blockIdx < blockNumber; blockIdx++ ){ SdioStartReciveData( (uint8_t *)data + blockIdx * block_size, block_size); waiting = true; result = mico_rtos_get_semaphore( &sdio_transfer_finished_semaphore, (uint32_t) 50 ); waiting = false; if ( result != kNoErr ) { printf("@, %d", data_size); //SdioDataInterruptDis(); goto restart; } //while(!SdioIsDatTransDone()); } } SdioEndDatTrans(); SdioDataInterruptDis(); //memcpy( data, temp_dma_buffer, (size_t) data_size ); }else{ //memcpy(temp_dma_buffer, data, data_size); //require_noerr_quiet(SdioSendCommand(command, argument, 2), restart); status = SdioSendCommand(command, argument, 1); if(status != 0){ goto restart; } SdioDataInterruptEn(); if(mode == SDIO_BYTE_MODE){ waiting = true; SdioStartSendData((uint8_t *)data, data_size); result = mico_rtos_get_semaphore( &sdio_transfer_finished_semaphore, (uint32_t) 50 ); waiting = false; if ( result != kNoErr ) { printf("$, %d", data_size); //SdioDataInterruptDis(); goto restart; } //while(!SdioIsDatTransDone()); }else{ blockNumber = argument & (uint32_t) ( 0x1FF ) ; for( blockIdx = 0; blockIdx < blockNumber; blockIdx++ ){ SdioStartSendData( (uint8_t *)data + blockIdx * block_size, block_size); waiting = true; result = mico_rtos_get_semaphore( &sdio_transfer_finished_semaphore, (uint32_t) 50 ); waiting = false; if ( result != kNoErr ) { printf("-, %d", data_size); //SdioDataInterruptDis(); goto restart; } //while(!SdioIsDatTransDone()); } } SdioEndDatTrans(); SdioDataInterruptDis(); } } else { status = SdioSendCommand(command, argument, 50); if( response_expected == RESPONSE_NEEDED && status != 0 ) { goto restart; } } if ( response != NULL ) { SdioGetCmdResp(response_full, 6); *response = hton32(*(uint32_t *)&response_full[1]); } result = kNoErr; exit: MCU_CLOCKS_NOT_NEEDED(); return result; }
OSStatus platform_spi_deinit( const platform_spi_t* spi ) { UNUSED_PARAMETER( spi ); platform_log("unimplemented"); return kUnsupportedErr; }
void platform_mcu_enter_standby(uint32_t secondsToWakeup) { platform_log("unimplemented"); return; }
OSStatus platform_adc_take_sample( const platform_adc_t* adc, uint16_t* output ) { UNUSED_PARAMETER(output); platform_log("unimplemented"); return kUnsupportedErr; }
void init_platform_bootloader( void ) { CRC8_Context crc; OSStatus err = kNoErr; mico_logic_partition_t *rf_partition = MicoFlashGetInfo( MICO_PARTITION_RF_FIRMWARE ); MicoGpioInitialize( (mico_gpio_t)MICO_SYS_LED, OUTPUT_PUSH_PULL ); MicoGpioOutputLow( (mico_gpio_t)MICO_SYS_LED ); MicoGpioInitialize( (mico_gpio_t)MICO_RF_LED, OUTPUT_OPEN_DRAIN_NO_PULL ); MicoGpioOutputHigh( (mico_gpio_t)MICO_RF_LED ); MicoGpioInitialize((mico_gpio_t)BOOT_SEL, INPUT_PULL_UP); MicoGpioInitialize((mico_gpio_t)MFG_SEL, INPUT_PULL_UP); #ifdef USE_MiCOKit_EXT dc_motor_init( ); dc_motor_set( 0 ); rgb_led_init(); rgb_led_open(0, 0, 0); #endif /* Specific operations used in EMW3165 production */ #define NEED_RF_DRIVER_COPY_BASE ((uint32_t)0x08008000) #define TEMP_RF_DRIVER_BASE ((uint32_t)0x08040000) #define TEMP_RF_DRIVER_END ((uint32_t)0x0807FFFF) const uint8_t isDriverNeedCopy = *(uint8_t *)(NEED_RF_DRIVER_COPY_BASE); const uint32_t totalLength = rf_partition->partition_length; const uint8_t crcResult = *(uint8_t *)(TEMP_RF_DRIVER_END); uint8_t targetCrcResult = 0; uint32_t copyLength; uint32_t destStartAddress_tmp = rf_partition->partition_start_addr; uint32_t sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; uint32_t i; if ( isDriverNeedCopy != 0x0 ) return; platform_log( "Bootloader start to copy RF driver..." ); /* Copy RF driver to SPI flash */ err = platform_flash_init( &platform_flash_peripherals[ MICO_FLASH_SPI ] ); require_noerr(err, exit); err = platform_flash_init( &platform_flash_peripherals[ MICO_FLASH_EMBEDDED ] ); require_noerr(err, exit); err = platform_flash_erase( &platform_flash_peripherals[ MICO_FLASH_SPI ], rf_partition->partition_start_addr, rf_partition->partition_start_addr + rf_partition->partition_length - 1 ); require_noerr(err, exit); platform_log( "Time: %d", mico_get_time_no_os() ); for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = platform_flash_read( &platform_flash_peripherals[ MICO_FLASH_EMBEDDED ], &sourceStartAddress_tmp, data , copyLength ); require_noerr( err, exit ); err = platform_flash_write( &platform_flash_peripherals[ MICO_FLASH_SPI ], &destStartAddress_tmp, data, copyLength ); require_noerr(err, exit); } printf("\r\n"); /* Check CRC-8 check-sum */ platform_log( "Bootloader start to verify RF driver..." ); sourceStartAddress_tmp = TEMP_RF_DRIVER_BASE; destStartAddress_tmp = rf_partition->partition_start_addr; CRC8_Init( &crc ); for(i = 0; i <= totalLength/SizePerRW; i++){ if( i == totalLength/SizePerRW ){ if(totalLength%SizePerRW) copyLength = totalLength%SizePerRW; else break; }else{ copyLength = SizePerRW; } printf("."); err = platform_flash_read( &platform_flash_peripherals[ MICO_FLASH_SPI ], &destStartAddress_tmp, data, copyLength ); require_noerr( err, exit ); CRC8_Update( &crc, data, copyLength); } CRC8_Final( &crc, &targetCrcResult ); printf("\r\n"); //require_string( crcResult == targetCrcResult, exit, "Check-sum error" ); if( crcResult != targetCrcResult ){ platform_log("Check-sum error"); while(1); } /* Clear RF driver from temperary storage */ platform_log("Bootloader start to clear RF driver temporary storage..."); /* Clear copy tag */ err = platform_flash_erase( &platform_flash_peripherals[ MICO_FLASH_EMBEDDED ], NEED_RF_DRIVER_COPY_BASE, NEED_RF_DRIVER_COPY_BASE); require_noerr(err, exit); exit: return; }