Contiki 2.6
|
00001 /** @file hal/micro/cortexm3/compiler/gnu.h 00002 * See @ref gnu for detailed documentation. 00003 * 00004 */ 00005 00006 /** @addtogroup gnu 00007 * @brief Compiler and Platform specific definitions and typedefs for the 00008 * GNU C ARM compiler. 00009 * 00010 * @note gnu.h should be included first in all source files by setting the 00011 * preprocessor macro PLATFORM_HEADER to point to it. gnu.h automatically 00012 * includes platform-common.h. 00013 * 00014 * See gnu.h and platform-common.h for source code. 00015 *@{ 00016 */ 00017 00018 #ifndef __GNU_H__ 00019 #define __GNU_H__ 00020 00021 #ifndef __GNUC__ 00022 #error Improper PLATFORM_HEADER 00023 #endif 00024 00025 #if (__GNUC__ < 4) 00026 #error Only GNU C versions later than 4.3.2 are supported 00027 #elif (__GNUC__ == 4) 00028 #if (__GNUC_MINOR__ < 3) 00029 #error Only GNU C versions later than 4.3.2 are supported 00030 #elif (__GNUC_MINOR__ == 3) 00031 #if (__GNUC_PATCHLEVEL__ < 2) 00032 #error Only GNU C versions later than 4.3.2 are supported 00033 #endif 00034 #endif 00035 #endif // __GNUC__ 00036 00037 00038 #ifndef DOXYGEN_SHOULD_SKIP_THIS 00039 //#include <intrinsics.h> 00040 #include <stdarg.h> 00041 #if defined (CORTEXM3_STM32W108) 00042 #include "micro/cortexm3/stm32w108/regs.h" 00043 #include "micro/cortexm3/stm32w108/stm32w108_type.h" 00044 #else 00045 #error Unknown CORTEXM3 micro 00046 #endif 00047 //Provide a default NVIC configuration file. The build process can 00048 //override this if it needs to. 00049 #ifndef NVIC_CONFIG 00050 #define NVIC_CONFIG "hal/micro/cortexm3/nvic-config.h" 00051 #endif 00052 //[[ 00053 #ifdef EMU_TEST 00054 #ifdef I_AM_AN_EMULATOR 00055 // This register is defined for both the chip and the emulator with 00056 // with distinct reset values. Need to undefine to avoid preprocessor 00057 // collision. 00058 #undef DATA_EMU_REGS_BASE 00059 #undef DATA_EMU_REGS_END 00060 #undef DATA_EMU_REGS_SIZE 00061 #undef I_AM_AN_EMULATOR 00062 #undef I_AM_AN_EMULATOR_REG 00063 #undef I_AM_AN_EMULATOR_ADDR 00064 #undef I_AM_AN_EMULATOR_RESET 00065 #undef I_AM_AN_EMULATOR_I_AM_AN_EMULATOR 00066 #undef I_AM_AN_EMULATOR_I_AM_AN_EMULATOR_MASK 00067 #undef I_AM_AN_EMULATOR_I_AM_AN_EMULATOR_BIT 00068 #undef I_AM_AN_EMULATOR_I_AM_AN_EMULATOR_BITS 00069 #endif//I_AM_AN_EMULATOR 00070 #error MICRO currently not supported for emulator builds. 00071 #endif//EMU_TEST 00072 //]] 00073 00074 // suppress warnings about unknown pragmas 00075 // (as they may be pragmas known to other platforms) 00076 //#pragma diag_suppress = pe161 00077 00078 #endif // DOXYGEN_SHOULD_SKIP_THIS 00079 00080 // Define that the minimal hal is being used. 00081 #define MINIMAL_HAL 00082 00083 00084 /** \name Master Variable Types 00085 * These are a set of typedefs to make the size of all variable declarations 00086 * explicitly known. 00087 */ 00088 //@{ 00089 /** 00090 * @brief A typedef to make the size of the variable explicitly known. 00091 */ 00092 typedef unsigned char boolean; 00093 typedef unsigned char int8u; 00094 typedef signed char int8s; 00095 typedef unsigned short int16u; 00096 typedef signed short int16s; 00097 typedef unsigned int int32u; 00098 typedef signed int int32s; 00099 typedef unsigned int PointerType; 00100 //@} \\END MASTER VARIABLE TYPES 00101 00102 /** 00103 * @brief Use the Master Program Memory Declarations from platform-common.h 00104 */ 00105 #define _HAL_USE_COMMON_PGM_ 00106 00107 00108 00109 //////////////////////////////////////////////////////////////////////////////// 00110 /** \name Miscellaneous Macros 00111 */ 00112 //////////////////////////////////////////////////////////////////////////////// 00113 //@{ 00114 00115 /** 00116 * @brief A convenient method for code to know what endiannes processor 00117 * it is running on. For the Cortex-M3, we are little endian. 00118 */ 00119 #define BIGENDIAN_CPU FALSE 00120 00121 00122 /** 00123 * @brief A friendlier name for the compiler's intrinsic for not 00124 * stripping. 00125 */ 00126 #define NO_STRIPPING /* __root ??? */ 00127 #define __no_init /*__attribute__((section (".noinit")))*/ 00128 00129 /** 00130 * @brief A friendlier name for the compiler's intrinsic for eeprom 00131 * reference. 00132 */ 00133 #define EEPROM errorerror 00134 00135 00136 #ifndef __SOURCEFILE__ 00137 /** 00138 * @brief The __SOURCEFILE__ macro is used by asserts to list the 00139 * filename if it isn't otherwise defined, set it to the compiler intrinsic 00140 * which specifies the whole filename and path of the sourcefile 00141 */ 00142 #define __SOURCEFILE__ __FILE__ 00143 #endif 00144 00145 00146 //#include <assert.h> 00147 #undef assert 00148 #define assert(condition) do { if (! (condition)) {while (1); }} while(0) 00149 #if 0 00150 do { if (! (condition)) { \ 00151 printf ("Assert failed %s %d\r\n",__SOURCEFILE__, __LINE__); }} while(0) 00152 #endif 00153 00154 #ifndef BOOTLOADER 00155 #undef __delay_cycles 00156 /** 00157 * @brief __delay_cycles() is an intrinsic IAR call; however, we 00158 * have explicity disallowed it since it is too specific to the system clock. 00159 * \note Please use halCommonDelayMicroseconds() instead, because it correctly 00160 * accounts for various system clock speeds. 00161 */ 00162 #define __delay_cycles(x) please_use_halCommonDelayMicroseconds_instead_of_delay_cycles 00163 #endif 00164 00165 /** 00166 * @brief Set debug level based on whether or DEBUG is defined. 00167 * basic debugging support is included if DEBUG is not defined. 00168 */ 00169 #ifndef DEBUG_LEVEL 00170 #ifdef DEBUG 00171 #define DEBUG_LEVEL FULL_DEBUG 00172 #else 00173 #define DEBUG_LEVEL BASIC_DEBUG 00174 #endif 00175 #endif 00176 00177 /** 00178 * @brief Set the application start and end address. 00179 * This are useful to detect whether an image is for bootloader mode or not. 00180 * This can be used also to clone image to another node via bootloader. 00181 */ 00182 #define APPLICATION_IMAGE_START ((u32) &__ApplicationFlashStart) 00183 #define APPLICATION_IMAGE_END ((u32) &__ApplicationFlashEnd) 00184 extern char __ApplicationFlashStart; 00185 extern char __ApplicationFlashEnd; 00186 00187 /** 00188 * @brief Macro to reset the watchdog timer. Note: be very very 00189 * careful when using this as you can easily get into an infinite loop if you 00190 * are not careful. 00191 */ 00192 void halInternalResetWatchDog(void); 00193 #define halResetWatchdog() halInternalResetWatchDog() 00194 00195 00196 /** 00197 * @brief Define __attribute__ to nothing since it isn't handled by IAR. 00198 */ 00199 00200 00201 /** 00202 * @brief Declare a variable as unused to avoid a warning. Has no effect 00203 * in IAR builds 00204 */ 00205 #define UNUSED 00206 00207 /** 00208 * @brief Some platforms need to cast enum values that have the high bit set. 00209 */ 00210 #define SIGNED_ENUM 00211 00212 00213 /** 00214 * @brief Define the magic value that is interpreted by IAR C-SPY's Stack View. 00215 */ 00216 #define STACK_FILL_VALUE 0xCDCDCDCD 00217 00218 /** 00219 * @brief Define a generic RAM function identifier to a compiler specific one. 00220 */ 00221 #ifdef RAMEXE 00222 //If the whole build is running out of RAM, as chosen by the RAMEXE build 00223 //define, then define RAMFUNC to nothing since it's not needed. 00224 #define RAMFUNC 00225 #else //RAMEXE 00226 #define RAMFUNC __ramfunc 00227 #endif //RAMEXE 00228 00229 /** 00230 * @brief Define a generic no operation identifier to a compiler specific one. 00231 */ 00232 #define NO_OPERATION() __no_operation() 00233 00234 /** 00235 * @brief A convenience macro that makes it easy to change the field of a 00236 * register to any value. 00237 */ 00238 #define SET_REG_FIELD(reg, field, value) \ 00239 do{ \ 00240 reg = ((reg & (~field##_MASK)) | (value << field##_BIT)); \ 00241 }while(0) 00242 00243 /** 00244 * @brief Stub for code not running in simulation. 00245 */ 00246 #define simulatedTimePasses() 00247 /** 00248 * @brief Stub for code not running in simulation. 00249 */ 00250 #define simulatedTimePassesMs(x) 00251 /** 00252 * @brief Stub for code not running in simulation. 00253 */ 00254 #define simulatedSerialTimePasses() 00255 00256 00257 /** 00258 * @brief Use the Divide and Modulus Operations from platform-common.h 00259 */ 00260 #define _HAL_USE_COMMON_DIVMOD_ 00261 00262 00263 /** 00264 * @brief Provide a portable way to specify the segment where a variable 00265 * lives. 00266 */ 00267 #define VAR_AT_SEGMENT(__variableDeclaration, __segmentName) \ 00268 __variableDeclaration __attribute__ ((section (__segmentName))) 00269 00270 #define ALIGN_VAR(__variableDeclaration, alignment) \ 00271 __variableDeclaration __attribute__ ((aligned(alignment))) 00272 00273 //////////////////////////////////////////////////////////////////////////////// 00274 //@} // end of Miscellaneous Macros 00275 //////////////////////////////////////////////////////////////////////////////// 00276 00277 /** @name Portable segment names 00278 *@{ 00279 */ 00280 /** 00281 * @brief Portable segment names 00282 */ 00283 #define __NO_INIT__ ".noinit" 00284 #define __INTVEC__ ".intvec" 00285 #define __CSTACK__ "CSTACK" 00286 #define __DATA_INIT__ ".data_init" 00287 #define __DATA__ ".data" 00288 #define __BSS__ ".bss" 00289 #define __CONST__ ".rodata" 00290 #define __TEXT__ ".text" 00291 #define __TEXTRW_INIT__ ".textrw_init" 00292 #define __TEXTRW__ ".textrw" 00293 #define __FAT__ "FAT" // Fixed address table 00294 #define __NVM__ "NVM" //Non-Volatile Memory data storage 00295 00296 //============================================================================= 00297 // The '#pragma segment=' declaration must be used before attempting to access 00298 // the segments so the compiler properly handles the __segment_*() functions. 00299 // 00300 // The segment names used here are the default segment names used by IAR. Refer 00301 // to the IAR Compiler Reference Guide for a proper description of these 00302 // segments. 00303 //============================================================================= 00304 #if 0 00305 #pragma segment=__NO_INIT__ 00306 #pragma segment=__INTVEC__ 00307 #pragma segment=__CSTACK__ 00308 #pragma segment=__DATA_INIT__ 00309 #pragma segment=__DATA__ 00310 #pragma segment=__BSS__ 00311 #pragma segment=__CONST__ 00312 #pragma segment=__TEXT__ 00313 #pragma segment=__TEXTRW_INIT__ 00314 #pragma segment=__TEXTRW__ 00315 #pragma segment=__FAT__ 00316 #pragma segment=__NVM__ 00317 #endif 00318 /**@} */ 00319 00320 //A utility function for inserting barrier instructions. These 00321 //instructions should be used whenever the MPU is enabled or disabled so 00322 //that all memory/instruction accesses can complete before the MPU changes 00323 //state. 00324 void _executeBarrierInstructions(void); 00325 00326 //////////////////////////////////////////////////////////////////////////////// 00327 /** \name Global Interrupt Manipulation Macros 00328 * 00329 * \b Note: The special purpose BASEPRI register is used to enable and disable 00330 * interrupts while permitting faults. 00331 * When BASEPRI is set to 1 no interrupts can trigger. The configurable faults 00332 * (usage, memory management, and bus faults) can trigger if enabled as well as 00333 * the always-enabled exceptions (reset, NMI and hard fault). 00334 * When BASEPRI is set to 0, it is disabled, so any interrupt can triggger if 00335 * its priority is higher than the current priority. 00336 */ 00337 //////////////////////////////////////////////////////////////////////////////// 00338 //@{ 00339 00340 #define ATOMIC_LITE(blah) ATOMIC(blah) 00341 #define DECLARE_INTERRUPT_STATE_LITE DECLARE_INTERRUPT_STATE 00342 #define DISABLE_INTERRUPTS_LITE() DISABLE_INTERRUPTS() 00343 #define RESTORE_INTERRUPTS_LITE() RESTORE_INTERRUPTS() 00344 00345 #ifdef BOOTLOADER 00346 #ifndef DOXYGEN_SHOULD_SKIP_THIS 00347 // The bootloader does not use interrupts 00348 #define DECLARE_INTERRUPT_STATE 00349 #define DISABLE_INTERRUPTS() do { } while(0) 00350 #define RESTORE_INTERRUPTS() do { } while(0) 00351 #define INTERRUPTS_ON() do { } while(0) 00352 #define INTERRUPTS_OFF() do { } while(0) 00353 #define INTERRUPTS_ARE_OFF() (FALSE) 00354 #define ATOMIC(blah) { blah } 00355 #define HANDLE_PENDING_INTERRUPTS() do { } while(0) 00356 #define SET_BASE_PRIORITY_LEVEL(basepri) do { } while(0) 00357 #endif // DOXYGEN_SHOULD_SKIP_THIS 00358 #else // BOOTLOADER 00359 00360 #ifndef DOXYGEN_SHOULD_SKIP_THIS 00361 /** 00362 * @brief This macro should be called in the local variable 00363 * declarations section of any function which calls DISABLE_INTERRUPTS() 00364 * or RESTORE_INTERRUPTS(). 00365 */ 00366 #define DECLARE_INTERRUPT_STATE int8u _emIsrState 00367 00368 // Prototypes for the BASEPRI and PRIMASK access functions. They are very 00369 // basic and instantiated in assembly code in the file spmr.s37 (since 00370 // there are no C functions that cause the compiler to emit code to access 00371 // the BASEPRI/PRIMASK). This will inhibit the core from taking interrupts 00372 // with a priority equal to or less than the BASEPRI value. 00373 // Note that the priority values used by these functions are 5 bits and 00374 // right-aligned 00375 extern int8u _readBasePri(void); 00376 extern void _writeBasePri(int8u priority); 00377 00378 // Prototypes for BASEPRI functions used to disable and enable interrupts 00379 // while still allowing enabled faults to trigger. 00380 extern void _enableBasePri(void); 00381 extern int8u _disableBasePri(void); 00382 extern boolean _basePriIsDisabled(void); 00383 00384 // Prototypes for setting and clearing PRIMASK for global interrupt 00385 // enable/disable. 00386 extern void _setPriMask(void); 00387 extern void _clearPriMask(void); 00388 #endif // DOXYGEN_SHOULD_SKIP_THIS 00389 00390 //The core Global Interrupt Manipulation Macros start here. 00391 00392 /** 00393 * @brief Disable interrupts, saving the previous state so it can be 00394 * later restored with RESTORE_INTERRUPTS(). 00395 * \note Do not fail to call RESTORE_INTERRUPTS(). 00396 * \note It is safe to nest this call. 00397 */ 00398 #define DISABLE_INTERRUPTS() \ 00399 do { \ 00400 _emIsrState = _disableBasePri(); \ 00401 } while(0) 00402 00403 00404 /** 00405 * @brief Restore the global interrupt state previously saved by 00406 * DISABLE_INTERRUPTS() 00407 * \note Do not call without having first called DISABLE_INTERRUPTS() 00408 * to have saved the state. 00409 * \note It is safe to nest this call. 00410 */ 00411 #define RESTORE_INTERRUPTS() \ 00412 do { \ 00413 _writeBasePri(_emIsrState); \ 00414 } while(0) 00415 00416 00417 /** 00418 * @brief Enable global interrupts without regard to the current or 00419 * previous state. 00420 */ 00421 #define INTERRUPTS_ON() \ 00422 do { \ 00423 _enableBasePri(); \ 00424 } while(0) 00425 00426 00427 /** 00428 * @brief Disable global interrupts without regard to the current or 00429 * previous state. 00430 */ 00431 #define INTERRUPTS_OFF() \ 00432 do { \ 00433 (void)_disableBasePri(); \ 00434 } while(0) 00435 00436 00437 /** 00438 * @returns TRUE if global interrupts are disabled. 00439 */ 00440 #define INTERRUPTS_ARE_OFF() ( _basePriIsDisabled() ) 00441 00442 /** 00443 * @returns TRUE if global interrupt flag was enabled when 00444 * ::DISABLE_INTERRUPTS() was called. 00445 */ 00446 #define INTERRUPTS_WERE_ON() (_emIsrState == 0) 00447 00448 /** 00449 * @brief A block of code may be made atomic by wrapping it with this 00450 * macro. Something which is atomic cannot be interrupted by interrupts. 00451 */ 00452 #define ATOMIC(blah) \ 00453 { \ 00454 DECLARE_INTERRUPT_STATE; \ 00455 DISABLE_INTERRUPTS(); \ 00456 { blah } \ 00457 RESTORE_INTERRUPTS(); \ 00458 } 00459 00460 00461 /** 00462 * @brief Allows any pending interrupts to be executed. Usually this 00463 * would be called at a safe point while interrupts are disabled (such as 00464 * within an ISR). 00465 * 00466 * Takes no action if interrupts are already enabled. 00467 */ 00468 #define HANDLE_PENDING_INTERRUPTS() \ 00469 do { \ 00470 if (INTERRUPTS_ARE_OFF()) { \ 00471 INTERRUPTS_ON(); \ 00472 INTERRUPTS_OFF(); \ 00473 } \ 00474 } while (0) 00475 00476 00477 /** 00478 * @brief Sets the base priority mask (BASEPRI) to the value passed, 00479 * bit shifted up by PRIGROUP_POSITION+1. This will inhibit the core from 00480 * taking all interrupts with a preemptive priority equal to or less than 00481 * the BASEPRI mask. This macro is dependent on the value of 00482 * PRIGROUP_POSITION in nvic-config.h. Note that the value 0 disables the 00483 * the base priority mask. 00484 * 00485 * Refer to the "PRIGROUP" table in nvic-config.h to know the valid values 00486 * for this macro depending on the value of PRIGROUP_POSITION. With respect 00487 * to the table, this macro can only take the preemptive priority group 00488 * numbers denoted by the parenthesis. 00489 */ 00490 #define SET_BASE_PRIORITY_LEVEL(basepri) \ 00491 do { \ 00492 _writeBasePri(basepri); \ 00493 } while(0) 00494 00495 #endif // BOOTLOADER 00496 //////////////////////////////////////////////////////////////////////////////// 00497 //@} // end of Global Interrupt Manipulation Macros 00498 //////////////////////////////////////////////////////////////////////////////// 00499 00500 /** 00501 * @brief Use the C Standard Library Memory Utilities from platform-common.h 00502 */ 00503 #define _HAL_USE_COMMON_MEMUTILS_ 00504 00505 //////////////////////////////////////////////////////////////////////////////// 00506 /** \name External Declarations 00507 * These are routines that are defined in certain header files that we don't 00508 * want to include, e.g. stdlib.h 00509 */ 00510 //////////////////////////////////////////////////////////////////////////////// 00511 //@{ 00512 00513 /** 00514 * @brief Returns the absolute value of I (also called the magnitude of I). 00515 * That is, if I is negative, the result is the opposite of I, but if I is 00516 * nonnegative the result is I. 00517 * 00518 * @param I An integer. 00519 * 00520 * @return A nonnegative integer. 00521 */ 00522 int abs(int I); 00523 00524 //////////////////////////////////////////////////////////////////////////////// 00525 //@} // end of External Declarations 00526 //////////////////////////////////////////////////////////////////////////////// 00527 00528 00529 /** 00530 * @brief Include platform-common.h last to pick up defaults and common definitions. 00531 */ 00532 #define PLATCOMMONOKTOINCLUDE 00533 #include "hal/micro/generic/compiler/platform-common.h" 00534 #undef PLATCOMMONOKTOINCLUDE 00535 00536 #endif // __GNU_H__ 00537 00538 /** @} END addtogroup */ 00539