diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 683e23f36e..a5e24e29a9 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -216,6 +216,13 @@ config ARMV7M_MPU Build in support for the ARM Cortex-M3/4 Memory Protection Unit (MPU). Check your chip specifications first; not all Cortex-M3/4 chips support the MPU. +config ARMV7M_MPU_NREGIONS + int "Number of MPU regions" + default 8 + depends on ARMV7M_MPU + ---help--- + This is the number of protection regions supported by the MPU. + config ARCH_HAVE_LOWVECTORS bool diff --git a/arch/arm/src/armv7-m/up_mpu.c b/arch/arm/src/armv7-m/up_mpu.c index d4b04a4446..2b8a8f9945 100644 --- a/arch/arm/src/armv7-m/up_mpu.c +++ b/arch/arm/src/armv7-m/up_mpu.c @@ -48,6 +48,11 @@ /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ +/* Configuration ************************************************************/ + +#ifndef CONFIG_ARMV7M_MPU_NREGIONS +# define CONFIG_ARMV7M_MPU_NREGIONS 8 +#endif /**************************************************************************** * Private Data @@ -84,13 +89,14 @@ static uint8_t g_region; * * Assumptions: * - Regions are never deallocated - * - Regions are only allocated early in initialization, so nothing - * special is require; + * - Regions are only allocated early in initialization, so no special + * protection against re-entrancy is required; * ****************************************************************************/ unsigned int mpu_allocregion(void) { + DEBUGASSERT(g_region < CONFIG_ARMV7M_MPU_NREGIONS); return (unsigned int)g_region++; } diff --git a/arch/arm/src/lpc17xx/Make.defs b/arch/arm/src/lpc17xx/Make.defs index b7bf382795..679e51a5f9 100644 --- a/arch/arm/src/lpc17xx/Make.defs +++ b/arch/arm/src/lpc17xx/Make.defs @@ -63,6 +63,10 @@ ifeq ($(CONFIG_ARCH_MEMCPY),y) CMN_ASRCS += up_memcpy.S endif +ifeq ($(CONFIG_NUTTX_KERNEL),y) +CMN_CSRCS += up_mpu.c +endif + ifeq ($(CONFIG_NET),y) ifneq ($(CONFIG_LPC17_ETHERNET),y) CMN_CSRCS += up_etherstub.c @@ -91,6 +95,10 @@ ifeq ($(CONFIG_ARMV7M_CMNVECTOR),y) CHIP_ASRCS += lpc17_vectors.S endif +ifeq ($(CONFIG_NUTTX_KERNEL),y) +CHIP_CSRCS += lpc17_userspace.c lpc17_mpuinit.c +endif + ifeq ($(CONFIG_LPC17_EMC),y) CHIP_CSRCS += lpc17_emc.c endif diff --git a/arch/arm/src/lpc17xx/lpc17_allocateheap.c b/arch/arm/src/lpc17xx/lpc17_allocateheap.c index c49ceed36c..b5cacce27e 100644 --- a/arch/arm/src/lpc17xx/lpc17_allocateheap.c +++ b/arch/arm/src/lpc17xx/lpc17_allocateheap.c @@ -53,6 +53,7 @@ #include "chip/lpc17_memorymap.h" #include "lpc17_emacram.h" #include "lpc17_ohciram.h" +#include "lpc17_mpuinit.h" /**************************************************************************** * Private Definitions @@ -195,11 +196,84 @@ void up_allocate_heap(FAR void **heap_start, size_t *heap_size) { +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) + /* Get the unaligned size of the user-space heap */ + + uintptr_t ubase = (uintptr_t)g_heapbase + CONFIG_MM_KERNEL_HEAPSIZE; + size_t usize = CONFIG_DRAM_END - ubase; + int log2; + + DEBUGASSERT(ubase < (uintptr_t)CONFIG_DRAM_END); + + /* Adjust that size to account for MPU alignment requirements. + * NOTE that there is an implicit assumption that the CONFIG_DRAM_END + * is aligned to the MPU requirement. + */ + + log2 = (int)mpu_log2regionsize(usize); + DEBUGASSERT((CONFIG_DRAM_END & ((1 << log2) - 1)) == 0); + + usize = (1 << log2); + ubase = CONFIG_DRAM_END - usize + + /* Return the user-space heap settings */ + + up_ledon(LED_HEAPALLOCATE); + *heap_start = (FAR void*)ubase; + *heap_size = usize; + + /* Allow user-mode access to the user heap memory */ + + lpc17_mpu_uheap((uintptr_t)ubase, usize); +#else + + /* Return the heap settings */ + up_ledon(LED_HEAPALLOCATE); *heap_start = (FAR void*)g_heapbase; - *heap_size = CONFIG_DRAM_END - g_heapbase; + *heap_size = CONFIG_DRAM_END - g_heapbase; +#endif } +/**************************************************************************** + * Name: up_allocate_kheap + * + * Description: + * For the kernel build (CONFIG_NUTTX_KERNEL=y) with both kernel- and + * user-space heaps (CONFIG_MM_KERNEL_HEAP=y), this function allocates + * (and protects) the kernel-space heap. + * + ****************************************************************************/ + +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) +void up_allocate_kheap(FAR void **heap_start, size_t *heap_size) +{ + /* Get the unaligned size of the user-space heap */ + + uintptr_t ubase = (uintptr_t)g_heapbase + CONFIG_MM_KERNEL_HEAPSIZE; + size_t usize = CONFIG_DRAM_END - ubase; + int log2; + + DEBUGASSERT(ubase < (uintptr_t)CONFIG_DRAM_END); + + /* Adjust that size to account for MPU alignment requirements. + * NOTE that there is an implicit assumption that the CONFIG_DRAM_END + * is aligned to the MPU requirement. + */ + + log2 = (int)mpu_log2regionsize(usize); + DEBUGASSERT((CONFIG_DRAM_END & ((1 << log2) - 1)) == 0); + + usize = (1 << log2); + ubase = CONFIG_DRAM_END - usize + + /* Return the kernel heap settings */ + + *heap_start = (FAR void*)g_heapbase; + *heap_size = ubase - (uintptr_t)g_heapbase; +} +#endif + /************************************************************************ * Name: up_addregion * diff --git a/arch/arm/src/lpc17xx/lpc17_mpuinit.c b/arch/arm/src/lpc17xx/lpc17_mpuinit.c new file mode 100644 index 0000000000..0a90229e75 --- /dev/null +++ b/arch/arm/src/lpc17xx/lpc17_mpuinit.c @@ -0,0 +1,124 @@ +/**************************************************************************** + * arch/arm/src/common/lpc17_mpuinit.c + * + * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name NuttX 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. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#include + +#include + +#include "mpu.h" +#include "lp17_mpuinit.h" + +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_ARMV7M_MPU) + +/**************************************************************************** + * Private Definitions + ****************************************************************************/ + +#ifndef MAX +# define MAX(a,b) a > b ? a : b +#endif + +#ifndef MIN +# define MIN(a,b) a < b ? a : b +#endif + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: lpc17_mpuinitialize + * + * Description: + * Configure the MPU to permit user-space access to only restricted SAM3U + * resources. + * + ****************************************************************************/ + +void lpc17_mpuinitialize(void) +{ + uintptr_t datastart = MIN(USERSPACE->us_datastart, USERSPACE->us_bssstart); + uintptr_t dataend = MAX(USERSPACE->us_dataend, USERSPACE->us_bssend); + + DEBUGASSERT(USERSPACE->us_textend >= USERSPACE->us_textstart && + dataend >= datastart); + + /* Show MPU information */ + + mpu_showtype(); + + /* Configure user flash and SRAM space */ + + mpu_userflash(USERSPACE->us_textstart, + USERSPACE->us_textend - USERSPACE->us_textstart); + + mpu_userintsram(datastart, dataend - datastart); + + /* Then enable the MPU */ + + mpu_control(true, false, true); +} + +/**************************************************************************** + * Name: lpc17_mpu_uheap + * + * Description: + * Map the user-heap region. + * + * This logic may need an extension to handle external SDRAM). + * + ****************************************************************************/ + +void lpc17_mpu_uheap(uintptr_t start, size_t size) +{ + mpu_userintsram(start, size); +} + +#endif /* CONFIG_NUTTX_KERNEL && CONFIG_ARMV7M_MPU */ + diff --git a/arch/arm/src/lpc17xx/lpc17_mpuinit.h b/arch/arm/src/lpc17xx/lpc17_mpuinit.h new file mode 100644 index 0000000000..4d0e6944ff --- /dev/null +++ b/arch/arm/src/lpc17xx/lpc17_mpuinit.h @@ -0,0 +1,90 @@ +/************************************************************************************ + * arch/arm/src/lpc17xx/lpc17_mpuinit.h + * + * Copyright (C) 2013 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name NuttX 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. + * + ************************************************************************************/ + +#ifndef __ARCH_ARM_SRC_LPC17XX_LPC17_MPUINIT_H +#define __ARCH_ARM_SRC_LPC17XX_LPC17_MPUINIT_H + +/************************************************************************************ + * Included Files + ************************************************************************************/ + +#include + +/************************************************************************************ + * Pre-processor Definitions + ************************************************************************************/ + +/************************************************************************************ + * Public Types + ************************************************************************************/ + +/************************************************************************************ + * Public Data + ************************************************************************************/ + +/************************************************************************************ + * Public Functions + ************************************************************************************/ + +/**************************************************************************** + * Name: lpc17_mpuinitialize + * + * Description: + * Configure the MPU to permit user-space access to only unrestricted MCU + * resources. + * + ****************************************************************************/ + +#ifdef CONFIG_NUTTX_KERNEL +void lpc17_mpuinitialize(void); +#else +# define lpc17_mpuinitialize() +#endif + +/**************************************************************************** + * Name: lpc17_mpu_uheap + * + * Description: + * Map the user heap region. + * + ****************************************************************************/ + +#ifdef CONFIG_NUTTX_KERNEL +void lpc17_mpu_uheap(uintptr_t start, size_t size); +#else +# define lpc17_mpu_uheap(start,size) +#endif + +#endif /* __ARCH_ARM_SRC_LPC17XX_LPC17_MPUINIT_H */ diff --git a/arch/arm/src/lpc17xx/lpc17_start.c b/arch/arm/src/lpc17xx/lpc17_start.c index e13abe15c0..e3e4013d09 100644 --- a/arch/arm/src/lpc17xx/lpc17_start.c +++ b/arch/arm/src/lpc17xx/lpc17_start.c @@ -2,7 +2,7 @@ * arch/arm/src/lpc17xx/lpc17_start.c * arch/arm/src/chip/lpc17_start.c * - * Copyright (C) 2010, 2012 Gregory Nutt. All rights reserved. + * Copyright (C) 2010, 2012-2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt * * Redistribution and use in source and binary forms, with or without @@ -52,6 +52,7 @@ #include "lpc17_clockconfig.h" #include "lpc17_lowputc.h" +#include "lpc17_userspace.h" #ifdef CONFIG_ARCH_FPU # include "nvic.h" @@ -230,10 +231,21 @@ void __start(void) #endif showprogress('D'); + /* For the case of the separate user-/kernel-space build, perform whatever + * platform specific initialization of the user memory is required. + * Normally this just means initializing the user space .data and .bss + * segements. + */ + +#ifdef CONFIG_NUTTX_KERNEL + lpc17_userspace(); + showprogress('E'); +#endif + /* Initialize onboard resources */ lpc17_boardinitialize(); - showprogress('E'); + showprogress('F'); /* Then start NuttX */ diff --git a/arch/arm/src/lpc17xx/lpc17_userspace.c b/arch/arm/src/lpc17xx/lpc17_userspace.c new file mode 100644 index 0000000000..ffc935af35 --- /dev/null +++ b/arch/arm/src/lpc17xx/lpc17_userspace.c @@ -0,0 +1,119 @@ +/**************************************************************************** + * arch/arm/src/lpc17xx/lpc17_userspace.c + * + * Copyright (C) 2013 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name NuttX 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. + * + ****************************************************************************/ + +/**************************************************************************** + * Included Files + ****************************************************************************/ + +#include + +#include +#include + +#include + +#include "lpc17_mpuinit.h" +#include "lpc17_userspace.h" + +#ifdef CONFIG_NUTTX_KERNEL + +/**************************************************************************** + * Private Definitions + ****************************************************************************/ + +/**************************************************************************** + * Private Data + ****************************************************************************/ + +/**************************************************************************** + * Private Functions + ****************************************************************************/ + +/**************************************************************************** + * Public Functions + ****************************************************************************/ + +/**************************************************************************** + * Name: lpc17_userspace + * + * Description: + * For the case of the separate user-/kernel-space build, perform whatever + * platform specific initialization of the user memory is required. + * Normally this just means initializing the user space .data and .bss + * segments. + * + ****************************************************************************/ + +void lpc17_userspace(void) +{ + uint8_t *src; + uint8_t *dest; + uint8_t *end; + + /* Clear all of user-space .bss */ + + DEBUGASSERT(USERSPACE->us_bssstart != 0 && USERSPACE->us_bssend != 0 && + USERSPACE->us_bssstart <= USERSPACE->us_bssend); + + dest = (uint8_t*)USERSPACE->us_bssstart; + end = (uint8_t*)USERSPACE->us_bssend; + + while (dest != end) + { + *dest++ = 0; + } + + /* Initialize all of user-space .data */ + + DEBUGASSERT(USERSPACE->us_datasource != 0 && + USERSPACE->us_datastart != 0 && USERSPACE->us_dataend != 0 && + USERSPACE->us_datastart <= USERSPACE->us_dataend); + + src = (uint8_t*)USERSPACE->us_datasource; + dest = (uint8_t*)USERSPACE->us_datastart; + end = (uint8_t*)USERSPACE->us_dataend; + + while (dest != end) + { + *dest++ = *src++; + } + + /* Configure the MPU to permit user-space access to its FLASH and RAM */ + + lpc17_mpuinitialize(); +} + +#endif /* CONFIG_NUTTX_KERNEL */ + diff --git a/arch/arm/src/lpc17xx/lpc17_userspace.h b/arch/arm/src/lpc17xx/lpc17_userspace.h new file mode 100644 index 0000000000..c4d265cc06 --- /dev/null +++ b/arch/arm/src/lpc17xx/lpc17_userspace.h @@ -0,0 +1,77 @@ +/************************************************************************************ + * arch/arm/src/lpc17xx/lpc17_qei.h + * + * Copyright (C) 2013 Gregory Nutt. All rights reserved. + * Author: Gregory Nutt + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. Neither the name NuttX 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. + * + ************************************************************************************/ + +#ifndef __ARCH_ARM_SRC_LPC17XX_LPC17_USERSPACE_H +#define __ARCH_ARM_SRC_LPC17XX_LPC17_USERSPACE_H + +/************************************************************************************ + * Included Files + ************************************************************************************/ + +#include +#include "chip/lpc17_qei.h" + +/************************************************************************************ + * Pre-processor Definitions + ************************************************************************************/ + +/************************************************************************************ + * Public Types + ************************************************************************************/ + +/************************************************************************************ + * Public Data + ************************************************************************************/ + +/************************************************************************************ + * Public Functions + ************************************************************************************/ + +/**************************************************************************** + * Name: lpc17_userspace + * + * Description: + * For the case of the separate user-/kernel-space build, perform whatever + * platform specific initialization of the user memory is required. + * Normally this just means initializing the user space .data and .bss + * segments. + * + ****************************************************************************/ + +#ifdef CONFIG_NUTTX_KERNEL +void lpc17_userspace(void); +#endif + +#endif /* __ARCH_ARM_SRC_LPC17XX_LPC17_USERSPACE_H */ diff --git a/arch/arm/src/sam3u/sam3u_allocateheap.c b/arch/arm/src/sam3u/sam3u_allocateheap.c index 5b5c6b8106..249777d69f 100644 --- a/arch/arm/src/sam3u/sam3u_allocateheap.c +++ b/arch/arm/src/sam3u/sam3u_allocateheap.c @@ -78,68 +78,6 @@ # warning "CONFIG_DRAM_END is before end of SRAM0... not all of SRAM0 used" #endif -#ifdef CONFIG_MM_KERNEL_HEAPSIZE -# if CONFIG_MM_KERNEL_HEAPSIZE < (1 << 5) /* Kernel heap size < 2**5 */ -# define KHEAP_SIZE (1 << 4) /* Use size 2**4 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 6) /* Kernel heap size < 2**6 */ -# define KHEAP_SIZE (1 << 5) /* Use size 2**5 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 7) /* Kernel heap size < 2**7 */ -# define KHEAP_SIZE (1 << 6) /* Use size 2**6 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 8) /* Kernel heap size < 2**8 */ -# define KHEAP_SIZE (1 << 7) /* Use size 2**7 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 9) /* Kernel heap size < 2**9 */ -# define KHEAP_SIZE (1 << 8) /* Use size 2**8 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 10) /* Kernel heap size < 2**10 */ -# define KHEAP_SIZE (1 << 9) /* Use size 2**9 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 11) /* Kernel heap size < 2**11 */ -# define KHEAP_SIZE (1 << 10) /* Use size 2**10 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 12) /* Kernel heap size < 2**12 */ -# define KHEAP_SIZE (1 << 11) /* Use size 2**11 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 13) /* Kernel heap size < 2**13 */ -# define KHEAP_SIZE (1 << 12) /* Use size 2**12 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 14) /* Kernel heap size < 2**14 */ -# define KHEAP_SIZE (1 << 13) /* Use size 2**13 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 15) /* Kernel heap size < 2**15 */ -# define KHEAP_SIZE (1 << 14) /* Use size 2**14 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 16) /* Kernel heap size < 2**16 */ -# define KHEAP_SIZE (1 << 15) /* Use size 2**15 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 17) /* Kernel heap size < 2**17 */ -# define KHEAP_SIZE (1 << 16) /* Use size 2**16 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 18) /* Kernel heap size < 2**18 */ -# define KHEAP_SIZE (1 << 17) /* Use size 2**17 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 19) /* Kernel heap size < 2**19 */ -# define KHEAP_SIZE (1 << 18) /* Use size 2**18 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 20) /* Kernel heap size < 2**20 */ -# define KHEAP_SIZE (1 << 19) /* Use size 2**19 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 21) /* Kernel heap size < 2**21 */ -# define KHEAP_SIZE (1 << 20) /* Use size 2**20 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 22) /* Kernel heap size < 2**22 */ -# define KHEAP_SIZE (1 << 21) /* Use size 2**21 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 23) /* Kernel heap size < 2**23 */ -# define KHEAP_SIZE (1 << 22) /* Use size 2**22 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 24) /* Kernel heap size < 2**24 */ -# define KHEAP_SIZE (1 << 23) /* Use size 2**23 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 25) /* Kernel heap size < 2**25 */ -# define KHEAP_SIZE (1 << 24) /* Use size 2**24 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 26) /* Kernel heap size < 2**26 */ -# define KHEAP_SIZE (1 << 25) /* Use size 2**25 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 27) /* Kernel heap size < 2**27 */ -# define KHEAP_SIZE (1 << 26) /* Use size 2**26 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 28) /* Kernel heap size < 2**28 */ -# define KHEAP_SIZE (1 << 27) /* Use size 2**27 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 29) /* Kernel heap size < 2**29 */ -# define KHEAP_SIZE (1 << 28) /* Use size 2**28 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 30) /* Kernel heap size < 2**30 */ -# define KHEAP_SIZE (1 << 29) /* Use size 2**29 */ -# elif CONFIG_MM_KERNEL_HEAPSIZE < (1 << 31) /* Kernel heap size < 2**31 */ -# define KHEAP_SIZE (1 << 30) /* Use size 2**30 */ -# else -# define KHEAP_SIZE (1 << 31) /* Use size 2**31 */ -# endif - -# define KHEAP_MASK (KHEAP_SIZE - 1) -#endif - /**************************************************************************** * Private Data ****************************************************************************/ @@ -170,35 +108,41 @@ void up_allocate_heap(FAR void **heap_start, size_t *heap_size) { #if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) - uintptr_t kbase = ((uintptr_t)g_heapbase + KHEAP_MASK) & ~KHEAP_MASK; - uintptr_t ubase = kbase + KHEAP_SIZE; + /* Get the unaligned size of the user-space heap */ + + uintptr_t ubase = (uintptr_t)g_heapbase + CONFIG_MM_KERNEL_HEAPSIZE; size_t usize = CONFIG_DRAM_END - ubase; + int log2; DEBUGASSERT(ubase < (uintptr_t)CONFIG_DRAM_END); - /* Return the heap settings */ + /* Adjust that size to account for MPU alignment requirements. + * NOTE that there is an implicit assumption that the CONFIG_DRAM_END + * is aligned to the MPU requirement. + */ + + log2 = (int)mpu_log2regionsize(usize); + DEBUGASSERT((CONFIG_DRAM_END & ((1 << log2) - 1)) == 0); + + usize = (1 << log2); + ubase = CONFIG_DRAM_END - usize + + /* Return the user-space heap settings */ up_ledon(LED_HEAPALLOCATE); *heap_start = (FAR void*)ubase; *heap_size = usize; - /* Allow access to the heap memory */ + /* Allow user-mode access to the user heap memory */ sam3u_mpu_uheap((uintptr_t)ubase, usize); #else - size_t size = CONFIG_DRAM_END - g_heapbase; - /* Return the heap settings */ up_ledon(LED_HEAPALLOCATE); *heap_start = (FAR void*)g_heapbase; - *heap_size = size; - - /* Allow user access to the user heap memory */ - - sam3u_mpu_uheap((uintptr_t)g_heapbase, size); - + *heap_size = CONFIG_DRAM_END - g_heapbase; #endif } @@ -215,14 +159,29 @@ void up_allocate_heap(FAR void **heap_start, size_t *heap_size) #if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_MM_KERNEL_HEAP) void up_allocate_kheap(FAR void **heap_start, size_t *heap_size) { - uintptr_t kbase = ((uintptr_t)g_heapbase + KHEAP_MASK) & ~KHEAP_MASK; + /* Get the unaligned size of the user-space heap */ - DEBUGASSERT((kbase + KHEAP_SIZE) < (uintptr_t)CONFIG_DRAM_END); + uintptr_t ubase = (uintptr_t)g_heapbase + CONFIG_MM_KERNEL_HEAPSIZE; + size_t usize = CONFIG_DRAM_END - ubase; + int log2; - /* Return the heap settings */ + DEBUGASSERT(ubase < (uintptr_t)CONFIG_DRAM_END); - *heap_start = (FAR void*)kbase; - *heap_size = KHEAP_SIZE; + /* Adjust that size to account for MPU alignment requirements. + * NOTE that there is an implicit assumption that the CONFIG_DRAM_END + * is aligned to the MPU requirement. + */ + + log2 = (int)mpu_log2regionsize(usize); + DEBUGASSERT((CONFIG_DRAM_END & ((1 << log2) - 1)) == 0); + + usize = (1 << log2); + ubase = CONFIG_DRAM_END - usize + + /* Return the kernel heap settings */ + + *heap_start = (FAR void*)g_heapbase; + *heap_size = ubase - (uintptr_t)g_heapbase; } #endif diff --git a/arch/arm/src/sam3u/sam3u_internal.h b/arch/arm/src/sam3u/sam3u_internal.h index 14857bcf8a..8953aa0c61 100644 --- a/arch/arm/src/sam3u/sam3u_internal.h +++ b/arch/arm/src/sam3u/sam3u_internal.h @@ -453,7 +453,7 @@ void sam3u_lowsetup(void); * For the case of the separate user-/kernel-space build, perform whatever * platform specific initialization of the user memory is required. * Normally this just means initializing the user space .data and .bss - * segements. + * segments. * ****************************************************************************/ @@ -465,7 +465,7 @@ void sam3u_userspace(void); * Name: sam3u_mpuinitialize * * Description: - * Configure the MPU to permit user-space access to only restricted SAM3U + * Configure the MPU to permit user-space access to only unrestricted SAM3U * resources. * ****************************************************************************/ diff --git a/arch/arm/src/sam3u/sam3u_mpuinit.c b/arch/arm/src/sam3u/sam3u_mpuinit.c index 1e1a564d55..f3e18ad05c 100644 --- a/arch/arm/src/sam3u/sam3u_mpuinit.c +++ b/arch/arm/src/sam3u/sam3u_mpuinit.c @@ -45,7 +45,7 @@ #include "mpu.h" -#ifdef CONFIG_NUTTX_KERNEL +#if defined(CONFIG_NUTTX_KERNEL) && defined(CONFIG_ARMV7M_MPU) /**************************************************************************** * Private Definitions @@ -105,12 +105,12 @@ void sam3u_mpuinitialize(void) } /**************************************************************************** - * Name: sam3u_mpu_uheap and sam3u_mpu_uheap + * Name: sam3u_mpu_uheap * * Description: - * Map a user- or kernel-heap region. + * Map the user-heap region. * - * This logic may need an extension to handle external SRAM). + * This logic may need an extension to handle external SDRAM). * ****************************************************************************/ @@ -119,5 +119,5 @@ void sam3u_mpu_uheap(uintptr_t start, size_t size) mpu_userintsram(start, size); } -#endif /* CONFIG_NUTTX_KERNEL */ +#endif /* CONFIG_NUTTX_KERNEL && CONFIG_ARMV7M_MPU */ diff --git a/arch/arm/src/sam3u/sam3u_start.c b/arch/arm/src/sam3u/sam3u_start.c index aceda2c464..dceb65ab2c 100644 --- a/arch/arm/src/sam3u/sam3u_start.c +++ b/arch/arm/src/sam3u/sam3u_start.c @@ -142,12 +142,13 @@ void __start(void) #ifdef CONFIG_NUTTX_KERNEL sam3u_userspace(); + showprogress('E'); #endif /* Initialize onboard resources */ sam3u_boardinitialize(); - showprogress('E'); + showprogress('F'); /* Then start NuttX */ diff --git a/arch/arm/src/sam3u/sam3u_userspace.c b/arch/arm/src/sam3u/sam3u_userspace.c index 89a2a27ed3..1450e27a9f 100644 --- a/arch/arm/src/sam3u/sam3u_userspace.c +++ b/arch/arm/src/sam3u/sam3u_userspace.c @@ -1,5 +1,5 @@ /**************************************************************************** - * arch/arm/src/common/sam3u_userspace.c + * arch/arm/src/sam3u/sam3u_userspace.c * * Copyright (C) 2011, 2013 Gregory Nutt. All rights reserved. * Author: Gregory Nutt @@ -71,7 +71,7 @@ * For the case of the separate user-/kernel-space build, perform whatever * platform specific initialization of the user memory is required. * Normally this just means initializing the user space .data and .bss - * segements. + * segments. * ****************************************************************************/ diff --git a/arch/arm/src/sam3u/sam3u_vectors.S b/arch/arm/src/sam3u/sam3u_vectors.S index 53e2f636c0..ec0287e343 100644 --- a/arch/arm/src/sam3u/sam3u_vectors.S +++ b/arch/arm/src/sam3u/sam3u_vectors.S @@ -39,6 +39,7 @@ ************************************************************************************************/ #include + #include /************************************************************************************************ @@ -240,13 +241,18 @@ sam3u_common: */ adds r2, r14, #3 /* If R14=0xfffffffd, then r2 == 0 */ - ite ne /* Next two instructions are condition */ + ite ne /* Next two instructions are conditional */ mrsne r1, msp /* R1=The main stack pointer */ mrseq r1, psp /* R1=The process stack pointer */ #else mrs r1, msp /* R1=The main stack pointer */ #endif + /* r1 holds the value of the stack pointer AFTER the excption handling logic + * pushed the various registers onto the stack. Get r2 = the value of the + * stack pointer BEFORE the interrupt modified it. + */ + mov r2, r1 /* R2=Copy of the main/process stack pointer */ add r2, #HW_XCPT_SIZE /* R2=MSP/PSP before the interrupt was taken */ #ifdef CONFIG_ARMV7M_USEBASEPRI @@ -254,6 +260,22 @@ sam3u_common: #else mrs r3, primask /* R3=Current PRIMASK setting */ #endif + +#ifdef CONFIG_ARCH_FPU + /* Skip over the block of memory reserved for floating pointer register save. + * Lazy FPU register saving is used. FPU registers will be saved in this + * block only if a context switch occurs (this means, of course, that the FPU + * cannot be used in interrupt processing). + */ + + sub r1, #(4*SW_FPU_REGS) +#endif + + /* Save the the remaining registers on the stack after the registers pushed + * by the exception handling logic. r2=SP and r3=primask or basepri, r4-r11, + * r14=register values. + */ + #ifdef CONFIG_NUTTX_KERNEL stmdb r1!, {r2-r11,r14} /* Save the remaining registers plus the SP value */ #else @@ -290,17 +312,36 @@ sam3u_common: cmp r0, r1 /* Context switch? */ beq 1f /* Branch if no context switch */ + /* We are returning with a pending context switch. + * + * If the FPU is enabled, then we will need to restore FPU registers. + * This is not done in normal interrupt save/restore because the cost + * is prohibitive. This is only done when switching contexts. A + * consequence of this is that floating point operations may not be + * performed in interrupt handling logic. + * + * Here: + * r0 = Address of the register save area + + * NOTE: It is a requirement that up_restorefpu() preserve the value of + * r0! + */ + +#ifdef CONFIG_ARCH_FPU + bl up_restorefpu /* Restore the FPU registers */ +#endif + /* We are returning with a pending context switch. This case is different * because in this case, the register save structure does not lie on the * stack but, rather, are within a TCB structure. We'll have to copy some * values to the stack. */ - add r1, r0, #SW_XCPT_SIZE /* R1=Address of HW save area in reg array */ + add r1, r0, #SW_XCPT_SIZE /* R1=Address of HW save area in reg array */ ldmia r1, {r4-r11} /* Fetch eight registers in HW save area */ - ldr r1, [r0, #(4*REG_SP)] /* R1=Value of SP before interrupt */ + ldr r1, [r0, #(4*REG_SP)] /* R1=Value of SP before interrupt */ stmdb r1!, {r4-r11} /* Store eight registers in HW save area */ -#ifdef CONFIG_NUTTX_KERNEL +#ifdef CONFIG_NUTTX_KERNEL ldmia r0, {r2-r11,r14} /* Recover R4-R11, r14 + 2 temp values */ #else ldmia r0, {r2-r11} /* Recover R4-R11 + 2 temp values */ @@ -309,13 +350,33 @@ sam3u_common: /* We are returning with no context switch. We simply need to "unwind" * the same stack frame that we created + * + * Here: + * r1 = Address of the return stack (same as r0) */ 1: -#ifdef CONFIG_NUTTX_KERNEL +#ifdef CONFIG_NUTTX_KERNEL ldmia r1!, {r2-r11,r14} /* Recover R4-R11, r14 + 2 temp values */ #else ldmia r1!, {r2-r11} /* Recover R4-R11 + 2 temp values */ #endif + +#ifdef CONFIG_ARCH_FPU + /* Skip over the block of memory reserved for floating pointer register + * save. Then R1 is the address of the HW save area + */ + + add r1, #(4*SW_FPU_REGS) +#endif + + /* Set up to return from the exception + * + * Here: + * r1 = Address on the target thread's stack position at the start of + * the registers saved by hardware + * r3 = primask or basepri + * r4-r11 = restored register values + */ 2: #ifdef CONFIG_NUTTX_KERNEL /* The EXC_RETURN value will be 0xfffffff9 (privileged thread) or 0xfffffff1