1404 lines
39 KiB
Plaintext
1404 lines
39 KiB
Plaintext
#
|
|
# For a description of the syntax of this configuration file,
|
|
# see the file kconfig-language.txt in the NuttX tools repository.
|
|
#
|
|
|
|
choice
|
|
prompt "CPU Architecture"
|
|
default ARCH_ARM
|
|
|
|
config ARCH_ARM
|
|
bool "ARM"
|
|
select ARCH_HAVE_BACKTRACE
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_FORK
|
|
select ARCH_HAVE_STACKCHECK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_STDARG_H
|
|
select ARCH_HAVE_SETJMP if !ARCH_TOOLCHAIN_IAR
|
|
select ARCH_HAVE_SYSCALL_HOOKS
|
|
select ARCH_HAVE_RDWR_MEM_CPU_RUN
|
|
select ARCH_HAVE_TCBINFO
|
|
select ARCH_HAVE_THREAD_LOCAL
|
|
---help---
|
|
The ARM architectures
|
|
|
|
config ARCH_ARM64
|
|
bool "ARM64"
|
|
select ALARM_ARCH
|
|
select ARCH_HAVE_BACKTRACE
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_STACKCHECK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_STDARG_H
|
|
select ARCH_HAVE_SETJMP
|
|
select ARCH_HAVE_SYSCALL_HOOKS
|
|
select ARCH_HAVE_RDWR_MEM_CPU_RUN
|
|
select ARCH_HAVE_TCBINFO
|
|
select ARCH_HAVE_THREAD_LOCAL
|
|
select ARCH_HAVE_PERF_EVENTS
|
|
select ONESHOT
|
|
---help---
|
|
The ARM64 architectures
|
|
|
|
config ARCH_AVR
|
|
bool "AVR"
|
|
select ARCH_NOINTC
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
---help---
|
|
Atmel 8-bit bit AVR and 32-bit AVR32 architectures
|
|
|
|
config ARCH_HC
|
|
bool "Freescale HC"
|
|
select ARCH_NOINTC
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
---help---
|
|
Freescale HC architectures (M9S12)
|
|
|
|
config ARCH_MIPS
|
|
bool "MIPS"
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
---help---
|
|
MIPS architectures (PIC32)
|
|
|
|
config ARCH_MISOC
|
|
bool "MISOC"
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_STDARG_H
|
|
---help---
|
|
MISOC
|
|
|
|
config ARCH_RENESAS
|
|
bool "Renesas"
|
|
select ARCH_NOINTC
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
---help---
|
|
Renesas architectures (SH and M16C).
|
|
|
|
config ARCH_RISCV
|
|
bool "RISC-V"
|
|
select ARCH_HAVE_BACKTRACE
|
|
select ARCH_HAVE_CPUINFO
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_STACKCHECK
|
|
select ARCH_HAVE_FORK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_SETJMP
|
|
select ARCH_HAVE_STDARG_H
|
|
select ARCH_HAVE_SYSCALL_HOOKS
|
|
select ARCH_HAVE_RDWR_MEM_CPU_RUN
|
|
select ARCH_HAVE_TCBINFO
|
|
select ARCH_HAVE_THREAD_LOCAL
|
|
select ARCH_HAVE_LAZYFPU if ARCH_HAVE_FPU
|
|
---help---
|
|
RISC-V 32 and 64-bit RV32 / RV64 architectures.
|
|
|
|
config ARCH_SIM
|
|
bool "Simulation"
|
|
select ARCH_HAVE_BACKTRACE
|
|
select ARCH_HAVE_MULTICPU
|
|
select ARCH_HAVE_RTC_SUBSECONDS
|
|
select ARCH_HAVE_SERIAL_TERMIOS
|
|
select ARCH_HAVE_SYSCALL_HOOKS
|
|
select ARCH_HAVE_TICKLESS
|
|
select ARCH_HAVE_POWEROFF
|
|
select ARCH_HAVE_TESTSET
|
|
select ARCH_HAVE_FORK if !HOST_WINDOWS
|
|
select ARCH_HAVE_SETJMP
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_TCBINFO
|
|
select ARCH_HAVE_TEXT_HEAP
|
|
select ARCH_SETJMP_H
|
|
select ALARM_ARCH
|
|
select ONESHOT
|
|
select SERIAL_CONSOLE
|
|
select SERIAL_IFLOWCONTROL
|
|
select SCHED_HPWORK
|
|
select ARCH_HAVE_CPUINFO
|
|
---help---
|
|
Linux/Cygwin user-mode simulation.
|
|
|
|
config ARCH_X86
|
|
bool "x86"
|
|
select ARCH_HAVE_TCBINFO
|
|
---help---
|
|
Intel x86 architectures.
|
|
|
|
config ARCH_X86_64
|
|
bool "x86_64"
|
|
select ARCH_HAVE_TCBINFO
|
|
select LIBC_ARCH_ELF_64BIT if LIBC_ARCH_ELF
|
|
---help---
|
|
x86-64 architectures.
|
|
|
|
config ARCH_XTENSA
|
|
bool "Xtensa"
|
|
select ARCH_HAVE_BACKTRACE
|
|
select ARCH_HAVE_CPUINFO
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_STACKCHECK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_TCBINFO
|
|
select ARCH_HAVE_STDARG_H
|
|
select ARCH_HAVE_SETJMP if ARCH_TOOLCHAIN_GNU
|
|
select ARCH_HAVE_SYSCALL_HOOKS
|
|
select ARCH_HAVE_PERF_EVENTS
|
|
---help---
|
|
Cadence® Tensilica® Xtensa® actictures.
|
|
|
|
config ARCH_Z16
|
|
bool "ZNEO"
|
|
select ARCH_HAVE_HEAP2
|
|
---help---
|
|
ZiLOG ZNEO 16-bit architectures (z16f).
|
|
|
|
config ARCH_Z80
|
|
bool "z80"
|
|
select ARCH_HAVE_HEAP2
|
|
---help---
|
|
ZiLOG 8-bit architectures (z80, ez80, z8).
|
|
|
|
config ARCH_OR1K
|
|
bool "OpenRISC"
|
|
---help---
|
|
OpenRISC architectures.
|
|
|
|
config ARCH_SPARC
|
|
bool "SPARC"
|
|
select ARCH_HAVE_INTERRUPTSTACK
|
|
select ARCH_HAVE_CUSTOMOPT
|
|
select ARCH_HAVE_TCBINFO
|
|
---help---
|
|
SPARC architectures (SPARC V8)
|
|
|
|
endchoice
|
|
|
|
config ARCH
|
|
string
|
|
default "arm" if ARCH_ARM
|
|
default "arm64" if ARCH_ARM64
|
|
default "avr" if ARCH_AVR
|
|
default "hc" if ARCH_HC
|
|
default "mips" if ARCH_MIPS
|
|
default "misoc" if ARCH_MISOC
|
|
default "renesas" if ARCH_RENESAS
|
|
default "risc-v" if ARCH_RISCV
|
|
default "sim" if ARCH_SIM
|
|
default "x86" if ARCH_X86
|
|
default "x86_64" if ARCH_X86_64
|
|
default "xtensa" if ARCH_XTENSA
|
|
default "z16" if ARCH_Z16
|
|
default "z80" if ARCH_Z80
|
|
default "or1k" if ARCH_OR1K
|
|
default "sparc" if ARCH_SPARC
|
|
|
|
source "arch/arm/Kconfig"
|
|
source "arch/arm64/Kconfig"
|
|
source "arch/avr/Kconfig"
|
|
source "arch/hc/Kconfig"
|
|
source "arch/mips/Kconfig"
|
|
source "arch/misoc/Kconfig"
|
|
source "arch/renesas/Kconfig"
|
|
source "arch/risc-v/Kconfig"
|
|
source "arch/sim/Kconfig"
|
|
source "arch/x86/Kconfig"
|
|
source "arch/x86_64/Kconfig"
|
|
source "arch/xtensa/Kconfig"
|
|
source "arch/z16/Kconfig"
|
|
source "arch/z80/Kconfig"
|
|
source "arch/or1k/Kconfig"
|
|
source "arch/sparc/Kconfig"
|
|
|
|
config ARCH_CHIP_CUSTOM
|
|
bool "Custom Chip Support"
|
|
default n
|
|
|
|
if ARCH_CHIP_CUSTOM
|
|
menu "Custom Chip Configuration"
|
|
|
|
config ARCH_CHIP_CUSTOM_NAME
|
|
string "Custom chip name"
|
|
default ""
|
|
---help---
|
|
This is a name for the chip. It is not used except to return the
|
|
information via the NSH uname command.
|
|
|
|
config ARCH_CHIP_CUSTOM_DIR
|
|
string "Custom chip directory"
|
|
default ""
|
|
---help---
|
|
If the custom chip configuration is selected, then it is necessary
|
|
to also tell the build system where it can find the chip directory
|
|
for the custom chip.
|
|
|
|
In this case, the chip directory is assumed to lie outside the
|
|
NuttX directory. The provided path must then be a full, absolute
|
|
path to some location outside of the NuttX source tree (like
|
|
"~/projects/mychip").
|
|
|
|
config ARCH_CHIP_CUSTOM_DIR_RELPATH
|
|
bool "Relative custom chip directory"
|
|
default y
|
|
---help---
|
|
Specifies that the chip directory is relative to the NuttX directory.
|
|
|
|
endmenu # Custom Chip Configuration
|
|
endif #ARCH_CHIP_CUSTOM
|
|
|
|
source "$BINDIR/arch/dummy/Kconfig"
|
|
|
|
config ARCH_TOOLCHAIN_IAR
|
|
bool
|
|
default n
|
|
|
|
config ARCH_TOOLCHAIN_GNU
|
|
bool
|
|
default n
|
|
|
|
config ARCH_TOOLCHAIN_CLANG
|
|
bool
|
|
select ARCH_TOOLCHAIN_GNU
|
|
default n
|
|
|
|
choice
|
|
prompt "Link Time Optimization (LTO)"
|
|
default LTO_NONE
|
|
---help---
|
|
This option enables Link Time Optimization (LTO), which allows the
|
|
compiler to optimize binaries globally.
|
|
|
|
If unsure, select LTO_NONE. Note that LTO is very resource-intensive
|
|
so it's disabled by default.
|
|
|
|
config LTO_NONE
|
|
bool "None"
|
|
---help---
|
|
Build the kernel normally, without Link Time Optimization (LTO).
|
|
|
|
config LTO_FULL
|
|
bool "GNU Full LTO (EXPERIMENTAL)"
|
|
depends on ARCH_TOOLCHAIN_GNU
|
|
---help---
|
|
Link time optimization is implemented as a GCC front end for a bytecode
|
|
bytecode representation of GIMPLE that is emitted in special sections
|
|
of .o files. Currently, LTO support is enabled in most ELF-based systems,
|
|
as well as darwin, cygwin and mingw systems.
|
|
|
|
config LTO_THIN
|
|
bool "Clang ThinLTO (EXPERIMENTAL)"
|
|
depends on ARCH_TOOLCHAIN_CLANG
|
|
---help---
|
|
This option enables Clang's ThinLTO, which allows for parallel
|
|
optimization and faster incremental compiles compared to the
|
|
CONFIG_LTO_FULL option. More information can be found
|
|
from Clang's documentation:
|
|
|
|
https://clang.llvm.org/docs/ThinLTO.html
|
|
|
|
If unsure, say Y.
|
|
endchoice
|
|
|
|
config ARCH_GNU_NO_WEAKFUNCTIONS
|
|
bool
|
|
depends on ARCH_TOOLCHAIN_GNU
|
|
default n
|
|
---help---
|
|
Disable support for weak functions.
|
|
|
|
config ARCH_SIZET_LONG
|
|
bool "size_t is type long"
|
|
default n
|
|
---help---
|
|
size_t may be type long or type int. This matters for some
|
|
C++ library routines because the NuttX size_t might not have
|
|
the same underlying type as your toolchain's size_t.
|
|
|
|
config ARCH_COVERAGE
|
|
bool "Enable code coverage analysis"
|
|
select HAVE_CXXINITIALIZE
|
|
default n
|
|
---help---
|
|
Generate code coverage
|
|
|
|
config ARCH_COVERAGE_ALL
|
|
bool "Enable code coverage for the entire image"
|
|
depends on ARCH_COVERAGE
|
|
default n
|
|
---help---
|
|
This option activates code coverage instrumentation for the
|
|
entire image. If you don't enable this option, you have to
|
|
explicitly specify "-fprofile-generate -ftest-coverage" for
|
|
the files/directories you want to check. Enabling this option
|
|
will get image size increased and performance decreased
|
|
significantly.
|
|
|
|
config ARCH_INSTRUMENT_ALL
|
|
bool "Instrument All"
|
|
default n
|
|
---help---
|
|
Add instrument to all source files. we can use instrument_register
|
|
to register the instrument function.
|
|
|
|
comment "Architecture Options"
|
|
|
|
config ARCH_NOINTC
|
|
bool
|
|
default n
|
|
|
|
config ARCH_VECNOTIRQ
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_IRQTRIGGER
|
|
bool
|
|
default n
|
|
depends on !ARCH_NOINTC
|
|
|
|
config ARCH_DMA
|
|
bool
|
|
default n
|
|
|
|
config ARCH_DMA_NO_FLASH_TRANSFER
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_IRQPRIO
|
|
bool
|
|
default n
|
|
|
|
config ARCH_ICACHE
|
|
bool
|
|
default n
|
|
|
|
config ARCH_ICACHE_LOCK
|
|
bool
|
|
depends on ARCH_ICACHE
|
|
default n
|
|
|
|
config ARCH_DCACHE
|
|
bool
|
|
default n
|
|
|
|
config ARCH_DCACHE_LOCK
|
|
bool
|
|
depends on ARCH_DCACHE
|
|
default n
|
|
|
|
config ARCH_L2CACHE
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_ADDRENV
|
|
bool
|
|
default n
|
|
|
|
config ARCH_NEED_ADDRENV_MAPPING
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_EXTRA_HEAPS
|
|
bool
|
|
default n
|
|
---help---
|
|
Special memory regions used as separate heaps
|
|
|
|
config ARCH_HAVE_TEXT_HEAP
|
|
bool
|
|
default n
|
|
---help---
|
|
Special memory region for dynamic code loading
|
|
|
|
config ARCH_HAVE_DATA_HEAP
|
|
bool
|
|
default n
|
|
---help---
|
|
Special memory region for dynamic data loading
|
|
|
|
config ARCH_HAVE_COPY_SECTION
|
|
bool
|
|
default n
|
|
---help---
|
|
Section copying for dynamic code loading
|
|
|
|
config ARCH_HAVE_MULTICPU
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_FORK
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_FPU
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_DPFPU
|
|
bool
|
|
default n
|
|
select ARCH_HAVE_FPU
|
|
|
|
config ARCH_HAVE_LAZYFPU
|
|
bool
|
|
default n
|
|
depends on ARCH_HAVE_FPU
|
|
|
|
config ARCH_HAVE_MMU
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_MPU
|
|
bool
|
|
default n
|
|
|
|
config ARCH_NAND_HWECC
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_EXTCLK
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_POWEROFF
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_PROGMEM
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_PROGMEM_READ
|
|
bool
|
|
default n
|
|
depends on ARCH_HAVE_PROGMEM
|
|
|
|
config ARCH_HAVE_RESET
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_TESTSET
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_THREAD_LOCAL
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_FETCHADD
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_RTC_SUBSECONDS
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_SYSCALL_HOOKS
|
|
bool
|
|
default n
|
|
---help---
|
|
Indicates that the architecture supports the system call hooks as
|
|
required if CONFIG_SCHED_INSTRUMENTATION_SYSCALL is enabled. Refer
|
|
to sched/Kconfig for additional information.
|
|
|
|
config ARCH_HAVE_BACKTRACE
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_DEBUG
|
|
bool "Architecture have debug support"
|
|
default n
|
|
|
|
config ARCH_HAVE_PERF_EVENTS
|
|
bool
|
|
default n
|
|
---help---
|
|
The architecture supports hardware performance counting.
|
|
|
|
config ARCH_PERF_EVENTS
|
|
bool "Configure hardware performance counting"
|
|
default y if SCHED_CRITMONITOR || SCHED_IRQMONITOR || RPTUN_PING || SEGGER_SYSVIEW
|
|
default n
|
|
depends on ARCH_HAVE_PERF_EVENTS
|
|
---help---
|
|
Enable hardware performance counter support for perf events. If
|
|
disabled, perf events will use software events only.
|
|
|
|
config ARCH_HAVE_BOOTLOADER
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_CPUINFO
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_TCBINFO
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_ELF_EXECUTABLE
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HAVE_TRUSTZONE
|
|
bool
|
|
default n
|
|
---help---
|
|
Automatically selected to indicate that the ARM CPU supports
|
|
TrustZone.
|
|
|
|
choice
|
|
prompt "TrustZone Configuration"
|
|
default ARCH_TRUSTZONE_NONSECURE
|
|
depends on ARCH_HAVE_TRUSTZONE
|
|
|
|
config ARCH_TRUSTZONE_SECURE
|
|
bool "All CPUs operate secure state"
|
|
|
|
config ARCH_TRUSTZONE_NONSECURE
|
|
bool "All CPUs operate non-secure state"
|
|
|
|
endchoice # TrustZone Configuration
|
|
|
|
config ARCH_FPU
|
|
bool "FPU support"
|
|
default y
|
|
depends on ARCH_HAVE_FPU
|
|
---help---
|
|
Build in support for the Floating Point Unit (FPU).
|
|
Check your chip specifications first; not all chips support the FPU.
|
|
|
|
config ARCH_DPFPU
|
|
bool "Double precision FPU support"
|
|
default y
|
|
depends on ARCH_FPU && ARCH_HAVE_DPFPU
|
|
---help---
|
|
Enable toolchain support for double precision (64-bit) floating
|
|
point if both the toolchain and the hardware support it.
|
|
|
|
config ARCH_LAZYFPU
|
|
bool "Enable lazy FPU state save / restore"
|
|
default n
|
|
depends on ARCH_FPU && ARCH_HAVE_LAZYFPU
|
|
---help---
|
|
Enable lazy FPU state save and restore. Normally FPU state is saved
|
|
and restored with the integer context registers, if the task is using
|
|
FPU. The state is typically saved into the task's user stack upon
|
|
exception entry or context switch out, and restored when the
|
|
exception returns or context switches back in.
|
|
|
|
As the kernel does not use FPU, this can be optimized with the help
|
|
of the FPU hardware status and a bit of code logic inside the kernel.
|
|
The logic keeps track of the FPU state, which can be "unused",
|
|
"dirty" or "clean". A clean state means the FPU has not been used
|
|
since the last state save, while the dirty state indicates that the
|
|
FPU has been used.
|
|
|
|
The optimization saves / restores FPU registers only if:
|
|
- A context change has happened, save and restore does not happen
|
|
during exception entry / return to the same task
|
|
- FPU is in use (state is not unused) and
|
|
- FPU status is dirty, i.e. FPU has been used after the last
|
|
- FPU restore happens when status is in dirty or clean
|
|
|
|
This saves CPU time as the FPU registers do not have to be moved in
|
|
and out when handling an exception that does not result in a context
|
|
switch.
|
|
|
|
The tradeoff with the lazy FPU feature is that it requires a static
|
|
memory allocation from the task's TCB to store the FPU registers,
|
|
while the non-lazy style can use stack memory for storing the FPU
|
|
registers, saving memory as the stack frame for the FPU registers can
|
|
be skipped if the FPU is not in use.
|
|
|
|
config ARCH_USE_MMU
|
|
bool "Enable MMU"
|
|
default n
|
|
depends on ARCH_HAVE_MMU
|
|
---help---
|
|
The architecture supports supports an MMU. Enable this option in
|
|
order to enable use of the MMU. For most architectures, this is
|
|
not really an option: It is required to use the MMU. In those
|
|
cases, this selection will always be forced.
|
|
|
|
config ARCH_USE_MPU
|
|
bool "Enable MPU"
|
|
default n
|
|
depends on ARCH_HAVE_MPU
|
|
---help---
|
|
The architecture supports supports an MPU. Enable this option in
|
|
order to enable use of the MPU. For most architectures, this option
|
|
is enabled by other, platform-specific logic. In those cases, this
|
|
selection will always be forced.
|
|
|
|
config ARCH_USE_TEXT_HEAP
|
|
bool "Enable separate text allocation for dynamic code loading"
|
|
default n
|
|
depends on ARCH_HAVE_TEXT_HEAP
|
|
---help---
|
|
This option enables architecture-specific memory allocator
|
|
for dynamic code loading. For example, ESP32 has separate memory
|
|
regions for instruction and data and the memory region used for
|
|
usual malloc doesn't work for instruction.
|
|
|
|
config ARCH_USE_DATA_HEAP
|
|
bool "Enable separate data allocation for dynamic data loading"
|
|
default n
|
|
depends on ARCH_HAVE_DATA_HEAP
|
|
---help---
|
|
This option enables architecture-specific memory allocator
|
|
for dynamic data loading.
|
|
|
|
menuconfig ARCH_ADDRENV
|
|
bool "Address environments"
|
|
default n
|
|
depends on ARCH_HAVE_ADDRENV && SCHED_LPWORK
|
|
---help---
|
|
Support per-task address environments using the MMU... i.e., support
|
|
"processes"
|
|
|
|
config ARCH_USE_COPY_SECTION
|
|
bool "Enable arch copy section by self for dynamic code loading"
|
|
default n
|
|
depends on ARCH_HAVE_COPY_SECTION
|
|
---help---
|
|
This option enables architecture-specific memory copy for
|
|
dynamic code loading. For example, Ambiq has MRAM regions
|
|
for instruction which can't load by the memcpy directly.
|
|
|
|
if ARCH_ADDRENV && ARCH_NEED_ADDRENV_MAPPING
|
|
|
|
config ARCH_TEXT_VBASE
|
|
hex "Virtual .text base"
|
|
---help---
|
|
The virtual address of the beginning the .text region
|
|
|
|
config ARCH_DATA_VBASE
|
|
hex "Virtual .bss/.data base"
|
|
---help---
|
|
The virtual address of the beginning of the .bss/.data region.
|
|
|
|
config ARCH_HEAP_VBASE
|
|
hex "Virtual heap base"
|
|
---help---
|
|
The virtual address of the beginning of the heap region.
|
|
|
|
config ARCH_VMA_MAPPING
|
|
bool "Support runtime memory mapping into SHM area"
|
|
default n
|
|
|
|
config ARCH_SHM_VBASE
|
|
hex "Shared memory base"
|
|
depends on ARCH_VMA_MAPPING
|
|
---help---
|
|
The virtual address of the beginning of the shared memory region.
|
|
|
|
config ARCH_KMAP_VBASE
|
|
hex "Kernel dynamic virtual mappings base"
|
|
---help---
|
|
The virtual address of the beginning of the kernel dynamic mapping
|
|
region.
|
|
|
|
config ARCH_TEXT_NPAGES
|
|
int "Max .text pages"
|
|
default 1
|
|
---help---
|
|
The maximum number of pages that can allocated for the .text region.
|
|
This, along with knowledge of the page size, determines the size of
|
|
the .text virtual address space. Default is 1.
|
|
|
|
config ARCH_DATA_NPAGES
|
|
int "Max .bss/.data pages"
|
|
default 1
|
|
---help---
|
|
The maximum number of pages that can allocated for the .bss/.data
|
|
region. This, along with knowledge of the page size, determines the
|
|
size of the .bss/.data virtual address space. Default is 1.
|
|
|
|
config ARCH_HEAP_NPAGES
|
|
int "Max heap pages"
|
|
default 1
|
|
---help---
|
|
The maximum number of pages that can allocated for the heap region.
|
|
This, along with knowledge of the page size, determines the size of
|
|
the heap virtual address space. Default is 1.
|
|
|
|
if ARCH_VMA_MAPPING
|
|
|
|
config ARCH_SHM_MAXREGIONS
|
|
int "Max shared memory regions"
|
|
default 1
|
|
---help---
|
|
The maximum number of regions that can allocated for the shared
|
|
memory space. This hard-coded value permits static allocation of
|
|
the shared memory data structures and serves no other purpose.
|
|
Default is 1.
|
|
|
|
The size of the virtual shared memory address space is then
|
|
determined by the product of the maximum number of regions, the
|
|
maximum number of pages per region, and the configured size of
|
|
each page.
|
|
|
|
config ARCH_SHM_NPAGES
|
|
int "Max shared memory pages"
|
|
default 1
|
|
---help---
|
|
The maximum number of pages that can allocated per region for the shared memory
|
|
region. Default is 1.
|
|
|
|
The size of the virtual shared memory address space is then
|
|
determined by the product of the maximum number of regions, the
|
|
maximum number of pages per region, and the configured size of
|
|
each page.
|
|
|
|
endif # ARCH_VMA_MAPPING
|
|
|
|
config ARCH_KMAP_NPAGES
|
|
int "Max kernel dynamic mapping pages"
|
|
default 1
|
|
---help---
|
|
The maximum amount of pages that a kernel can use for dynamically
|
|
mapping physical pages to itself.
|
|
|
|
The size of the virtual shared memory address space is then
|
|
determined by the product of the maximum number of regions, the
|
|
maximum number of pages per region, and the configured size of
|
|
each page.
|
|
|
|
config ARCH_STACK_DYNAMIC
|
|
bool "Dynamic user stack"
|
|
default n
|
|
depends on BUILD_KERNEL && EXPERIMENTAL
|
|
---help---
|
|
Select this option if the user process stack resides in its own
|
|
address space. The naming of this selection implies that dynamic
|
|
stack allocation is supported. Certainly this option must be set if
|
|
dynamic stack allocation is supported by a platform. But the more
|
|
general meaning of this configuration environment is simply that the
|
|
stack has its own address space.
|
|
|
|
NOTE: This option not yet fully implemented in the code base.
|
|
Hence, it is marked EXPERIMENTAL: Do not enable it unless you plan
|
|
finish the implementation.
|
|
|
|
if ARCH_STACK_DYNAMIC
|
|
|
|
config ARCH_STACK_VBASE
|
|
hex "Virtual stack base"
|
|
---help---
|
|
The virtual address of the beginning the stack region
|
|
|
|
config ARCH_STACK_NPAGES
|
|
int "Max. stack pages"
|
|
default 1
|
|
---help---
|
|
The maximum number of pages that can allocated for the stack region.
|
|
This, along with knowledge of the page size, determines the size of
|
|
the stack virtual address space. Default is 1.
|
|
|
|
endif # ARCH_STACK_DYNAMIC
|
|
|
|
config ARCH_KERNEL_STACK
|
|
bool "Kernel process stack"
|
|
default LIBC_EXECFUNCS
|
|
depends on BUILD_KERNEL
|
|
---help---
|
|
It this option is selected, then every user process will have two
|
|
stacks: A large, potentially dynamically sized user stack and small
|
|
kernel stack that is used during system call process.
|
|
|
|
If this option is not selected, then kernel system calls will simply
|
|
use the caller's user stack. So, in most cases, this option is not
|
|
required. However, this option is *required* if both BUILD_KERNEL
|
|
and LIBC_EXECFUNCS are selected. Why? Because when we instantiate
|
|
and initialize the address environment of the new user process, we
|
|
will temporarily lose the address environment of the old user
|
|
process, including its stack contents. The kernel C logic will
|
|
crash immediately with no valid stack in place.
|
|
|
|
When this option is selected, the smaller kernel stack stays in
|
|
place during system call processing event though the original user
|
|
stack may or may not be accessible.
|
|
|
|
if ARCH_KERNEL_STACK
|
|
|
|
config ARCH_KERNEL_STACKSIZE
|
|
int "Kernel stack size"
|
|
default 1568
|
|
---help---
|
|
The common size of each process's kernel stack
|
|
|
|
endif # ARCH_KERNEL_STACK
|
|
|
|
config ARCH_PGPOOL_MAPPING
|
|
bool "Have page pool mapping"
|
|
default n
|
|
---help---
|
|
If there is a MMU mapping in place for the page pool memory, then
|
|
this mapping can be utilized to simplify some page table operations.
|
|
Otherwise, a temporary mapping will have to be established each time
|
|
it is necessary to modify the contents of a page.
|
|
|
|
if ARCH_PGPOOL_MAPPING
|
|
|
|
config ARCH_PGPOOL_PBASE
|
|
hex "Page pool physical address"
|
|
default 0x0
|
|
---help---
|
|
The physical address of the start of the page pool memory. This
|
|
setting is probably equivalent to other platform specific definitions
|
|
but is required again in order to modularize the common address
|
|
environment logic.
|
|
|
|
config ARCH_PGPOOL_VBASE
|
|
hex "Page pool virtual address"
|
|
default 0x0
|
|
---help---
|
|
The virtual address of the start of the page pool memory. This
|
|
setting is probably equivalent to other platform specific definitions
|
|
but is required again in order to modularize the common address
|
|
environment logic.
|
|
|
|
config ARCH_PGPOOL_SIZE
|
|
int "Page pool size (bytes)"
|
|
default 0
|
|
---help---
|
|
The size of the page pool memory in bytes. This setting is probably
|
|
equivalent to other platform specific definitions but is required again
|
|
in order to modularize the common address environment logic.
|
|
|
|
endif # ARCH_PGPOOL_MAPPING
|
|
endif # ARCH_ADDRENV && ARCH_NEED_ADDRENV_MAPPING
|
|
|
|
menuconfig PAGING
|
|
bool "On-demand paging"
|
|
default n
|
|
depends on ARCH_USE_MMU && !ARCH_ROMPGTABLE
|
|
---help---
|
|
If set =y in your configation file, this setting will enable the on-demand
|
|
paging feature as described in
|
|
https://nuttx.apache.org/docs/latest/components/paging.html.
|
|
|
|
if PAGING
|
|
|
|
config PAGING_PAGESIZE
|
|
int "Page size (bytes)"
|
|
default 4096
|
|
---help---
|
|
The size of one managed page. This must be a value supported by the
|
|
processor's memory management unit
|
|
|
|
config PAGING_NLOCKED
|
|
int "Number of locked pages"
|
|
default 48
|
|
---help---
|
|
This is the number of locked pages in the memory map.
|
|
|
|
config PAGING_CUSTOM_BASE
|
|
bool "Custom paging base address"
|
|
default n
|
|
---help---
|
|
By default, the page begins at RAM_START/VSTART. That base address
|
|
can be changed if this value is selected.
|
|
|
|
if PAGING_CUSTOM_BASE
|
|
|
|
config PAGING_LOCKED_PBASE
|
|
hex "Physical base address"
|
|
|
|
config PAGING_LOCKED_VBASE
|
|
hex "Virtual base address"
|
|
|
|
endif # PAGING_CUSTOM_BASE
|
|
|
|
config PAGING_NPPAGED
|
|
int "Number of physical pages"
|
|
default 256
|
|
---help---
|
|
This is the number of physical pages available to support the paged
|
|
text region.
|
|
|
|
config PAGING_NVPAGED
|
|
int "Number of virtual pages"
|
|
default 1024
|
|
---help---
|
|
This actual size of the virtual paged text region (in pages). This
|
|
is also the number of virtual pages required to span the entire
|
|
paged region. The on-demand paging feature is intended to support
|
|
only the case where the virtual paged text area is much larger the
|
|
available physical pages. Otherwise, why would you enable on-demand paging?
|
|
|
|
config PAGING_NDATA
|
|
int "Number of data pages"
|
|
default 256
|
|
---help---
|
|
This is the number of data pages in the memory map. The data region
|
|
will extend to the end of RAM unless overridden by a setting in the
|
|
configuration file.
|
|
|
|
NOTE: In some architectures, it may be necessary to take some memory
|
|
from the end of RAM for page tables or other system usage. The
|
|
configuration settings and linker directives must be cognizant of
|
|
that: PAGING_NDATA should be defined to prevent the data region from
|
|
extending all the way to the end of memory.
|
|
|
|
config PAGING_DEFPRIO
|
|
int "Page fill worker thread priority"
|
|
default 100
|
|
---help---
|
|
The default, minimum priority of the page fill worker thread. The
|
|
priority of the page fill work thread will be boosted boosted
|
|
dynamically so that it matches the priority of the task on behalf
|
|
of which it performs the fill. This defines the minimum priority
|
|
that will be used. Default: 100.
|
|
|
|
config PAGING_STACKSIZE
|
|
int "Page fill worker thread stack size"
|
|
default 1024
|
|
---help---
|
|
Defines the size of the allocated stack for the page fill worker
|
|
thread. Default: 1024.
|
|
|
|
config PAGING_BLOCKINGFILL
|
|
bool "Blocking fill"
|
|
default n
|
|
---help---
|
|
The architecture specific up_fillpage() function may be blocking
|
|
or non-blocking. If defined, this setting indicates that the
|
|
up_fillpage() implementation will block until the transfer is
|
|
completed. Default: Undefined (non-blocking).
|
|
|
|
config PAGING_WORKPERIOD
|
|
int "Work period (usec)"
|
|
default 500000
|
|
---help---
|
|
The page fill worker thread will wake periodically even if there
|
|
is no mapping to do. This selection controls that wake-up period
|
|
(in microseconds). This wake-up a failsafe that will handle any
|
|
cases where a single is lost (that would really be a bug and
|
|
shouldn't happen!) and also supports timeouts for case of non-
|
|
blocking, asynchronous fills (see CONFIG_PAGING_TIMEOUT_TICKS).
|
|
|
|
config PAGING_TIMEOUT
|
|
bool "Paging timeout"
|
|
default n
|
|
---help---
|
|
If defined, the implementation will monitor the (asynchronous) page
|
|
fill logic. If the fill takes longer than than a timeout value,
|
|
then a fatal error will be declared. Default: No timeouts monitored
|
|
|
|
config PAGING_TIMEOUT_TICKS
|
|
int "Paging timeout ticks"
|
|
default 10
|
|
depends on PAGING_TIMEOUT
|
|
---help---
|
|
If PAGING_TIMEOUT is defined, then implementation will monitor the
|
|
(asynchronous) page fill logic. If the fill takes longer than this
|
|
number if microseconds, then a fatal error will be declared.
|
|
Default: No timeouts monitored
|
|
|
|
endif # PAGING
|
|
|
|
config ARCH_IRQPRIO
|
|
bool "Prioritized interrupt support"
|
|
default n
|
|
depends on ARCH_HAVE_IRQPRIO
|
|
---help---
|
|
Enable support for prioritized interrupts.
|
|
|
|
NOTE: The use of interrupt priorities implies that you also have
|
|
support for nested interrupts. Most architectures do not support
|
|
nesting of interrupts or, if they do, they only supported nested
|
|
interrupts with certain configuration options. So this selection
|
|
should be used with caution.
|
|
|
|
config ARCH_STACKDUMP
|
|
bool "Dump stack on assertions"
|
|
default n
|
|
select DEBUG_ALERT
|
|
---help---
|
|
Enable to do stack dumps after assertions
|
|
|
|
config ARCH_STACKDUMP_MAX_LENGTH
|
|
int "The maximum length for dump stack on assertions"
|
|
depends on ARCH_STACKDUMP
|
|
default 0
|
|
|
|
config DUMP_ON_EXIT
|
|
bool "Dump all tasks state on exit"
|
|
default n
|
|
depends on DEBUG_SCHED_INFO
|
|
---help---
|
|
Dump all tasks state on exit()
|
|
|
|
config ARCH_USBDUMP
|
|
bool "Dump USB trace data"
|
|
default n
|
|
depends on USBDEV_TRACE
|
|
---help---
|
|
Enable to do USB trace after assertions
|
|
|
|
config ARCH_DEADLOCKDUMP
|
|
bool "Dump dead lock thread"
|
|
default "n"
|
|
---help---
|
|
This option will dump the dead lock thread when assert happen..
|
|
|
|
config ENDIAN_BIG
|
|
bool "Big Endian Architecture"
|
|
default n
|
|
depends on !ARCH_RISCV
|
|
---help---
|
|
Select if architecture operates using big-endian byte ordering.
|
|
|
|
config ARCH_IDLE_CUSTOM
|
|
bool "Custom IDLE loop"
|
|
default n
|
|
---help---
|
|
Each architecture provides a "default" IDLE loop that exits when the
|
|
MCU has nothing else to do. This default IDLE loop can be replaced
|
|
by a custom, board-specific IDLE loop by setting this option. Such
|
|
a custom IDLE loop may do things like a continuous built-in test or
|
|
perhaps or IDLE low power operations.
|
|
|
|
NOTE: As of this writing, this capability is only supported by ARM
|
|
and MIPS architectures. However, the implementation is trivial: If
|
|
CONFIG_ARCH_IDLE_CUSTOM is defined, then the default IDLE loop file
|
|
is not included in the MCU-specific Make.defs file.
|
|
|
|
config ARCH_CUSTOM_PMINIT
|
|
bool "Custom PM initialization"
|
|
default n
|
|
depends on PM
|
|
---help---
|
|
Each architecture provides default power management (PM)
|
|
initialization that is called automatically when the system is
|
|
started. This default PM initialization can be replaced by custom,
|
|
board-specific PM initialization by setting this option. Such a
|
|
custom initialization may do additional PM-related initialization
|
|
that is unique to the board power management requirements.
|
|
|
|
NOTE: As of this writing, this capability is only supported by the
|
|
STM32. However, the implementation is trivial: If CONFIG_ARCH_CUSTOM_PMINIT,
|
|
then the default PM initialization is not included in the MCU-specific
|
|
Make.defs file.
|
|
|
|
config ARCH_HAVE_RAMFUNCS
|
|
bool
|
|
default n
|
|
|
|
config ARCH_RAMFUNCS
|
|
bool "Copy functions to RAM on startup"
|
|
default y
|
|
depends on ARCH_HAVE_RAMFUNCS
|
|
---help---
|
|
Copy some functions to RAM at boot time. This is done in some
|
|
architectures to improve performance. In other cases, it is done
|
|
so that FLASH can be reconfigured while the MCU executes out of
|
|
SRAM.
|
|
|
|
config ARCH_HAVE_RAMVECTORS
|
|
bool
|
|
default n
|
|
|
|
config ARCH_RAMVECTORS
|
|
bool "Support RAM interrupt vectors"
|
|
default n
|
|
depends on ARCH_HAVE_RAMVECTORS
|
|
---help---
|
|
If ARCH_RAMVECTORS is defined, then the architecture will support
|
|
modifiable vectors in a RAM-based vector table.
|
|
|
|
config ARCH_MINIMAL_VECTORTABLE
|
|
bool "Minimal RAM usage for vector table"
|
|
default n
|
|
---help---
|
|
Use a minimum amount of RAM for the vector table.
|
|
|
|
Instead of allowing irq_attach() to work for all interrupt vectors,
|
|
restrict to only working for a select few (defined in your board
|
|
configuration). This can dramatically reduce the amount of RAM used
|
|
be your vector table.
|
|
|
|
To use this setting, you must have a file in your board config that
|
|
provides:
|
|
|
|
#include <nuttx/arch.h>
|
|
const irq_mapped_t g_irqmap[NR_IRQS] =
|
|
{
|
|
... IRQ to index mapping values ...
|
|
};
|
|
|
|
This table is index by the hardware IRQ number and provides a value
|
|
in the range of 0 to CONFIG_ARCH_NUSER_INTERRUPTS that is the new,
|
|
mapped index into the vector table. Unused, unmapped interrupts
|
|
should be set to IRQMAPPED_MAX. So, for example, if g_irqmap[37]
|
|
== 24, then the hardware interrupt vector 37 will be mapped to the
|
|
interrupt vector table at index 24. if g_irqmap[42] ==
|
|
IRQMAPPED_MAX, then hardware interrupt vector 42 is not used and
|
|
if it occurs will result in an unexpected interrupt crash.
|
|
|
|
config ARCH_NUSER_INTERRUPTS
|
|
int "Number of interrupts"
|
|
default 0
|
|
depends on ARCH_MINIMAL_VECTORTABLE
|
|
---help---
|
|
If CONFIG_ARCH_MINIMAL_VECTORTABLE is defined, then this setting
|
|
defines the actual number of valid, mapped interrupts in g_irqmap.
|
|
This number will be the new size of the OS vector table
|
|
|
|
# Bring-up debug configuration options. These are only intended for low level
|
|
# bring-up and not part of normal platform configuration. They should never be
|
|
# selected in a "normal" configuration and, hence, depend on both EXPERIMENTAL
|
|
# and DEBUG_FEATURES.
|
|
|
|
menu "Bring-Up Options"
|
|
depends on DEBUG_FEATURES
|
|
|
|
config SUPPRESS_CLOCK_CONFIG
|
|
bool "Suppress clock configuration"
|
|
default n
|
|
---help---
|
|
Do not configure clocking. Instead relies on the reset clock
|
|
configuration (or clock configuration provided by a bootloader).
|
|
|
|
config SUPPRESS_INTERRUPTS
|
|
bool "Suppress all interrupts"
|
|
default n
|
|
---help---
|
|
Do not enable interrupts
|
|
|
|
config SUPPRESS_TIMER_INTS
|
|
bool "No timer"
|
|
default n
|
|
---help---
|
|
Do not initialize or enable the system timer
|
|
|
|
config SUPPRESS_SERIAL_INTS
|
|
bool "Suppress serial interrupts"
|
|
default n
|
|
---help---
|
|
Console will poll
|
|
|
|
config SUPPRESS_UART_CONFIG
|
|
bool "Do no re-configure UART"
|
|
default n
|
|
---help---
|
|
Do not re-configure the serial console UART from its start-up state.
|
|
This is useful when a boot loader has already initialized the serial
|
|
port.
|
|
|
|
endmenu # Bring-Up Options
|
|
|
|
comment "Board Settings"
|
|
|
|
config BOARD_LOOPSPERMSEC
|
|
int "Delay loops per millisecond"
|
|
default 5000
|
|
---help---
|
|
Simple delay loops are used by some logic, especially during boot-up,
|
|
driver initialization. These delay loops must be calibrated for each
|
|
board in order to assure accurate timing by the delay loops.
|
|
|
|
comment "Interrupt options"
|
|
|
|
config ARCH_HAVE_INTERRUPTSTACK
|
|
bool
|
|
default n
|
|
|
|
config ARCH_INTERRUPTSTACK
|
|
int "Interrupt Stack Size"
|
|
depends on ARCH_HAVE_INTERRUPTSTACK
|
|
default 0
|
|
---help---
|
|
This architecture supports an interrupt stack. If defined, this symbol
|
|
will be the size of the interrupt stack in bytes. If not defined (or
|
|
defined to be zero), the user task stacks will be used during interrupt
|
|
handling.
|
|
|
|
config ARCH_HAVE_HIPRI_INTERRUPT
|
|
bool
|
|
default n
|
|
|
|
config ARCH_HIPRI_INTERRUPT
|
|
bool "High priority interrupts"
|
|
default n
|
|
depends on ARCH_HAVE_HIPRI_INTERRUPT && ARCH_HAVE_IRQPRIO
|
|
select ARCH_IRQPRIO
|
|
---help---
|
|
NOTE: This description is currently unique to the Cortex-M family
|
|
which is the only family that currently supports this feature. The
|
|
general feature is not conceptually unique to the Cortex-M but if it
|
|
is extended to any other family, then this discussion will have to
|
|
be generalized.
|
|
|
|
If ARMV7M_USEBASEPRI is selected, then interrupts will be disabled
|
|
by setting the BASEPRI register to NVIC_SYSH_DISABLE_PRIORITY so
|
|
that most interrupts will not have execution priority. SVCall must
|
|
have execution priority in all cases.
|
|
|
|
In the normal cases, interrupts are not nest-able and all interrupts
|
|
run at an execution priority between NVIC_SYSH_PRIORITY_MIN and
|
|
NVIC_SYSH_PRIORITY_MAX (with NVIC_SYSH_PRIORITY_MAX reserved for
|
|
SVCall).
|
|
|
|
If, in addition, ARCH_HIPRI_INTERRUPT is defined, then special high
|
|
priority interrupts are supported. These are not "nested" in the
|
|
normal sense of the word. These high priority interrupts can
|
|
interrupt normal processing but execute outside of OS (although they
|
|
can "get back into the game" via a PendSV interrupt).
|
|
|
|
How do you specify a high priority interrupt? You need to do two
|
|
things:
|
|
|
|
1) You need to change the address in the vector table so that
|
|
the high priority interrupt vectors to your special C
|
|
interrupt handler. There are two ways to do this:
|
|
|
|
a) If you select CONFIG_ARCH_RAMVECTORS, then vectors will
|
|
be kept in RAM and the system will support the interface:
|
|
|
|
int up_ramvec_attach(int irq, up_vector_t vector)
|
|
|
|
that can be used to attach your C interrupt handler to the
|
|
vector at run time.
|
|
|
|
b) Alternatively, you could keep your vectors in FLASH but in
|
|
order to this, you would have to develop your own custom
|
|
vector table.
|
|
|
|
2) Then set the priority of your interrupt to NVIC to
|
|
NVIC_SYSH_HIGH_PRIORITY using the standard interface:
|
|
|
|
int up_prioritize_irq(int irq, int priority)
|
|
|
|
NOTE: ARCH_INTERRUPTSTACK must be set in kernel mode (BUILD_KERNEL).
|
|
In kernel mode without an interrupt stack, the interrupt handler
|
|
will set the MSP to the stack pointer of the interrupted thread. If
|
|
the interrupted thread was a privileged thread, that will be the MSP
|
|
otherwise it will be the PSP. If the PSP is used, then the value of
|
|
the MSP will be invalid when the interrupt handler returns because
|
|
it will be a pointer to an old position in the unprivileged stack.
|
|
Then when the high priority interrupt occurs and uses this stale MSP,
|
|
there will most likely be a system failure.
|
|
|
|
If the interrupt stack is selected, on the other hand, then the
|
|
interrupt handler will always set the MSP to the interrupt
|
|
stack. So when the high priority interrupt occurs, it will either
|
|
use the MSP of the last privileged thread to run or, in the case of
|
|
the nested interrupt, the interrupt stack if no privileged task has
|
|
run
|
|
|
|
comment "Boot options"
|
|
|
|
choice
|
|
prompt "Boot Mode"
|
|
default BOOT_RUNFROMFLASH
|
|
|
|
config BOOT_RUNFROMEXTSRAM
|
|
bool "Run from external SRAM"
|
|
---help---
|
|
Some configuration support booting and running from external SRAM.
|
|
|
|
config BOOT_RUNFROMFLASH
|
|
bool "Boot and run from flash"
|
|
---help---
|
|
Most configurations support XIP operation from FLASH but must copy
|
|
initialized .data sections to RAM. (This is the default).
|
|
|
|
config BOOT_RUNFROMISRAM
|
|
bool "Boot and run from internal SRAM"
|
|
---help---
|
|
Some configuration support booting and running from internal SRAM.
|
|
|
|
config BOOT_RUNFROMSDRAM
|
|
bool "Boot and run from external SDRAM"
|
|
---help---
|
|
Some configuration support booting and running from external SDRAM.
|
|
|
|
config BOOT_COPYTORAM
|
|
bool "Boot from FLASH but copy to ram"
|
|
---help---
|
|
Some configurations boot in FLASH but copy themselves entirely into
|
|
RAM for better performance.
|
|
|
|
endchoice
|
|
|
|
menu "Boot Memory Configuration"
|
|
|
|
config RAM_START
|
|
hex "Primary RAM start address (physical)"
|
|
default 0x0
|
|
---help---
|
|
The physical start address of primary installed RAM. "Primary" RAM
|
|
refers to the RAM that you link program code into. If program code
|
|
does not execute out of RAM but from FLASH, then you may designate
|
|
any block of RAM as "primary."
|
|
|
|
config RAM_VSTART
|
|
hex "Primary RAM start address (virtual)"
|
|
default 0x0
|
|
depends on ARCH_USE_MMU
|
|
---help---
|
|
The virtual start address of installed primary RAM. "Primary" RAM
|
|
refers to the RAM that you link program code into. If program code
|
|
does not execute out of RAM but from FLASH, then you may designate
|
|
any block of RAM as "primary."
|
|
|
|
config RAM_SIZE
|
|
int "Primary RAM size"
|
|
default 0
|
|
---help---
|
|
The size in bytes of the installed primary RAM. "Primary" RAM
|
|
refers to the RAM that you link program code into. If program code
|
|
does not execute out of RAM but from FLASH, then you may designate
|
|
any block of RAM as "primary."
|
|
|
|
if BOOT_RUNFROMFLASH && ARCH_USE_MMU
|
|
|
|
config FLASH_START
|
|
hex "Boot FLASH start address (physical)"
|
|
default 0x0
|
|
---help---
|
|
The physical start address of installed boot FLASH. "Boot" FLASH
|
|
refers to the FLASH that you link program code into.
|
|
|
|
config FLASH_VSTART
|
|
hex "Boot FLASH start address (virtual)"
|
|
default 0x0
|
|
---help---
|
|
The virtual start address of installed boot FLASH. "Boot" FLASH
|
|
refers to the FLASH that you link program code into.
|
|
|
|
config FLASH_SIZE
|
|
int "Boot FLASH size"
|
|
default 0
|
|
---help---
|
|
The size in bytes of the installed boot FLASH. "Boot" FLASH
|
|
refers to the FLASH that you link program code into.
|
|
|
|
endif # BOOT_RUNFROMFLASH && ARCH_USE_MMU
|
|
|
|
config ARCH_HAVE_SDRAM
|
|
bool
|
|
default n
|
|
|
|
config BOOT_SDRAM_DATA
|
|
bool "Data in SDRAM"
|
|
default n
|
|
depends on ARCH_HAVE_SDRAM && !BOOT_RUNFROMSDRAM
|
|
---help---
|
|
This selection should be set if data lies in SDRAM (vs. SRAM) and if
|
|
SDRAM was not previously initialized by a loader. Obviously, this
|
|
does not apply if we booting from SDRAM because SDRAM must have been
|
|
initialized priority to loading NuttX into SDRAM.
|
|
|
|
In the case where SDRAM must be initialized by NuttX, the
|
|
initialization sequence is a little different: Normally, .data and
|
|
.bss must be initialized before starting the system. But in this
|
|
case SDRAM must be configured by board-specific logic before the
|
|
.data and .bss sections can be initialized.
|
|
|
|
endmenu # Boot Memory Configuration
|