RTC auf true
Diff: rtos/TARGET_CORTEX/TOOLCHAIN_IAR/mbed_boot_iar.c
- Revision:
- 0:38ceb79fef03
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rtos/TARGET_CORTEX/TOOLCHAIN_IAR/mbed_boot_iar.c Wed Nov 28 15:10:15 2018 +0000 @@ -0,0 +1,173 @@ +/* mbed Microcontroller Library + * Copyright (c) 2018-2018 ARM Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "cmsis.h" +#include "mbed_error.h" +#include "mbed_boot.h" +#if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ >= 8000000) +#include <DLib_Threads.h> +#endif +#include "mbed_rtos_storage.h" +#include "cmsis_os2.h" + +/* Defined by linker script */ +#pragma section="CSTACK" +#pragma section="HEAP" + +extern void* __vector_table; +extern int __low_level_init(void); +extern void __iar_data_init3(void); +extern __weak void __iar_init_core(void); +extern __weak void __iar_init_vfp(void); +extern void __iar_dynamic_initialization(void); + +/* + * mbed entry point for the IAR toolchain + * + * Override __iar_program_start to run code before main. + * This is the first function called after the low level + * target initialization, so RAM has not been setup yet. + * + * Details on what this function are supposed to do can + * be found by looking at the IAR source for this file. + * + * IAR source files for ARM instruction set: + * <IAR>\arm\src\lib\arm\cstartup.s + * <IAR>\arm\src\lib\arm\cmain.s + * + * IAR source files for THUMB instruction set: + * <IAR>\arm\src\lib\thumb\cmain.s + * <IAR>\arm\src\lib\thumb\cstartup_M.s + */ +#pragma required=__vector_table +void __iar_program_start( void ) +{ + /* the calls below are normally made in IAR cstartup */ + __iar_init_core(); + __iar_init_vfp(); + + /* the calls below are normally made in IAR cmain + * + * The function "__low_level_init" is a user overrideable hook + * that does nothing by default. Returning zero means that + * ram initialization should be skipped. Skipping ram initialization + * is not allowed by mbed. + * + * The function "__iar_data_init3" is an IAR function which + * initializes ram. + * + */ + __low_level_init(); + __iar_data_init3(); + + /* mbed specific code */ + mbed_heap_start = (unsigned char*)__section_begin("HEAP"); + mbed_heap_size = (uint32_t)__section_size("HEAP"); + + mbed_stack_isr_start = (unsigned char*)__section_begin("CSTACK"); + mbed_stack_isr_size = (uint32_t)__section_size("CSTACK"); + + mbed_init(); + mbed_rtos_start(); +} + +void mbed_toolchain_init(void) +{ +#if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ >= 8000000) + __iar_Initlocks(); +#endif + + /* Run the C++ global object constructors */ + __iar_dynamic_initialization(); +} + +/* Thread safety */ +static osMutexId_t std_mutex_id_sys[_MAX_LOCK] = {0}; +static mbed_rtos_storage_mutex_t std_mutex_sys[_MAX_LOCK] = {0}; +#define _FOPEN_MAX 10 +static osMutexId_t std_mutex_id_file[_FOPEN_MAX] = {0}; +static mbed_rtos_storage_mutex_t std_mutex_file[_FOPEN_MAX] = {0}; + +void __iar_system_Mtxinit(__iar_Rmtx *mutex) /* Initialize a system lock */ +{ + osMutexAttr_t attr; + uint32_t index; + for (index = 0; index < _MAX_LOCK; index++) { + if (0 == std_mutex_id_sys[index]) { + attr.name = "system_mutex"; + attr.cb_mem = &std_mutex_sys[index]; + attr.cb_size = sizeof(std_mutex_sys[index]); + attr.attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust; + std_mutex_id_sys[index] = osMutexNew(&attr); + *mutex = (__iar_Rmtx*)&std_mutex_id_sys[index]; + return; + } + } + + /* This should never happen */ + error("Not enough mutexes\n"); +} + +void __iar_system_Mtxdst(__iar_Rmtx *mutex) /* Destroy a system lock */ +{ + osMutexDelete(*(osMutexId_t*)*mutex); + *mutex = 0; +} + +void __iar_system_Mtxlock(__iar_Rmtx *mutex) /* Lock a system lock */ +{ + osMutexAcquire(*(osMutexId_t*)*mutex, osWaitForever); +} + +void __iar_system_Mtxunlock(__iar_Rmtx *mutex) /* Unlock a system lock */ +{ + osMutexRelease(*(osMutexId_t*)*mutex); +} + +void __iar_file_Mtxinit(__iar_Rmtx *mutex) /* Initialize a file lock */ +{ + osMutexAttr_t attr; + uint32_t index; + for (index = 0; index < _FOPEN_MAX; index++) { + if (0 == std_mutex_id_file[index]) { + attr.name = "file_mutex"; + attr.cb_mem = &std_mutex_file[index]; + attr.cb_size = sizeof(std_mutex_file[index]); + attr.attr_bits = osMutexRecursive | osMutexPrioInherit | osMutexRobust; + std_mutex_id_file[index] = osMutexNew(&attr); + *mutex = (__iar_Rmtx*)&std_mutex_id_file[index]; + return; + } + } + /* The variable _FOPEN_MAX needs to be increased */ + error("Not enough mutexes\n"); +} + +void __iar_file_Mtxdst(__iar_Rmtx *mutex) /* Destroy a file lock */ +{ + osMutexDelete(*(osMutexId_t*)*mutex); + *mutex = 0; +} + +void __iar_file_Mtxlock(__iar_Rmtx *mutex) /* Lock a file lock */ +{ + osMutexAcquire(*(osMutexId_t*)*mutex, osWaitForever); +} + +void __iar_file_Mtxunlock(__iar_Rmtx *mutex) /* Unlock a file lock */ +{ + osMutexRelease(*(osMutexId_t*)*mutex); +}