void bsp_pretasking_hook(void) { void *heapStart; unsigned long heapSize = (unsigned long)_HeapSize; unsigned long ramSpace; heapStart = (void *) ((unsigned long)_WorkspaceBase + BSP_Configuration.work_space_size); ramSpace = (unsigned long)_RamBase + _M68k_Ramsize - (unsigned long)heapStart; /* * Can't use 'if(heapSize==0)' because the compiler "knows" that nothing * can have an address of 0 and proceeds to optimize-away the test. */ if (heapSize < 10) heapSize = ramSpace; else if (heapSize > ramSpace) rtems_fatal_error_occurred (('H'<<24) | ('E'<<16) | ('A'<<8) | 'P'); bsp_libc_init(heapStart, heapSize, 0); #ifdef RTEMS_DEBUG rtems_debug_enable( RTEMS_DEBUG_ALL_MASK ); #endif }
void bsp_pretasking_hook(void) { /* * These are assigned addresses in the linkcmds file for the BSP. This * approach is better than having these defined as manifest constants and * compiled into the kernel, but it is still not ideal when dealing with * multiprocessor configuration in which each board as a different memory * map. A better place for defining these symbols might be the makefiles. * Consideration should also be given to developing an approach in which * the kernel and the application can be linked and burned into ROM * independently of each other. */ extern unsigned char _HeapStart; extern unsigned char _HeapEnd; bsp_libc_init( &_HeapStart, &_HeapEnd - &_HeapStart, 0 ); #ifdef STACK_CHECKER_ON /* * Initialize the stack bounds checker * We can either turn it on here or from the app. */ Stack_check_Initialize(); #endif #ifdef RTEMS_DEBUG rtems_debug_enable( RTEMS_DEBUG_ALL_MASK ); #endif }
void bsp_pretasking_hook(void) { bsp_libc_init(&HeapStart, (char *)&HeapEnd - (char *)&HeapStart, 0); #ifdef RTEMS_DEBUG rtems_debug_enable( RTEMS_DEBUG_ALL_MASK ); #endif }
void bsp_pretasking_hook(void) { void *heapStart; unsigned long heapSize; extern int WorkspaceBase; heapStart = (void *) ((unsigned long)&WorkspaceBase + BSP_Configuration.work_space_size); if ( (unsigned long) heapStart > (256 * 1024) ) rtems_fatal_error_occurred (('H'<<24) | ('E'<<16) | ('A'<<8) | 'P'); heapSize = (256 * 1024) - (unsigned long)(heapStart); bsp_libc_init(heapStart, heapSize, 0); #ifdef RTEMS_DEBUG rtems_debug_enable( RTEMS_DEBUG_ALL_MASK ); #endif }
/* * 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 ) { if ( !rtems_unified_work_area && heap_start == BSP_BOOTCARD_HEAP_USES_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; } } bsp_libc_init(heap_start, heap_size, 0); }
/*-------------------------------------------------------------------------+ | Function: bsp_pretasking_hook | Description: BSP pretasking hook. Called just before drivers are | initialized. Used to setup libc and install any BSP | extensions. NOTE: Must not use libc (to do io) from here, | since drivers are not yet initialized. | Global Variables: None. | Arguments: None. | Returns: Nothing. +--------------------------------------------------------------------------*/ void bsp_pretasking_hook(void) { unsigned32 heap_start; unsigned32 heap_size; /* * Set up the heap. */ heap_start = free_mem_start; heap_size = free_mem_end - free_mem_start; /* call rtems lib init - malloc stuff */ bsp_libc_init((void *)heap_start, heap_size, 0); #ifdef RTEMS_DEBUG rtems_debug_enable(RTEMS_DEBUG_ALL_MASK); #endif /* RTEMS_DEBUG */ } /* bsp_pretasking_hook */
/* * bsp_pretasking_hook * * Called when RTEMS initialization is complete but before interrupts and * tasking are enabled. Used to setup libc and install any BSP extensions. * * Must not use libc (to do io) from here, since drivers are not yet * initialized. * * Installed in the rtems_cpu_table defined in * rtems/c/src/exec/score/cpu/powerpc/rtems/new-exceptions/cpu.h by main() * below. Called from rtems_initialize_executive() defined in * rtems/c/src/exec/sapi/src/init.c * * Input parameters: NONE * * Output parameters: NONE * * Return values: NONE */ void bsp_pretasking_hook(void) { /* * These are assigned addresses in the linkcmds file for the BSP. This * approach is better than having these defined as manifest constants and * compiled into the kernel, but it is still not ideal when dealing with * multiprocessor configuration in which each board as a different memory * map. A better place for defining these symbols might be the makefiles. * Consideration should also be given to developing an approach in which * the kernel and the application can be linked and burned into ROM * independently of each other. */ uint8_t *_HeapStart = (uint8_t *)BSP_Configuration.work_space_start + BSP_Configuration.work_space_size; extern uint8_t _HeapEnd[]; bsp_libc_init( _HeapStart, _HeapEnd - _HeapStart, 0 ); #ifdef RTEMS_DEBUG rtems_debug_enable( RTEMS_DEBUG_ALL_MASK ); #endif }
void bsp_pretasking_hook(void) { uint32_t heap_start; uint32_t heap_size; /* * Set up the heap. It uses all free SDRAM except that reserved * for non-cached uses. */ heap_start = free_mem_start; /* heap_size = (free_mem_end - heap_start - MEM_NOCACHE_SIZE); */ heap_size = 0x200000; bsp_libc_init((void *)heap_start, heap_size, 0); #ifdef RTEMS_DEBUG rtems_debug_enable(RTEMS_DEBUG_ALL_MASK); #endif /* RTEMS_DEBUG */ } /* bsp_pretasking_hook */
/* * 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. */ void boot_card( const char *cmdline ) { rtems_interrupt_level bsp_isr_level; /* * Make sure interrupts are disabled. */ (void) bsp_isr_level; rtems_interrupt_local_disable( bsp_isr_level ); bsp_boot_cmdline = cmdline; /* * Invoke Board Support Package initialization routine written in C. */ bsp_start(); /* * Initialize the RTEMS Workspace and the C Program Heap. */ bsp_work_area_initialize(); /* * Initialize RTEMS data structures */ rtems_initialize_data_structures(); /* * Initialize the C library for those BSPs using the shared * framework. */ bsp_libc_init(); /* * Let the BSP 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 NOW!!! We will not return to here!!! * *************************************************************** ***************************************************************/ }