BSP

CC2538移植到RT-Thread-nano启动文件

发布于 2020-05-20 19:54:32    浏览:290
//*****************************************************************************
//! @file startup_iar.c
//! @brief Startup code for CC2538 for use with IAR EWARM.
//!
//! Revised $Date: 2013-04-29 14:48:18 +0200 (Mon, 29 Apr 2013) $
//! Revision $Revision: 9929 $
//
// Copyright (C) 2013 Texas Instruments Incorporated -
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// Neither the name of Texas Instruments Incorporated nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//****************************************************************************/

#include

#define FLASH_START_ADDR 0x00200000
#define BOOTLOADER_BACKDOOR_DISABLE 0xEFFFFFFF
#define SYS_CTRL_EMUOVR 0x400D20B4
#define SYS_CTRL_I_MAP 0x400D2098


//*****************************************************************************
//
// Check if compiler is IAR
//
//*****************************************************************************
#if !(defined(__IAR_SYSTEMS_ICC__))
#error "startup_iar.c: Unsupported compiler!"
#endif


//*****************************************************************************
//
// Macro for hardware access, both direct and via the bit-band region.
//
//*****************************************************************************
#ifndef HWREG
#define HWREG(x) \
(*((volatile uint32_t *)(x)))
#endif


//*****************************************************************************
//
// IAR: Enable the IAR extensions for this source file.
//
//*****************************************************************************
#pragma language=extended


//*****************************************************************************
//
// IAR: The entry point for the application startup code.
//
//*****************************************************************************
extern void __iar_program_start(void);


//*****************************************************************************
//
// IAR: Get stack start (highest address) symbol from linker file.
//
//*****************************************************************************
extern const void* STACK_TOP;

// It is required to place something in the CSTACK segment to get the stack
// check feature in IAR to work as expected
__root static void* dummy_stack @ ".stack";

//*****************************************************************************
//
// Forward declaration of the default fault handlers.
//
//*****************************************************************************
static void ResetISR(void);
static void NmiISR(void);
//static void FaultISR(void);
void HardFault_Handler(void);
//static void PendSV_Handler(void);
void PendSV_Handler(void);
// Handlers that can potentially be registered directly by application
extern void PendSV_Handler(void);
extern void SysTickIntHandler(void);
extern void GPIOAIntHandler(void);
extern void GPIOBIntHandler(void);
extern void GPIOCIntHandler(void);
extern void GPIODIntHandler(void);
extern void UART0IntHandler(void);
extern void UART1IntHandler(void);
extern void SSI0IntHandler(void);
extern void SSI1IntHandler(void);
extern void I2CIntHandler(void);
extern void ADCIntHandler(void);
extern void WatchdogIntHandler(void);
extern void Timer0AIntHandler(void);
extern void Timer0BIntHandler(void);
extern void Timer1AIntHandler(void);
extern void Timer1BIntHandler(void);
extern void Timer2AIntHandler(void);
extern void Timer2BIntHandler(void);
extern void Timer3AIntHandler(void);
extern void Timer3BIntHandler(void);
extern void CompIntHandler(void);
extern void RFCoreTxIntHandler(void);
extern void RFCoreErrIntHandler(void);
extern void IcePickIntHandler(void);
extern void FlashIntHandler(void);
extern void AESIntHandler(void);
extern void PKAIntHandler(void);
extern void SleepModeIntHandler(void);
extern void MacTimerIntHandler(void);
extern void USBIntHandler(void);
extern void uDMAIntHandler(void);
extern void uDMAErrIntHandler(void);

