forked from Imagelibrary/rtems
d1e85c41ea
PR1797/bsps * shared/bootcard.c: Fixed a typo (in code, not comment) which I introduced with the last change.
287 lines
8.1 KiB
C
287 lines
8.1 KiB
C
/**
|
|
* @file
|
|
*
|
|
* @ingroup bsp_bootcard
|
|
*
|
|
* @brief Standard system startup.
|
|
*/
|
|
|
|
/*
|
|
* This is the C entry point for ALL RTEMS BSPs. It is invoked
|
|
* from the assembly language initialization file usually called
|
|
* start.S. It provides the framework for the BSP initialization
|
|
* sequence. The basic flow of initialization is:
|
|
*
|
|
* + start.S: basic CPU setup (stack, zero BSS)
|
|
* + boot_card
|
|
* + bspstart.c: bsp_start - more advanced initialization
|
|
* + obtain information on BSP memory and allocate RTEMS Workspace
|
|
* + rtems_initialize_data_structures
|
|
* + allocate memory to C Program Heap
|
|
* + initialize C Library and C Program Heap
|
|
* + bsp_pretasking_hook
|
|
* + if defined( RTEMS_DEBUG )
|
|
* - rtems_debug_enable( RTEMS_DEBUG_ALL_MASK );
|
|
* + rtems_initialize_before_drivers
|
|
* + bsp_predriver_hook
|
|
* + rtems_initialize_device_drivers
|
|
* - all device drivers
|
|
* + bsp_postdriver_hook
|
|
* + rtems_initialize_start_multitasking
|
|
* - 1st task executes C++ global constructors
|
|
* .... appplication runs ...
|
|
* - exit
|
|
* + back to here eventually
|
|
* + bspclean.c: bsp_cleanup
|
|
*
|
|
* This style of initialization ensures that the C++ global
|
|
* constructors are executed after RTEMS is initialized.
|
|
* Thanks to Chris Johns <cjohns@plessey.com.au> for the idea
|
|
* to move C++ global constructors into the first task.
|
|
*
|
|
* COPYRIGHT (c) 1989-2008.
|
|
* On-Line Applications Research Corporation (OAR).
|
|
*
|
|
* The license and distribution terms for this file may be
|
|
* found in the file LICENSE in this distribution or at
|
|
* http://www.rtems.com/license/LICENSE.
|
|
*
|
|
* $Id$
|
|
*/
|
|
|
|
#include <rtems.h>
|
|
|
|
#include <bsp/bootcard.h>
|
|
#include <rtems/bspIo.h>
|
|
#include <rtems/malloc.h>
|
|
|
|
#ifdef CONFIGURE_MALLOC_BSP_SUPPORTS_SBRK
|
|
#include <unistd.h> /* for sbrk() */
|
|
#endif
|
|
|
|
/*
|
|
* At most a single pointer to the cmdline for those target
|
|
* short on memory and not supporting a command line.
|
|
*/
|
|
const char *bsp_boot_cmdline;
|
|
|
|
/*
|
|
* Are we using a single heap for the RTEMS Workspace and C Program Heap?
|
|
*/
|
|
extern bool rtems_unified_work_area;
|
|
|
|
/*
|
|
* These are the prototypes and helper routines which are used
|
|
* when the BSP lets the framework handle RAM allocation between
|
|
* the RTEMS Workspace and C Program Heap.
|
|
*/
|
|
static void bootcard_bsp_libc_helper(
|
|
void *work_area_start,
|
|
uintptr_t work_area_size,
|
|
void *heap_start,
|
|
uintptr_t heap_size,
|
|
uintptr_t sbrk_amount
|
|
)
|
|
{
|
|
if ( heap_start == BSP_BOOTCARD_HEAP_USES_WORK_AREA ) {
|
|
if ( ! rtems_unified_work_area ) {
|
|
uintptr_t work_space_size = rtems_configuration_get_work_space_size();
|
|
|
|
heap_start = (char *) work_area_start + work_space_size;
|
|
|
|
if (heap_size == BSP_BOOTCARD_HEAP_SIZE_DEFAULT) {
|
|
uintptr_t heap_size_default = work_area_size - work_space_size;
|
|
|
|
heap_size = heap_size_default;
|
|
}
|
|
} else {
|
|
heap_start = work_area_start;
|
|
if (heap_size == BSP_BOOTCARD_HEAP_SIZE_DEFAULT) {
|
|
heap_size = work_area_size;
|
|
}
|
|
}
|
|
}
|
|
|
|
bsp_libc_init(heap_start, heap_size, sbrk_amount);
|
|
}
|
|
|
|
/*
|
|
* This is the initialization framework routine that weaves together
|
|
* calls to RTEMS and the BSP in the proper sequence to initialize
|
|
* the system while maximizing shared code and keeping BSP code in C
|
|
* as much as possible.
|
|
*/
|
|
int boot_card(
|
|
const char *cmdline
|
|
)
|
|
{
|
|
rtems_interrupt_level bsp_isr_level;
|
|
void *work_area_start = NULL;
|
|
uintptr_t work_area_size = 0;
|
|
void *heap_start = NULL;
|
|
uintptr_t heap_size = 0;
|
|
uintptr_t sbrk_amount = 0;
|
|
|
|
/*
|
|
* Special case for PowerPC: The interrupt disable mask is stored in SPRG0.
|
|
* It must be valid before we can use rtems_interrupt_disable().
|
|
*/
|
|
#ifdef PPC_INTERRUPT_DISABLE_MASK_DEFAULT
|
|
ppc_interrupt_set_disable_mask( PPC_INTERRUPT_DISABLE_MASK_DEFAULT );
|
|
#endif /* PPC_INTERRUPT_DISABLE_MASK_DEFAULT */
|
|
|
|
/*
|
|
* Make sure interrupts are disabled.
|
|
*/
|
|
rtems_interrupt_disable( bsp_isr_level );
|
|
|
|
bsp_boot_cmdline = cmdline;
|
|
|
|
/*
|
|
* Invoke Board Support Package initialization routine written in C.
|
|
*/
|
|
bsp_start();
|
|
|
|
/*
|
|
* Find out where the block of memory the BSP will use for
|
|
* the RTEMS Workspace and the C Program Heap is.
|
|
*/
|
|
bsp_get_work_area(&work_area_start, &work_area_size,
|
|
&heap_start, &heap_size);
|
|
|
|
#ifdef CONFIGURE_MALLOC_BSP_SUPPORTS_SBRK
|
|
/* This routine may reduce the work area size with the
|
|
* option to extend it later via sbrk(). If the application
|
|
* was configured w/o CONFIGURE_MALLOC_BSP_SUPPORTS_SBRK then
|
|
* omit this step.
|
|
*/
|
|
if ( rtems_malloc_sbrk_helpers ) {
|
|
sbrk_amount = bsp_sbrk_init(work_area_start, &work_area_size);
|
|
if ( work_area_size < Configuration.work_space_size && sbrk_amount > 0 ) {
|
|
/* Need to use sbrk right now */
|
|
uintptr_t sbrk_now;
|
|
|
|
sbrk_now = (Configuration.work_space_size - work_area_size) / sbrk_amount;
|
|
sbrk( sbrk_now * sbrk_amount );
|
|
}
|
|
}
|
|
#else
|
|
if ( rtems_malloc_sbrk_helpers ) {
|
|
printk("Configuration error!\n"
|
|
"Application was configured with CONFIGURE_MALLOC_BSP_SUPPORTS_SBRK\n"
|
|
"but BSP was configured w/o sbrk support\n");
|
|
bsp_cleanup();
|
|
return -1;
|
|
}
|
|
#endif
|
|
|
|
if ( work_area_size <= Configuration.work_space_size ) {
|
|
printk(
|
|
"bootcard: work space too big for work area: %p > %p\n",
|
|
(void *) Configuration.work_space_size,
|
|
(void *) work_area_size
|
|
);
|
|
bsp_cleanup();
|
|
return -1;
|
|
}
|
|
|
|
if ( rtems_unified_work_area ) {
|
|
Configuration.work_space_start = work_area_start;
|
|
Configuration.work_space_size = work_area_size;
|
|
} else {
|
|
Configuration.work_space_start = work_area_start;
|
|
}
|
|
|
|
#if (BSP_DIRTY_MEMORY == 1)
|
|
memset( work_area_start, 0xCF, work_area_size );
|
|
#endif
|
|
|
|
/*
|
|
* Initialize RTEMS data structures
|
|
*/
|
|
rtems_initialize_data_structures();
|
|
|
|
/*
|
|
* Initialize the C library for those BSPs using the shared
|
|
* framework.
|
|
*/
|
|
bootcard_bsp_libc_helper(
|
|
work_area_start,
|
|
work_area_size,
|
|
heap_start,
|
|
heap_size,
|
|
sbrk_amount
|
|
);
|
|
|
|
/*
|
|
* All BSP to do any required initialization now that RTEMS
|
|
* data structures are initialized. In older BSPs or those
|
|
* which do not use the shared framework, this is the typical
|
|
* time when the C Library is initialized so malloc()
|
|
* can be called by device drivers. For BSPs using the shared
|
|
* framework, this routine can be empty.
|
|
*/
|
|
bsp_pretasking_hook();
|
|
|
|
/*
|
|
* If debug is enabled, then enable all dynamic RTEMS debug
|
|
* capabilities.
|
|
*
|
|
* NOTE: Most debug features are conditionally compiled in
|
|
* or enabled via configure time plugins.
|
|
*/
|
|
#ifdef RTEMS_DEBUG
|
|
rtems_debug_enable( RTEMS_DEBUG_ALL_MASK );
|
|
#endif
|
|
|
|
/*
|
|
* Let RTEMS perform initialization it requires before drivers
|
|
* are allowed to be initialized.
|
|
*/
|
|
rtems_initialize_before_drivers();
|
|
|
|
/*
|
|
* Execute BSP specific pre-driver hook. Drivers haven't gotten
|
|
* to initialize yet so this is a good chance to initialize
|
|
* buses, spurious interrupt handlers, etc..
|
|
*
|
|
* NOTE: Many BSPs do not require this handler and use the
|
|
* shared stub.
|
|
*/
|
|
bsp_predriver_hook();
|
|
|
|
/*
|
|
* Initialize all device drivers.
|
|
*/
|
|
rtems_initialize_device_drivers();
|
|
|
|
/*
|
|
* Invoke the postdriver hook. This normally opens /dev/console
|
|
* for use as stdin, stdout, and stderr.
|
|
*/
|
|
bsp_postdriver_hook();
|
|
|
|
/*
|
|
* Complete initialization of RTEMS and switch to the first task.
|
|
* Global C++ constructors will be executed in the context of that task.
|
|
*/
|
|
rtems_initialize_start_multitasking();
|
|
|
|
/***************************************************************
|
|
***************************************************************
|
|
* APPLICATION RUNS HERE!!! When it shuts down, we return!!! *
|
|
***************************************************************
|
|
***************************************************************
|
|
*/
|
|
|
|
/*
|
|
* Perform any BSP specific shutdown actions which are written in C.
|
|
*/
|
|
bsp_cleanup();
|
|
|
|
/*
|
|
* Now return to the start code.
|
|
*/
|
|
return 0;
|
|
}
|