Changeset d4886a06 in rtems


Ignore:
Timestamp:
Jul 24, 2008, 2:52:55 PM (11 years ago)
Author:
Thomas Doerfler <Thomas.Doerfler@…>
Branches:
4.10, 4.11, 4.9, master
Children:
de3864e
Parents:
075d817
Message:

Changed bsp_get_workarea() to bsp_get_work_area() and
added support for an optional separate heap area.

Location:
c/src/lib/libbsp
Files:
1 added
25 edited

Legend:

Unmodified
Added
Removed
  • c/src/lib/libbsp/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * Makefile.am: Install shared/include/bootcard.h.
     4
    152008-01-16      Ralf Corsepius <ralf.corsepius@rtems.org>
    26
  • c/src/lib/libbsp/Makefile.am

    r075d817 rd4886a06  
    3333EXTRA_DIST += shared/gdbstub/rtems-stub-glue.c
    3434
     35include_bspdir = $(includedir)/bsp
     36include_bsp_HEADERS = shared/include/bootcard.h
     37
     38include $(srcdir)/preinstall.am
    3539include $(top_srcdir)/automake/subdirs.am
    3640include $(top_srcdir)/automake/local.am
  • c/src/lib/libbsp/arm/nds/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * startup/start.c: Changed bsp_get_workarea() to bsp_get_work_area() and
     4        added support for an optional separate heap area.
     5
    162008-05-20      Joel Sherrill <joel.sherrill@oarcorp.com>
    27
  • c/src/lib/libbsp/arm/nds/startup/start.c

    r075d817 rd4886a06  
    1313
    1414#include <bsp.h>
     15#include <bsp/bootcard.h>
    1516#include <nds.h>
    1617
     
    2526 *  Heap.
    2627 */
    27 void bsp_get_workarea(
    28   void   **workarea_base,
    29   size_t  *workarea_size,
    30   size_t  *requested_heap_size
     28void bsp_get_work_area(
     29  void   **work_area_start,
     30  size_t  *work_area_size,
     31  void   **heap_start,
     32  size_t  *heap_size
    3133)
    3234{
     
    3436  extern uint8_t __ewram_end;
    3537
    36   *workarea_base       = &_end;
    37   *workarea_size       = (void *)&__ewram_end - (void *)&_end;
    38   *requested_heap_size = 0;
     38  *work_area_start       = &_end;
     39  *work_area_size       = (void *)&__ewram_end - (void *)&_end;
     40  *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     41  *heap_size = BSP_BOOTCARD_HEAP_SIZE_DEFAULT;
    3942}
    4043
  • c/src/lib/libbsp/m68k/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * shared/m68kbspgetworkarea.c: Changed bsp_get_workarea() to
     4        bsp_get_work_area() and added support for an optional separate heap
     5        area.
     6
    172008-07-16      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • c/src/lib/libbsp/m68k/shared/m68kbspgetworkarea.c

    r075d817 rd4886a06  
    11/*
    2  *  This routine is an implementation of the bsp_get_workarea()
     2 *  This routine is an implementation of the bsp_get_work_area()
    33 *  that can be used by all m68k BSPs following linkcmds conventions
    44 *  regarding heap, stack, and workspace allocation.
     
    1515
    1616#include <bsp.h>
     17#include <bsp/bootcard.h>
    1718
    1819/*
     
    2122 *  Heap.
    2223 */
    23 void bsp_get_workarea(
    24   void   **workarea_base,
    25   size_t  *workarea_size,
    26   size_t  *requested_heap_size
     24void bsp_get_work_area(
     25  void   **work_area_start,
     26  size_t  *work_area_size,
     27  void   **heap_start,
     28  size_t  *heap_size
    2729)
    2830{
     
    3234  extern char         _RamSize[];
    3335
    34   *workarea_base       = _WorkspaceBase;
    35   *workarea_size       = (unsigned long)_RamBase + (unsigned long) _RamSize -
     36  *work_area_start       = _WorkspaceBase;
     37  *work_area_size       = (unsigned long)_RamBase + (unsigned long) _RamSize -
    3638       (unsigned long)_WorkspaceBase;
    37   *requested_heap_size = (size_t) _HeapSize;
     39  *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     40  *heap_size = (size_t) _HeapSize;
    3841}
  • c/src/lib/libbsp/mips/jmr3904/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * startup/bspstart.c: Changed bsp_get_workarea() to
     4        bsp_get_work_area() and added support for an optional separate heap
     5        area.
     6
    172008-05-15      Joel Sherrill <joel.sherrill@OARcorp.com>
    28
  • c/src/lib/libbsp/mips/jmr3904/startup/bspstart.c

    r075d817 rd4886a06  
    1616
    1717#include <bsp.h>
     18#include <bsp/bootcard.h>
    1819
    1920/*
     
    2223 *  Heap.
    2324 */
    24 void bsp_get_workarea(
    25   void   **workarea_base,
    26   size_t  *workarea_size,
    27   size_t  *requested_heap_size
     25void bsp_get_work_area(
     26  void   **work_area_start,
     27  size_t  *work_area_size,
     28  void   **heap_start,
     29  size_t  *heap_size
    2830)
    2931{
     
    3133  extern int end;
    3234
    33   *workarea_base       = &WorkspaceBase;
    34   *workarea_size       = (void *)&end - (void *)&WorkspaceBase;
    35   *requested_heap_size = 0;
     35  *work_area_start       = &WorkspaceBase;
     36  *work_area_size       = (void *)&end - (void *)&WorkspaceBase;
     37  *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     38  *heap_size = BSP_BOOTCARD_HEAP_SIZE_DEFAULT;
    3639}
    3740
  • c/src/lib/libbsp/powerpc/gen83xx/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * configure.ac, include/bsp.h, startup/bspstart.c,
     4        startup/linkcmds.base: Support RAM allocation via bootcard.
     5
    162008-07-18      Sebastian Huber <sebastian.huber@embedded-brains.de>
    27
  • c/src/lib/libbsp/powerpc/gen83xx/configure.ac

    r075d817 rd4886a06  
    3232AC_CONFIG_FILES([Makefile])
    3333
     34RTEMS_BSP_BOOTCARD_HANDLES_RAM_ALLOCATION
     35
    3436RTEMS_PPC_EXCEPTIONS
    3537
  • c/src/lib/libbsp/powerpc/gen83xx/include/bsp.h

    r075d817 rd4886a06  
    6666LINKER_SYMBOL( bsp_interrupt_stack_end);
    6767LINKER_SYMBOL( bsp_interrupt_stack_size);
    68 LINKER_SYMBOL( bsp_interrupt_stack_pointer);
    69 
    70 LINKER_SYMBOL( bsp_workspace_start);
     68
     69LINKER_SYMBOL( bsp_work_area_start);
    7170
    7271LINKER_SYMBOL( IMMRBAR);
  • c/src/lib/libbsp/powerpc/gen83xx/startup/bspstart.c

    r075d817 rd4886a06  
    3030
    3131#include <bsp.h>
     32#include <bsp/bootcard.h>
    3233#include <bsp/irq-generic.h>
    3334#include <bsp/ppc_exc_bspsupp.h>
     
    5152/* Configuration parameters for clock driver, ... */
    5253uint32_t bsp_clicks_per_usec;
    53 
    54 static char *BSP_heap_start, *BSP_heap_end;
    5554
    5655/*
     
    8887void bsp_pretasking_hook( void)
    8988{
    90         /* Initialize libc including the heap */
    91         bsp_libc_init( BSP_heap_start, BSP_heap_end - BSP_heap_start, 0);
     89        /* Do noting */
     90}
     91
     92void bsp_get_work_area( void **work_area_start, size_t *work_area_size, void **heap_start, size_t *heap_size)
     93{
     94#ifdef HAS_UBOOT
     95        char *ram_end = (char *) mpc83xx_uboot_board_info.bi_memstart + mpc83xx_uboot_board_info.bi_memsize;
     96#else /* HAS_UBOOT */
     97        char *ram_end = bsp_ram_end;
     98#endif /* HAS_UBOOT */
     99
     100        *work_area_start = bsp_work_area_start;
     101        *work_area_size = ram_end - bsp_work_area_start;
     102        *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     103        *heap_size = BSP_BOOTCARD_HEAP_SIZE_DEFAULT;
    92104}
    93105
     
    99111        uint32_t interrupt_stack_start = (uint32_t) bsp_interrupt_stack_start;
    100112        uint32_t interrupt_stack_size = (uint32_t) bsp_interrupt_stack_size;
    101 
    102         size_t workspace_size = rtems_configuration_get_work_space_size();
    103113
    104114        /*
     
    123133        rtems_cache_enable_data();
    124134#endif
    125 
    126         /* Clear the workspace */
    127         Configuration.do_zero_of_workspace = 0;
    128         mpc83xx_zero_4( bsp_workspace_start, workspace_size);
    129 
    130         /* Workspace start */
    131         Configuration.work_space_start = bsp_workspace_start;
    132 
    133         /* Heap area */
    134         BSP_heap_start = (char *) Configuration.work_space_start + workspace_size;
    135 #ifdef HAS_UBOOT
    136         BSP_heap_end = mpc83xx_uboot_board_info.bi_memstart + mpc83xx_uboot_board_info.bi_memsize;
    137 #else /* HAS_UBOOT */
    138         BSP_heap_end = bsp_ram_end;
    139 #endif /* HAS_UBOOT */
    140135
    141136        /*
  • c/src/lib/libbsp/powerpc/gen83xx/startup/linkcmds.base

    r075d817 rd4886a06  
    269269        bsp_interrupt_stack_end = bsp_interrupt_stack_start + 32k;
    270270        bsp_interrupt_stack_size = bsp_interrupt_stack_end - bsp_interrupt_stack_start;
    271         bsp_interrupt_stack_pointer = bsp_interrupt_stack_end - 16;
    272271        . = bsp_interrupt_stack_end;
    273272
    274273        /*
    275          * BSP: Workspace start
    276          */
    277         bsp_workspace_start = .;
     274         * BSP: Work area start
     275         */
     276        bsp_work_area_start = .;
    278277       
    279278        /* Stabs debugging sections.  */
  • c/src/lib/libbsp/powerpc/mpc55xxevb/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * configure.ac, startup/bspstart.c: Support RAM allocation via
     4        bootcard.
     5
    162008-07-17      Ralf Corsépius <ralf.corsepius@rtems.org>
    27
  • c/src/lib/libbsp/powerpc/mpc55xxevb/configure.ac

    r075d817 rd4886a06  
    4848include/bspopts.h])
    4949
     50RTEMS_BSP_BOOTCARD_HANDLES_RAM_ALLOCATION
     51
    5052RTEMS_PPC_EXCEPTIONS
    5153
  • c/src/lib/libbsp/powerpc/mpc55xxevb/startup/bspstart.c

    r075d817 rd4886a06  
    3030
    3131#include <bsp.h>
     32#include <bsp/bootcard.h>
    3233#include <bsp/irq.h>
    3334#include <bsp/irq-generic.h>
     
    7980}
    8081
     82void bsp_get_work_area( void **work_area_start, size_t *work_area_size, void **heap_start, size_t *heap_size)
     83{
     84        *work_area_start = bsp_section_bss_end;
     85        *work_area_size = bsp_ram_end - 2 * MPC55XX_INTERRUPT_STACK_SIZE - bsp_section_bss_end;
     86        *heap_start = bsp_external_ram_start;
     87        *heap_size = (size_t) bsp_external_ram_size;
     88}
     89
    8190void bsp_pretasking_hook()
    8291{
    83         uint32_t heap_start = bsp_external_ram_start;
    84         uint32_t heap_size = bsp_external_ram_size;
    85 
    86         bsp_libc_init( heap_start, heap_size, 0);
    87 
    8892#ifdef STACK_CHECKER_ON
    8993        Stack_check_Initialize();
    90 #endif
    91 
    92 #ifdef RTEMS_DEBUG
    93         rtems_debug_enable( RTEMS_DEBUG_ALL_MASK );
    9494#endif
    9595}
     
    168168        ppc_cpu_revision_t myCpuRevision;
    169169
    170         uint32_t ram_start = bsp_ram_start;
    171         uint32_t ram_end = bsp_ram_end;
    172         uint32_t interrupt_stack_start = ram_end - 2 * MPC55XX_INTERRUPT_STACK_SIZE;
     170        uint32_t interrupt_stack_start = bsp_ram_end - 2 * MPC55XX_INTERRUPT_STACK_SIZE;
    173171        uint32_t interrupt_stack_size = MPC55XX_INTERRUPT_STACK_SIZE;
    174         uint32_t work_space_start = bsp_section_bss_end;
    175         uint32_t work_space_end = work_space_start + rtems_configuration_get_work_space_size();
    176172
    177173        /* ESCI pad configuration */
     
    181177        DEBUG_PRINT( "BSP start ...\n");
    182178
    183         /* Memory layout */
    184 
    185         Configuration.work_space_start = work_space_start;
    186 
    187179        DEBUG_PRINT( "System clock          : %i\n", mpc55xx_get_system_clock());
    188         DEBUG_PRINT( "Memory start          : 0x%08x\n", ram_start);
    189         DEBUG_PRINT( "Memory end            : 0x%08x\n", ram_end);
    190         DEBUG_PRINT( "Memory size           : 0x%08x\n", ram_end - ram_start);
    191         DEBUG_PRINT( "Work space start      : 0x%08x\n", work_space_start);
    192         DEBUG_PRINT( "Work space end        : 0x%08x\n", work_space_end);
    193         DEBUG_PRINT( "Work space size       : 0x%08x\n", work_space_end - work_space_start);
     180        DEBUG_PRINT( "Memory start          : 0x%08x\n", bsp_ram_start);
     181        DEBUG_PRINT( "Memory end            : 0x%08x\n", bsp_ram_end);
     182        DEBUG_PRINT( "Memory size           : 0x%08x\n", bsp_ram_end - bsp_ram_start);
    194183        DEBUG_PRINT( "Interrupt stack start : 0x%08x\n", interrupt_stack_start);
    195184        DEBUG_PRINT( "Interrupt stack end   : 0x%08x\n", interrupt_stack_start + interrupt_stack_size);
    196185        DEBUG_PRINT( "Interrupt stack size  : 0x%08x\n", interrupt_stack_size);
    197 
    198         if (work_space_end > interrupt_stack_start) {
    199                 BSP_panic( "Not enough memory for the work space");
    200         }
    201186       
    202187        /*
  • c/src/lib/libbsp/powerpc/psim/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * startup/bspstart.c: Changed bsp_get_workarea() to
     4        bsp_get_work_area() and added support for an optional separate heap
     5        area.
     6
    172008-07-18      Joel Sherrill <joel.sherrill@oarcorp.com>
    28
  • c/src/lib/libbsp/powerpc/psim/startup/bspstart.c

    r075d817 rd4886a06  
    1919#include <bsp.h>
    2020#include <bsp/irq.h>
     21#include <bsp/bootcard.h>
    2122#include <rtems/libio.h>
    2223#include <rtems/libcsupport.h>
     
    7172 *  Heap.
    7273 */
    73 void bsp_get_workarea(
    74   void   **workarea_base,
    75   size_t  *workarea_size,
    76   size_t  *requested_heap_size
     74void bsp_get_work_area(
     75  void   **work_area_start,
     76  size_t  *work_area_size,
     77  void   **heap_start,
     78  size_t  *heap_size
    7779)
    7880{
    79   *workarea_base       = &end;
    80   *workarea_size       = (void *)&RAM_END - (void *)&end;
    81   *requested_heap_size = 0;
     81  *work_area_start       = &end;
     82  *work_area_size       = (void *)&RAM_END - (void *)&end;
     83  *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     84  *heap_size = BSP_BOOTCARD_HEAP_SIZE_DEFAULT;
    8285}
    8386
  • c/src/lib/libbsp/shared/ChangeLog

    r075d817 rd4886a06  
    112008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * include/bootcard.h: New file.
     4
     5        * bootcard.c: Changed bsp_get_workarea() to bsp_get_work_area() and
     6        added support for an optional separate heap area.
     7
     8        * bsppretaskinghook.c: Cleanup.  Include bootcard.h.
    29
    310        * include/irq-generic.h, src/irq-generic.c, src/irq-legacy.c: Support
  • c/src/lib/libbsp/shared/bootcard.c

    r075d817 rd4886a06  
    4444 */
    4545
    46 #include <stddef.h>
    47 #include <stdint.h>
    48 
    4946#include <rtems.h>
    5047
    51 #include <bspopts.h>  /* for BSP_BOOTCARD_HANDLES_RAM_ALLOCATION */
     48#include <bsp/bootcard.h>
    5249
    5350/*
     
    5552 */
    5653char *rtems_progname;
    57 
    58 /*
    59  *  Prototypes of external routines
    60  */
    61 extern void bsp_start( void );
    62 extern void bsp_cleanup( void );
    63 extern void bsp_pretasking_hook(void);
    64 extern void bsp_libc_init( void *, uint32_t, int );
    65 extern void bsp_predriver_hook(void);
    66 extern void bsp_postdriver_hook(void);
    6754
    6855/*
     
    7259 */
    7360#if defined(BSP_BOOTCARD_HANDLES_RAM_ALLOCATION)
    74   extern void bsp_get_workarea( void **, size_t *, size_t *);
    75 
    76   void bootcard_bsp_libc_helper(
    77     void   *workarea_base,
    78     size_t  workarea_size,
    79     size_t  requested_heap_size
     61  static void bootcard_bsp_libc_helper(
     62    void   *work_area_start,
     63    size_t  work_area_size,
     64    void   *heap_start,
     65    size_t  heap_size
    8066  )
    8167  {
    82     uint32_t     heap_start;
    83     uint32_t     heap_size;
    84 
    85     heap_start = (uint32_t) workarea_base;
    86     if (heap_start & (CPU_ALIGNMENT-1))
    87       heap_start = (heap_start + CPU_ALIGNMENT) & ~(CPU_ALIGNMENT-1);
    88 
    89     if ( requested_heap_size == 0 ) {
    90       heap_size = Configuration.work_space_start - workarea_base;
    91       heap_size &= 0xfffffff0;  /* keep it as a multiple of 16 bytes */
    92     } else {
    93       heap_size = requested_heap_size;
     68    if (heap_start == BSP_BOOTCARD_HEAP_USES_WORK_AREA) {
     69      /* Use the work area start as heap start */
     70      heap_start = work_area_start;
     71
     72      /* Ensure proper alignement */
     73      if ((uintptr_t) heap_start & (CPU_ALIGNMENT - 1)) {
     74        heap_start = (void *) (((uintptr_t) heap_start + CPU_ALIGNMENT) & ~(CPU_ALIGNMENT - 1));
     75      }
     76
     77      /*
     78       * Use the free space from the start of the work area up to the work
     79       * space start as heap area.
     80       */
     81      if (heap_size == BSP_BOOTCARD_HEAP_SIZE_DEFAULT) {
     82        heap_size = (char *) Configuration.work_space_start
     83          - (char *) work_area_start;
     84
     85        /* Keep it as a multiple of 16 bytes */
     86        heap_size &= 0xfffffff0;
     87      }
    9488    }
    9589
    96     bsp_libc_init((void *) heap_start, heap_size, 0);
     90    bsp_libc_init( heap_start, (uint32_t) heap_size, 0);
    9791  }
    9892#endif
     
    116110  rtems_interrupt_level bsp_isr_level;
    117111  #if defined(BSP_BOOTCARD_HANDLES_RAM_ALLOCATION)
    118     void   *workarea_base;
    119     size_t  workarea_size;
    120     size_t  heap_size;
     112    void   *work_area_start = NULL;
     113    size_t  work_area_size = 0;
     114    void   *heap_start = NULL;
     115    size_t  heap_size = 0;
    121116  #endif
    122117
     
    157152  #if defined(BSP_BOOTCARD_HANDLES_RAM_ALLOCATION)
    158153  {
    159     unsigned char     *work_space_start;
    160 
    161     bsp_get_workarea( &workarea_base, &workarea_size, &heap_size );
    162 
    163     work_space_start = workarea_base + workarea_size
     154    void *work_space_start = NULL;
     155
     156    bsp_get_work_area(
     157      &work_area_start,
     158      &work_area_size,
     159      &heap_start,
     160      &heap_size
     161    );
     162
     163    work_space_start = (char *) work_area_start + work_area_size
    164164      - rtems_configuration_get_work_space_size();
    165165
    166     if ( work_space_start <= (unsigned char *)workarea_base ) {
     166    if ((uintptr_t) work_space_start <= (uintptr_t) work_area_start) {
    167167      printk( "bootcard: Not enough RAM!!!\n" );
    168168      bsp_cleanup();
     
    173173
    174174    #if (BSP_DIRTY_MEMORY == 1)
    175       memset(workarea_base, 0xCF,  workarea_size);
     175      memset( work_area_start, 0xCF,  work_area_size);
    176176    #endif
    177177  }
     
    194194   */
    195195  #if defined(BSP_BOOTCARD_HANDLES_RAM_ALLOCATION)
    196     bootcard_bsp_libc_helper( workarea_base, workarea_size, heap_size );
     196    bootcard_bsp_libc_helper(
     197      work_area_start,
     198      work_area_size,
     199      heap_start,
     200      heap_size
     201    );
    197202  #endif
    198203
  • c/src/lib/libbsp/shared/bsppretaskinghook.c

    r075d817 rd4886a06  
    22 *  This is a shared BSP pretasking hook which does nothing.
    33 *  If all the BSP needs to do is initialize the C library,
    4  *  then it can rely on bootcard.c and provide bsp_get_workarea().
     4 *  then it can rely on bootcard.c and provide bsp_get_work_area().
    55 *
    66 *  COPYRIGHT (c) 1989-2008.
     
    1414 */
    1515
    16 #include <rtems.h>
    17 #include <rtems/libio.h>
    18 #include <fcntl.h>
     16#include <bsp/bootcard.h>
    1917
    2018void bsp_pretasking_hook(void)
    2119{
     20  /* Do nothing */
    2221}
  • c/src/lib/libbsp/sparc/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * shared/startup/bspstart.c: Changed bsp_get_workarea() to
     4        bsp_get_work_area() and added support for an optional separate heap
     5        area.
     6
    172008-05-15      Joel Sherrill <joel.sherrill@OARcorp.com>
    28
  • c/src/lib/libbsp/sparc/leon3/ChangeLog

    r075d817 rd4886a06  
     12008-07-24      Sebastian Huber <sebastian.huber@embedded-brains.de>
     2
     3        * startup/bspstart.c: Changed bsp_get_workarea() to
     4        bsp_get_work_area() and added support for an optional separate heap
     5        area.
     6
    172008-05-15      Joel Sherrill <joel.sherrill@OARcorp.com>
    28
  • c/src/lib/libbsp/sparc/leon3/startup/bspstart.c

    r075d817 rd4886a06  
    2525
    2626#include <bsp.h>
     27#include <bsp/bootcard.h>
    2728#include <rtems/bspIo.h>
    2829
     
    7576 *  Heap.
    7677 */
    77 void bsp_get_workarea(
    78   void   **workarea_base,
    79   size_t  *workarea_size,
    80   size_t  *requested_heap_size
     78void bsp_get_work_area(
     79  void   **work_area_start,
     80  size_t  *work_area_size,
     81  void   **heap_start,
     82  size_t  *heap_size
    8183)
    8284{
     
    8688  #define STACK_SIZE (16 * 1024)
    8789
    88   *workarea_base       = &end;
    89   *workarea_size       = (void *)rdb_start - (void *)&end - STACK_SIZE;
    90   *requested_heap_size = 0;
     90  *work_area_start       = &end;
     91  *work_area_size       = (void *)rdb_start - (void *)&end - STACK_SIZE;
     92  *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     93  *heap_size = BSP_BOOTCARD_HEAP_SIZE_DEFAULT;
    9194}
    9295
  • c/src/lib/libbsp/sparc/shared/bspstart.c

    r075d817 rd4886a06  
    2323
    2424#include <bsp.h>
     25#include <bsp/bootcard.h>
    2526#include <rtems/libio.h>
    2627#include <rtems/libcsupport.h>
     
    6667 *  Heap.
    6768 */
    68 void bsp_get_workarea(
    69   void   **workarea_base,
    70   size_t  *workarea_size,
    71   size_t  *requested_heap_size
     69void bsp_get_work_area(
     70  void   **work_area_start,
     71  size_t  *work_area_size,
     72  void   **heap_start,
     73  size_t  *heap_size
    7274)
    7375{
     
    7779  #define STACK_SIZE (16 * 1024)
    7880
    79   *workarea_base       = &end;
    80   *workarea_size       = (void *)rdb_start - (void *)&end - STACK_SIZE;
    81   *requested_heap_size = 0;
     81  *work_area_start       = &end;
     82  *work_area_size       = (void *)rdb_start - (void *)&end - STACK_SIZE;
     83  *heap_start = BSP_BOOTCARD_HEAP_USES_WORK_AREA;
     84  *heap_size = BSP_BOOTCARD_HEAP_SIZE_DEFAULT;
    8285}
    8386
Note: See TracChangeset for help on using the changeset viewer.