// Default interrupt handlers, these can be overwritten if defined elsewhere
#pragma weak PendSVHandler = PendSV_Handler
#pragma weak SysTickIntHandler = PendSV_Handler
#pragma weak GPIOAIntHandler = PendSV_Handler
#pragma weak GPIOBIntHandler = PendSV_Handler
#pragma weak GPIOCIntHandler = PendSV_Handler
#pragma weak GPIODIntHandler = PendSV_Handler
#pragma weak UART0IntHandler = PendSV_Handler
#pragma weak UART1IntHandler = PendSV_Handler
#pragma weak SSI0IntHandler = PendSV_Handler
#pragma weak SSI1IntHandler = PendSV_Handler
#pragma weak I2CIntHandler = PendSV_Handler
#pragma weak ADCIntHandler = PendSV_Handler
#pragma weak WatchdogIntHandler = PendSV_Handler
#pragma weak Timer0AIntHandler = PendSV_Handler
#pragma weak Timer0BIntHandler = PendSV_Handler
#pragma weak Timer1AIntHandler = PendSV_Handler
#pragma weak Timer1BIntHandler = PendSV_Handler
#pragma weak Timer2AIntHandler = PendSV_Handler
#pragma weak Timer2BIntHandler = PendSV_Handler
#pragma weak Timer3AIntHandler = PendSV_Handler
#pragma weak Timer3BIntHandler = PendSV_Handler
#pragma weak CompIntHandler = PendSV_Handler
#pragma weak RFCoreTxIntHandler = PendSV_Handler
#pragma weak RFCoreErrIntHandler = PendSV_Handler
#pragma weak IcePickIntHandler = PendSV_Handler
#pragma weak FlashIntHandler = PendSV_Handler
#pragma weak AESIntHandler = PendSV_Handler
#pragma weak PKAIntHandler = PendSV_Handler
#pragma weak SleepModeIntHandler = PendSV_Handler
#pragma weak MacTimerIntHandler = PendSV_Handler
#pragma weak USBIntHandler = PendSV_Handler
#pragma weak uDMAIntHandler = PendSV_Handler
#pragma weak uDMAErrIntHandler = PendSV_Handler


//*****************************************************************************
//
// Customer Configuration Area in Lock Page
// Holds Image Vector table address (bytes 2013 - 2015) and
// Image Valid bytes (bytes 2008 -2011)
//
//*****************************************************************************
typedef struct
{
uint32_t ui32BootldrCfg;
uint32_t ui32ImageValid;
uint32_t ui32ImageVectorAddr;
}
lockPageCCA_t;

__root const lockPageCCA_t __cca @ ".flashcca" =
{
BOOTLOADER_BACKDOOR_DISABLE, // Bootloader backdoor disabled
0, // Image valid bytes
FLASH_START_ADDR // Vector table located at flash start address
};


