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;
}