//*****************************************************************************
//
// The vector table. Note that the proper constructs must be placed on this to
// ensure that it ends up at physical address 0x200000 (start of the flash).
//
//*****************************************************************************
__root void (* const __vector_table[])(void) @ ".intvec" =
{
(void (*)(void))&STACK_TOP, // 0 The initial stack pointer
ResetISR, // 1 The reset handler
NmiISR, // The NMI handler
//FaultISR, // The hard fault handler
HardFault_Handler,
PendSV_Handler, // 4 The MPU fault handler
PendSV_Handler, // 5 The bus fault handler
PendSV_Handler, // 6 The usage fault handler
0, // 7 Reserved
0, // 8 Reserved
0, // 9 Reserved
0, // 10 Reserved
PendSV_Handler, // 11 SVCall handler
PendSV_Handler, // 12 Debug monitor handler
0, // 13 Reserved
PendSV_Handler, // 14 The PendSV handler
SysTickIntHandler, // 15 The SysTick handler
GPIOAIntHandler, // 16 GPIO Port A
GPIOBIntHandler, // 17 GPIO Port B
GPIOCIntHandler, // 18 GPIO Port C
GPIODIntHandler, // 19 GPIO Port D
0, // 20 none
UART0IntHandler, // 21 UART0 Rx and Tx
UART1IntHandler, // 22 UART1 Rx and Tx
SSI0IntHandler, // 23 SSI0 Rx and Tx
I2CIntHandler, // 24 I2C Master and Slave
0, // 25 Reserved
0, // 26 Reserved
0, // 27 Reserved
0, // 28 Reserved
0, // 29 Reserved
ADCIntHandler, // 30 ADC Sequence 0
0, // 31 Reserved
0, // 32 Reserved
0, // 33 Reserved
WatchdogIntHandler, // 34 Watchdog timer, timer 0
Timer0AIntHandler, // 35 Timer 0 subtimer A
Timer0BIntHandler, // 36 Timer 0 subtimer B
Timer1AIntHandler, // 37 Timer 1 subtimer A
Timer1BIntHandler, // 38 Timer 1 subtimer B
Timer2AIntHandler, // 39 Timer 2 subtimer A
Timer2BIntHandler, // 40 Timer 2 subtimer B
CompIntHandler, // 41 Analog Comparator 0
RFCoreTxIntHandler, // 42 RFCore Rx/Tx
RFCoreErrIntHandler, // 43 RFCore Error
IcePickIntHandler, // 44 IcePick
FlashIntHandler, // 45 FLASH Control
AESIntHandler, // 46 AES
PKAIntHandler, // 47 PKA
SleepModeIntHandler, // 48 Sleep Timer
MacTimerIntHandler, // 49 MacTimer
SSI1IntHandler, // 50 SSI1 Rx and Tx
Timer3AIntHandler, // 51 Timer 3 subtimer A
Timer3BIntHandler, // 52 Timer 3 subtimer B
0, // 53 Reserved
0, // 54 Reserved
0, // 55 Reserved
0, // 56 Reserved
0, // 57 Reserved
0, // 58 Reserved
0, // 59 Reserved
USBIntHandler, // 60 USB 2538
0, // 61 Reserved
uDMAIntHandler, // 62 uDMA
uDMAErrIntHandler, // 63 uDMA Error
#ifndef CC2538_USE_ALTERNATE_INTERRUPT_MAP
0, // 64 64-155 are not in use
0, // 65
0, // 66
0, // 67
0, // 68
0, // 69
0, // 70
0, // 71
0, // 72
0, // 73
0, // 74
0, // 75
0, // 76
0, // 77
0, // 78
0, // 79
0, // 80
0, // 81
0, // 82
0, // 83
0, // 84
0, // 85
0, // 86
0, // 87
0, // 88
0, // 89
0, // 90
0, // 91
0, // 92
0, // 93
0, // 94
0, // 95
0, // 96
0, // 97
0, // 98
0, // 99
0, // 100
0, // 101
0, // 102
0, // 103
0, // 104
0, // 105
0, // 106
0, // 107
0, // 108
0, // 109
0, // 110
0, // 111
0, // 112
0, // 113
0, // 114
0, // 115
0, // 116
0, // 117
0, // 118
0, // 119
0, // 120
0, // 121
0, // 122
0, // 123
0, // 124
0, // 125
0, // 126
0, // 127
0, // 128
0, // 129
0, // 130
0, // 131
0, // 132
0, // 133
0, // 134
0, // 135
0, // 136
0, // 137
0, // 138
0, // 139
0, // 140
0, // 141
0, // 142
0, // 143
0, // 144
0, // 145
0, // 146
0, // 147
0, // 148
0, // 149
0, // 150
0, // 151
0, // 152
0, // 153
0, // 154
0, // 155
USBIntHandler, // 156 USB
RFCoreTxIntHandler, // 157 RFCORE RX/TX
RFCoreErrIntHandler, // 158 RFCORE Error
AESIntHandler, // 159 AES
PKAIntHandler, // 160 PKA
SleepModeIntHandler, // 161 SMTimer
MacTimerIntHandler, // 162 MACTimer
#endif
};

//*****************************************************************************
//
// This is the code that gets called when the processor is reset.
//
//*****************************************************************************
static void
ResetISR(void)
{
#ifdef DEBUG
//
// Workaround for System Reset debug issue
//
uint32_t ui32Timeout = 2000000;
volatile uint32_t* pui32StopAtResetIsr = (uint32_t*)0x20003000;
while((*pui32StopAtResetIsr == 0xA5F01248) && (ui32Timeout--));
#endif

#ifdef CC2538_USE_ALTERNATE_INTERRUPT_MAP
//
// Enable alternate interrupt mapping
//
HWREG(SYS_CTRL_I_MAP) |= 1;
#endif

//
// Jump to IAR initialization routine
//
__iar_program_start();
//rtthread_startup();
}


//*****************************************************************************
//
// This is the code that gets called when the processor receives a NMI. This
// simply enters an infinite loop, preserving the system state for examination
// by a debugger.
//
//*****************************************************************************
static void
NmiISR(void)
{
//
// Enter an infinite loop.
//
while(1)
{
}
}


//*****************************************************************************
//
// This is the code that gets called when the processor receives a fault
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
//static void
//FaultISR(void)
//{
// //
// // Enter an infinite loop.
// //
// // while(1)
// // {
// // }
//}


//*****************************************************************************
//
// This is the code that gets called when the processor receives an unexpected
// interrupt. This simply enters an infinite loop, preserving the system state
// for examination by a debugger.
//
//*****************************************************************************
static void
PendSV_Handler(void)
{
//
// Enter an infinite loop.
//
//while(1)
//{
//}
}


查看更多

0 个回答
暂无答案,快来添加答案吧

撰写答案

请登录后再发布答案,点击登录
关注者
0
被浏览
290

发布
问题

分享
好友

手机
浏览

扫码手机浏览