source: rtems/cpukit/sapi/include/confdefs.h @ d8b74dbe

4.104.11
Last change on this file since d8b74dbe was d8b74dbe, checked in by Chris Johns <chrisj@…>, on Apr 28, 2009 at 6:39:24 AM

2009-04-28 Chris Johns <chrisj@…>

  • sapi/include/confdefs.h: Add a prototype for Init with C linkage and define Init task command line arguments if confdefs.h provides an Init entry point.
  • Property mode set to 100644
File size: 68.9 KB
Line 
1/**
2 * @file rtems/confdefs.h
3 *
4 *  This include file contains the configuration table template that will
5 *  be instantiated by an application based on the setting of a number
6 *  of macros.  The macros are documented in the Configuring a System
7 *  chapter of the Classic API User's Guide
8 *
9 *  The model is to estimate the memory required for each configured item
10 *  and sum those estimates.  The estimate can be too high or too low for
11 *  a variety of reasons:
12 *
13 *  Reasons estimate is too high:
14 *    + FP contexts (not all tasks are FP)
15 *
16 *  Reasons estimate is too low:
17 *    + stacks greater than minimum size
18 *    + messages
19 *    + application must account for device driver resources
20 *    + application must account for add-on library resource requirements
21 *
22 *  NOTE:  Eventually this may be able to take into account some of
23 *         the above.  This procedure has evolved from just enough to
24 *         support the RTEMS Test Suites into something that can be
25 *         used remarkably reliably by most applications.
26 */
27 
28/*
29 *  COPYRIGHT (c) 1989-2008.
30 *  On-Line Applications Research Corporation (OAR).
31 *
32 *  The license and distribution terms for this file may be
33 *  found in the file LICENSE in this distribution or at
34 *  http://www.rtems.com/license/LICENSE.
35 *
36 *  $Id$
37 */
38
39#ifndef __CONFIGURATION_TEMPLATE_h
40#define __CONFIGURATION_TEMPLATE_h
41
42/*
43 * Include the executive's configuration
44 */
45#include <rtems/score/cpuopts.h>
46#include <rtems/score/apimutex.h>
47
48#ifdef __cplusplus
49extern "C" {
50#endif
51
52extern rtems_initialization_tasks_table Initialization_tasks[];
53extern rtems_driver_address_table       Device_drivers[];
54extern rtems_configuration_table        Configuration;
55#if defined(RTEMS_MULTIPROCESSING)
56  extern rtems_multiprocessing_table      Multiprocessing_configuration;
57#endif
58#ifdef RTEMS_POSIX_API
59  extern posix_api_configuration_table    Configuration_POSIX_API;
60#endif
61#ifdef RTEMS_ITRON_API
62  extern itron_api_configuration_table    Configuration_ITRON_API;
63#endif
64
65/**
66 *  This macro determines whether the RTEMS reentrancy support for
67 *  the Newlib C Library is enabled.
68 */
69#if (defined(RTEMS_NEWLIB) && !defined(CONFIGURE_DISABLE_NEWLIB_REENTRANCY))
70  #define CONFIGURE_NEWLIB_EXTENSION 1
71#else
72  #define CONFIGURE_NEWLIB_EXTENSION 0
73#endif
74
75
76#include <rtems/libio.h>
77
78#ifdef CONFIGURE_INIT
79rtems_libio_init_functions_t rtems_libio_init_helper = 
80    #ifdef CONFIGURE_APPLICATION_DISABLE_FILESYSTEM
81    NULL;
82    #else
83    rtems_libio_init;
84    #endif
85
86rtems_libio_supp_functions_t rtems_libio_supp_helper = 
87    #ifdef CONFIGURE_APPLICATION_DISABLE_FILESYSTEM
88    NULL;
89    #else
90    open_dev_console;
91    #endif
92
93rtems_fs_init_functions_t    rtems_fs_init_helper = 
94    #ifdef CONFIGURE_APPLICATION_DISABLE_FILESYSTEM
95    NULL;
96    #else
97    rtems_filesystem_initialize;
98    #endif
99#endif
100
101
102#ifdef CONFIGURE_APPLICATION_DISABLE_FILESYSTEM
103  #define CONFIGURE_HAS_OWN_MOUNT_TABLE
104#endif
105
106/**
107 *  This macro defines the number of POSIX file descriptors allocated
108 *  and managed by libio.  These are the "integer" file descriptors that
109 *  are used by calls like open(2) and read(2).
110 */
111#ifndef CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS
112  #define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 3
113#endif
114
115/**
116 *  From the number of file descriptors, we can determine how many
117 *  semaphores the implementation will require.
118 */
119#define CONFIGURE_LIBIO_SEMAPHORES \
120  (CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS + 1)
121
122#ifdef CONFIGURE_INIT
123  /**
124   *  When instantiating the configuration tables, this variable is
125   *  initialized to specify the maximum number of file descriptors.
126   */
127  uint32_t rtems_libio_number_iops = CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS;
128#endif
129
130/**
131 *  This macro determines if termios is disabled by this application.
132 *  This only means that resources will not be reserved.  If you end
133 *  up using termios, it will fail.
134 */
135#ifdef CONFIGURE_TERMIOS_DISABLED
136  #define CONFIGURE_TERMIOS_SEMAPHORES 0
137#else
138  /**
139   *  This macro specifies the number of serial or PTY ports that will
140   *  use termios.
141   */
142  #ifndef CONFIGURE_NUMBER_OF_TERMIOS_PORTS
143  #define CONFIGURE_NUMBER_OF_TERMIOS_PORTS 1
144  #endif
145
146  /**
147   *  This macro reserves the number of semaphores required by termios
148   *  based upon the number of communication ports that will use it.
149   */
150  #define CONFIGURE_TERMIOS_SEMAPHORES \
151    ((CONFIGURE_NUMBER_OF_TERMIOS_PORTS * 4) + 1)
152#endif
153
154/**
155 *  This macro specifies the number of PTYs that can be concurrently
156 *  active.
157 */
158#ifndef CONFIGURE_MAXIMUM_PTYS
159  #define CONFIGURE_MAXIMUM_PTYS 0
160#endif
161
162/**
163 *  This variable contains the maximum number of PTYs that can be
164 *  concurrently active.
165 */
166#ifdef CONFIGURE_INIT
167  int rtems_telnetd_maximum_ptys = CONFIGURE_MAXIMUM_PTYS;
168#else
169  extern int rtems_telnetd_maximum_ptys;
170#endif
171
172#ifdef CONFIGURE_INIT
173  #ifdef CONFIGURE_APPLICATION_DISABLE_FILESYSTEM
174    extern uint32_t rtems_device_table_size;
175    #define CONFIGURE_MEMORY_FOR_DEVFS  0
176  #elif defined(CONFIGURE_USE_DEVFS_AS_BASE_FILESYSTEM)
177    #ifndef CONFIGURE_MAXIMUM_DEVICES
178      #define CONFIGURE_MAXIMUM_DEVICES 4
179    #endif
180    #include <rtems/devfs.h>
181    uint32_t rtems_device_table_size = CONFIGURE_MAXIMUM_DEVICES;
182    #define CONFIGURE_MEMORY_FOR_DEVFS _Configure_Object_RAM(CONFIGURE_MAXIMUM_DEVICES, sizeof (rtems_device_name_t))
183  #else
184    #define CONFIGURE_MEMORY_FOR_DEVFS  0
185  #endif
186#endif
187
188/*
189 *  Mount Table Configuration
190 */
191#include <rtems/imfs.h>
192
193/**
194 *  This specifies the number of bytes per block for files within
195 *  the IMFS.  There are a maximum number of blocks per file so
196 *  this dictates the maximum size of a file.  This has to be balanced
197 *  with the unused portion of each block that might be wasted.
198 */
199#ifndef CONFIGURE_IMFS_MEMFILE_BYTES_PER_BLOCK
200  #define CONFIGURE_IMFS_MEMFILE_BYTES_PER_BLOCK \
201                    IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
202#endif
203#ifdef CONFIGURE_INIT
204  int imfs_rq_memfile_bytes_per_block = CONFIGURE_IMFS_MEMFILE_BYTES_PER_BLOCK;
205#endif /* CONFIGURE_INIT */
206
207#ifdef CONFIGURE_INIT
208  /**
209   *  This disables the inclusion of pipe support in the full IMFS.
210   */
211  #if !defined(CONFIGURE_USE_DEVFS_AS_BASE_FILESYSTEM)
212    #if defined(CONFIGURE_PIPES_ENABLED)
213      bool rtems_pipe_configured = true;
214    #else
215      bool rtems_pipe_configured = false;
216    #endif
217  #endif
218
219  #ifndef CONFIGURE_HAS_OWN_MOUNT_TABLE
220    const rtems_filesystem_mount_table_t configuration_mount_table = {
221      #ifdef CONFIGURE_USE_IMFS_AS_BASE_FILESYSTEM
222        &IMFS_ops,
223      #elif defined(CONFIGURE_USE_DEVFS_AS_BASE_FILESYSTEM)
224        &devFS_ops,
225      #else  /* using miniIMFS as base filesystem */
226        &miniIMFS_ops,
227      #endif
228      RTEMS_FILESYSTEM_READ_WRITE,
229      NULL,
230      NULL
231    };
232
233    const rtems_filesystem_mount_table_t
234        *rtems_filesystem_mount_table = &configuration_mount_table;
235    const int rtems_filesystem_mount_table_size = 1;
236  #endif
237#endif
238
239/*
240 *  STACK_CHECER_ON was still available in 4.9 so give a warning for now.
241 */
242#if defined(STACK_CHECKER_ON)
243  #define CONFIGURE_STACK_CHECKER_ENABLED
244  #warning "STACK_CHECKER_ON deprecated -- use CONFIGURE_STACK_CHECKER_ENABLED"
245#endif
246 
247/**
248 *  This configures the stack checker user extension.
249 */
250#ifdef CONFIGURE_STACK_CHECKER_ENABLED
251  #define CONFIGURE_STACK_CHECKER_EXTENSION 1
252#else
253  #define CONFIGURE_STACK_CHECKER_EXTENSION 0
254#endif
255
256/**
257 *  @brief Maximum Priority configuration
258 *
259 *  This configures the maximum priority value that
260 *  a task may have.
261 *
262 *  By reducing the number of priorities in a system,
263 *  the amount of RAM required by RTEMS can be significantly
264 *  reduced.  RTEMS allocates a Chain_Control structure per
265 *  priority and this structure contains 3 pointers.  So
266 *  the default is (256 * 12) = 3K on 32-bit architectures.
267 *
268 *  This must be one less than a power of 2 between
269 *  4 and 256.  Valid values along with the application
270 *  priority levels and memory saved when pointers are
271 *  32-bits in size are:
272 *
273 *    + 3,  2 application priorities, 3024 bytes saved
274 *    + 7, 5 application priorities, 2976 bytes saved
275 *    + 15, 13 application priorities, 2880 bytes saved
276 *    + 31, 29 application priorities, 2688 bytes saved
277 *    + 63, 61 application priorities, 2304 bytes saved
278 *    + 127, 125 application priorities, 1536 bytes saved
279 *    + 255, 253 application priorities, 0 bytes saved
280 *
281 *  It is specified in terms of Classic API
282 *  priority values.
283 */
284#ifndef CONFIGURE_MAXIMUM_PRIORITY
285  #define CONFIGURE_MAXIMUM_PRIORITY PRIORITY_DEFAULT_MAXIMUM
286#endif
287
288/*
289 *  If you said the IDLE task was going to do application initialization
290 *  and didn't override the IDLE body, then something is amiss.
291 */
292#if (defined(CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION) && \
293     !defined(CONFIGURE_IDLE_TASK_BODY))
294  #error "CONFIGURE_ERROR: You did not override the IDLE task body."
295#endif
296
297/**
298 *  @brief Idle task body configuration
299 *
300 *  There is a default IDLE thread body provided by RTEMS which
301 *  has the possibility of being CPU specific.  There may be a
302 *  BSP specific override of the RTEMS default body and in turn,
303 *  the application may override and provide its own.
304 */
305#ifndef CONFIGURE_IDLE_TASK_BODY
306  #if defined(BSP_IDLE_TASK_BODY)
307    #define CONFIGURE_IDLE_TASK_BODY BSP_IDLE_TASK_BODY
308  #elif (CPU_PROVIDES_IDLE_THREAD_BODY == TRUE)
309    #define CONFIGURE_IDLE_TASK_BODY _CPU_Thread_Idle_body
310  #else
311    #define CONFIGURE_IDLE_TASK_BODY _Thread_Idle_body
312  #endif
313#endif
314
315/**
316 *  By default, use the minimum stack size requested by this port.
317 */
318#ifndef CONFIGURE_MINIMUM_TASK_STACK_SIZE
319  #define CONFIGURE_MINIMUM_TASK_STACK_SIZE CPU_STACK_MINIMUM_SIZE
320#endif
321
322/**
323 *  @brief Idle task stack size configuration
324 *
325 *  By default, the IDLE task will have a stack of minimum size.
326 *  The BSP or application may override this value.
327 */
328#ifndef CONFIGURE_IDLE_TASK_STACK_SIZE
329  #ifdef BSP_IDLE_TASK_STACK_SIZE
330    #define CONFIGURE_IDLE_TASK_STACK_SIZE BSP_IDLE_TASK_STACK_SIZE
331  #else
332    #define CONFIGURE_IDLE_TASK_STACK_SIZE CONFIGURE_MINIMUM_TASK_STACK_SIZE
333  #endif
334#endif
335
336/**
337 *  @brief Interrupt stack size configuration
338 *
339 *  By default, the interrupt stack will be of minimum size.
340 *  The BSP or application may override this value.
341 */
342#ifndef CONFIGURE_INTERRUPT_STACK_SIZE
343  #ifdef BSP_INTERRUPT_STACK_SIZE
344    #define CONFIGURE_INTERRUPT_STACK_SIZE BSP_INTERRUPT_STACK_SIZE
345  #else
346    #define CONFIGURE_INTERRUPT_STACK_SIZE CONFIGURE_MINIMUM_TASK_STACK_SIZE
347  #endif
348#endif
349
350/**
351 *  This reserves memory for the interrupt stack if it is to be allocated
352 *  by RTEMS rather than the BSP.
353 *
354 *  @todo Try to get to the point where all BSPs support allocating the
355 *        memory from the Workspace.
356 */
357#if (CPU_ALLOCATE_INTERRUPT_STACK == 0)
358  #define CONFIGURE_INTERRUPT_STACK_MEMORY 0
359#else
360  #define CONFIGURE_INTERRUPT_STACK_MEMORY \
361     _Configure_From_workspace( CONFIGURE_INTERRUPT_STACK_SIZE )
362#endif
363
364/**
365 *  Configure the very much optional task stack allocator
366 */
367#ifndef CONFIGURE_TASK_STACK_ALLOCATOR
368  #define CONFIGURE_TASK_STACK_ALLOCATOR NULL
369#endif
370
371/**
372 *  Configure the very much optional task stack deallocator
373 */
374#ifndef CONFIGURE_TASK_STACK_DEALLOCATOR
375  #define CONFIGURE_TASK_STACK_DEALLOCATOR NULL
376#endif
377
378/**
379 *  Should the RTEMS Workspace and C Program Heap be cleared automatically
380 *  at system start up?
381 */
382#ifndef CONFIGURE_ZERO_WORKSPACE_AUTOMATICALLY
383  #ifdef BSP_ZERO_WORKSPACE_AUTOMATICALLY
384    #define CONFIGURE_ZERO_WORKSPACE_AUTOMATICALLY \
385            BSP_ZERO_WORKSPACE_AUTOMATICALLY
386  #else
387    #define CONFIGURE_ZERO_WORKSPACE_AUTOMATICALLY FALSE
388  #endif
389#endif
390
391/*
392 *  RTEMS Malloc configuration
393 */
394
395#include <rtems/malloc.h>
396
397#ifdef CONFIGURE_INIT
398  /**
399   *  By default, RTEMS uses separate heaps for the RTEMS Workspace and
400   *  the C Program Heap.  On many BSPs, these can be optionally
401   *  combined provided one larger memory pool. This is particularly
402   *  useful in combination with the unlimited objects configuration.
403   */
404  #ifdef CONFIGURE_UNIFIED_WORK_AREAS
405    #include <rtems/score/wkspace.h>
406    Heap_Control  *RTEMS_Malloc_Heap = &_Workspace_Area;
407    bool           rtems_unified_work_area = true;
408  #else
409    Heap_Control   RTEMS_Malloc_Area;
410    Heap_Control  *RTEMS_Malloc_Heap = &RTEMS_Malloc_Area;
411    bool           rtems_unified_work_area = false;
412  #endif
413#endif
414
415#ifdef CONFIGURE_INIT
416  /**
417   *  This configures the malloc family statistics to be available.
418   *  By default only function call counts are kept.
419   */
420  rtems_malloc_statistics_functions_t *rtems_malloc_statistics_helpers =
421    #ifndef CONFIGURE_MALLOC_STATISTICS
422      NULL;
423    #else
424      &rtems_malloc_statistics_helpers_table;
425    #endif
426#endif
427
428#ifdef CONFIGURE_INIT
429  /**
430   *  This configures the sbrk() support for the malloc family.
431   *  By default it is assumed that the BSP provides all available
432   *  RAM to the malloc family implementation so sbrk()'ing to get
433   *  more memory would always fail anyway.
434   */
435  rtems_malloc_sbrk_functions_t *rtems_malloc_sbrk_helpers =
436    #ifndef CONFIGURE_MALLOC_BSP_SUPPORTS_SBRK
437      NULL;
438    #else
439      &rtems_malloc_sbrk_helpers_table;
440    #endif
441#endif
442
443#ifdef CONFIGURE_INIT
444  /**
445   *  This configures the malloc family plugin which dirties memory
446   *  allocated.  This is helpful for finding unitialized data structure
447   *  problems.
448   */
449  rtems_malloc_dirtier_t *rtems_malloc_dirty_helper =
450    #if defined(CONFIGURE_MALLOC_DIRTY)
451      rtems_malloc_dirty_memory;
452    #else
453      NULL;
454    #endif
455#endif
456
457/**
458 *  This is a helper macro used in calculations in this file.  It is used
459 *  to noted when an element is allocated from the RTEMS Workspace and adds
460 *  a factor to account for heap overhead plus an alignment factor that
461 *  may be applied.
462 */
463#define _Configure_From_workspace(_size) \
464  (ssize_t)((_size) + (2 * sizeof(uint32_t)) + CPU_ALIGNMENT)
465
466/**
467 *  Do not use the unlimited bit as part of the multiplication
468 *  for memory usage.
469 */
470#define _Configure_Max_Objects(_max) \
471  ((_max) & ~RTEMS_UNLIMITED_OBJECTS)
472
473/**
474 *  This macro accounts for how memory for a set of configured objects is
475 *  allocated from the Executive Workspace. 
476 *
477 *  NOTE: It does NOT attempt to address the more complex case of unlimited
478 *        objects.
479 */
480#define _Configure_Object_RAM(_number, _size) \
481  ( _Configure_From_workspace(_Configure_Max_Objects(_number) * (_size)) + \
482    _Configure_From_workspace( \
483      ((_Configure_Max_Objects(_number) + 1) * sizeof(Objects_Control *)) + \
484      (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) \
485    ) \
486  )
487
488/*
489 *  Default User Initialization Task Table.  This table guarantees that
490 *  one user initialization table is defined.
491 */
492
493#ifdef CONFIGURE_RTEMS_INIT_TASKS_TABLE
494
495#ifdef CONFIGURE_HAS_OWN_INIT_TASK_TABLE
496
497/*
498 *  The user is defining their own table information and setting the
499 *  appropriate variables.
500 */
501
502#else
503
504#ifndef CONFIGURE_INIT_TASK_NAME
505  #define CONFIGURE_INIT_TASK_NAME          rtems_build_name('U', 'I', '1', ' ')
506#endif
507
508#ifndef CONFIGURE_INIT_TASK_STACK_SIZE
509  #define CONFIGURE_INIT_TASK_STACK_SIZE    CONFIGURE_MINIMUM_TASK_STACK_SIZE
510#endif
511
512#ifndef CONFIGURE_INIT_TASK_PRIORITY
513  #define CONFIGURE_INIT_TASK_PRIORITY      1
514#endif
515
516#ifndef CONFIGURE_INIT_TASK_ATTRIBUTES
517  #define CONFIGURE_INIT_TASK_ATTRIBUTES    RTEMS_DEFAULT_ATTRIBUTES
518#endif
519
520#ifndef CONFIGURE_INIT_TASK_ENTRY_POINT
521  #ifdef __cplusplus
522  extern "C" {
523  #endif
524    rtems_task Init (rtems_task_argument );
525  #ifdef __cplusplus
526  }
527  #endif
528  #define CONFIGURE_INIT_TASK_ENTRY_POINT   Init
529  extern const char* bsp_boot_cmdline;
530  #define CONFIGURE_INIT_TASK_ARGUMENTS     ((rtems_task_argument) &bsp_boot_cmdline)
531#endif
532
533#ifndef CONFIGURE_INIT_TASK_INITIAL_MODES
534  #define CONFIGURE_INIT_TASK_INITIAL_MODES RTEMS_NO_PREEMPT
535#endif
536
537#ifndef CONFIGURE_INIT_TASK_ARGUMENTS
538  #define CONFIGURE_INIT_TASK_ARGUMENTS     0
539#endif
540
541#ifdef CONFIGURE_INIT
542  rtems_initialization_tasks_table Initialization_tasks[] = {
543    { CONFIGURE_INIT_TASK_NAME,
544      CONFIGURE_INIT_TASK_STACK_SIZE,
545      CONFIGURE_INIT_TASK_PRIORITY,
546      CONFIGURE_INIT_TASK_ATTRIBUTES,
547      CONFIGURE_INIT_TASK_ENTRY_POINT,
548      CONFIGURE_INIT_TASK_INITIAL_MODES,
549      CONFIGURE_INIT_TASK_ARGUMENTS
550    }
551  };
552#endif
553
554#define CONFIGURE_INIT_TASK_TABLE Initialization_tasks
555
556#define CONFIGURE_INIT_TASK_TABLE_SIZE \
557  sizeof(CONFIGURE_INIT_TASK_TABLE) / sizeof(rtems_initialization_tasks_table)
558
559#endif    /* CONFIGURE_HAS_OWN_INIT_TASK_TABLE */
560
561#else     /* CONFIGURE_RTEMS_INIT_TASKS_TABLE */
562
563#define CONFIGURE_INIT_TASK_TABLE      NULL
564#define CONFIGURE_INIT_TASK_TABLE_SIZE 0
565#define CONFIGURE_INIT_TASK_STACK_SIZE 0
566
567#endif
568
569/*
570 *  Default Device Driver Table.  Each driver needed by the test is explicitly
571 *  choosen by that test.  There is always a null driver entry.
572 */
573
574#define NULL_DRIVER_TABLE_ENTRY \
575 { NULL, NULL, NULL, NULL, NULL, NULL }
576
577#ifdef CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
578  #include <rtems/console.h>
579#endif
580
581#ifdef CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
582  #include <rtems/clockdrv.h>
583#endif
584
585#ifdef CONFIGURE_APPLICATION_NEEDS_TIMER_DRIVER
586  #include <rtems/timerdrv.h>
587#endif
588
589#ifdef CONFIGURE_APPLICATION_NEEDS_RTC_DRIVER
590  #include <rtems/rtc.h>
591#endif
592
593#ifdef CONFIGURE_APPLICATION_NEEDS_WATCHDOG_DRIVER
594  #include <rtems/watchdogdrv.h>
595#endif
596
597#ifdef CONFIGURE_APPLICATION_NEEDS_STUB_DRIVER
598  #include <rtems/devnull.h>
599#endif
600
601#ifdef CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
602  /* the ide driver needs the ATA driver */
603  #ifndef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
604    #define CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
605  #endif
606  #include <libchip/ide_ctrl.h>
607#endif
608
609#ifdef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
610  #include <libchip/ata.h>
611#endif
612
613#ifndef CONFIGURE_HAS_OWN_DEVICE_DRIVER_TABLE
614
615#ifdef CONFIGURE_INIT
616  rtems_driver_address_table Device_drivers[] = {
617    #ifdef CONFIGURE_BSP_PREREQUISITE_DRIVERS
618      CONFIGURE_BSP_PREREQUISITE_DRIVERS,
619    #endif
620    #ifdef CONFIGURE_APPLICATION_PREREQUISITE_DRIVERS
621      CONFIGURE_APPLICATION_PREREQUISITE_DRIVERS,
622    #endif
623    #ifdef CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
624      CONSOLE_DRIVER_TABLE_ENTRY,
625    #endif
626    #ifdef CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
627      CLOCK_DRIVER_TABLE_ENTRY,
628    #endif
629    #ifdef CONFIGURE_APPLICATION_NEEDS_RTC_DRIVER
630      RTC_DRIVER_TABLE_ENTRY,
631    #endif
632    #ifdef CONFIGURE_APPLICATION_NEEDS_WATCHDOG_DRIVER
633      WATCHDOG_DRIVER_TABLE_ENTRY,
634    #endif
635    #ifdef CONFIGURE_APPLICATION_NEEDS_STUB_DRIVER
636      DEVNULL_DRIVER_TABLE_ENTRY,
637    #endif
638    #ifdef CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER
639      IDE_CONTROLLER_DRIVER_TABLE_ENTRY,
640    #endif
641    #ifdef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
642      ATA_DRIVER_TABLE_ENTRY,
643    #endif
644    #ifdef CONFIGURE_APPLICATION_EXTRA_DRIVERS
645      CONFIGURE_APPLICATION_EXTRA_DRIVERS,
646    #endif
647    #ifdef CONFIGURE_APPLICATION_NEEDS_NULL_DRIVER
648      NULL_DRIVER_TABLE_ENTRY
649    #elif !defined(CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER) && \
650        !defined(CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER) && \
651        !defined(CONFIGURE_APPLICATION_NEEDS_RTC_DRIVER) && \
652        !defined(CONFIGURE_APPLICATION_NEEDS_STUB_DRIVER) && \
653        !defined(CONFIGURE_APPLICATION_NEEDS_IDE_DRIVER) && \
654        !defined(CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER) && \
655        !defined(CONFIGURE_APPLICATION_EXTRA_DRIVERS)
656      NULL_DRIVER_TABLE_ENTRY
657    #endif
658  };
659#endif
660
661#endif  /* CONFIGURE_HAS_OWN_DEVICE_DRIVER_TABLE */
662
663/*
664 *  Default the number of drivers per node.  This value may be
665 *  overridden by the user.
666 */
667
668#define CONFIGURE_NUMBER_OF_DRIVERS \
669  ((sizeof(Device_drivers) / sizeof(rtems_driver_address_table)))
670
671/**
672 *  This specifies the maximum number of device drivers that
673 *  can be installed in the system at one time.  It must account
674 *  for both the statically and dynamically installed drivers.
675 */
676#ifndef CONFIGURE_MAXIMUM_DRIVERS
677  #define CONFIGURE_MAXIMUM_DRIVERS CONFIGURE_NUMBER_OF_DRIVERS
678#endif
679
680
681#ifdef CONFIGURE_APPLICATION_NEEDS_ATA_DRIVER
682  /*
683   * configure the priority of the ATA driver task
684   */
685  #ifndef CONFIGURE_ATA_DRIVER_TASK_PRIORITY
686    #define CONFIGURE_ATA_DRIVER_TASK_PRIORITY ATA_DRIVER_TASK_DEFAULT_PRIORITY
687  #endif
688  #ifdef CONFIGURE_INIT
689    rtems_task_priority rtems_ata_driver_task_priority
690      = CONFIGURE_ATA_DRIVER_TASK_PRIORITY;
691  #endif /* CONFIGURE_INIT */
692#endif
693
694/*
695 * add bdbuf configuration and values for swapout task priority
696 */
697#ifdef CONFIGURE_APPLICATION_NEEDS_LIBBLOCK
698  #include <rtems/bdbuf.h>
699  /*
700   * configure the bdbuf cache parameters
701   */
702  #ifndef CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS
703    #define CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS \
704                              RTEMS_BDBUF_MAX_READ_AHEAD_BLOCKS_DEFAULT
705  #endif
706  #ifndef CONFIGURE_BDBUF_MAX_WRITE_BLOCKS
707    #define CONFIGURE_BDBUF_MAX_WRITE_BLOCKS \
708                              RTEMS_BDBUF_MAX_WRITE_BLOCKS_DEFAULT
709  #endif
710  #ifndef CONFIGURE_SWAPOUT_TASK_PRIORITY
711    #define CONFIGURE_SWAPOUT_TASK_PRIORITY \
712                              RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT
713  #endif
714  #ifndef CONFIGURE_SWAPOUT_SWAP_PERIOD
715    #define CONFIGURE_SWAPOUT_SWAP_PERIOD \
716                              RTEMS_BDBUF_SWAPOUT_TASK_SWAP_PERIOD_DEFAULT
717  #endif
718  #ifndef CONFIGURE_SWAPOUT_BLOCK_HOLD
719    #define CONFIGURE_SWAPOUT_BLOCK_HOLD \
720                              RTEMS_BDBUF_SWAPOUT_TASK_BLOCK_HOLD_DEFAULT
721  #endif
722  #ifdef CONFIGURE_INIT
723    rtems_bdbuf_config rtems_bdbuf_configuration = { 
724      CONFIGURE_BDBUF_MAX_READ_AHEAD_BLOCKS,
725      CONFIGURE_BDBUF_MAX_WRITE_BLOCKS,
726      CONFIGURE_SWAPOUT_TASK_PRIORITY,
727      CONFIGURE_SWAPOUT_SWAP_PERIOD,
728      CONFIGURE_SWAPOUT_BLOCK_HOLD
729    };
730  #endif
731  #ifndef CONFIGURE_HAS_OWN_BDBUF_TABLE
732    #ifndef CONFIGURE_BDBUF_BUFFER_COUNT
733      #define CONFIGURE_BDBUF_BUFFER_COUNT 64
734    #endif
735
736    #ifndef CONFIGURE_BDBUF_BUFFER_SIZE
737      #define CONFIGURE_BDBUF_BUFFER_SIZE 512
738    #endif
739    #ifdef CONFIGURE_INIT
740      rtems_bdbuf_pool_config rtems_bdbuf_pool_configuration[] = {
741        {CONFIGURE_BDBUF_BUFFER_SIZE, CONFIGURE_BDBUF_BUFFER_COUNT, NULL}
742      };
743      int rtems_bdbuf_pool_configuration_size = 
744        (sizeof(rtems_bdbuf_pool_configuration) /
745         sizeof(rtems_bdbuf_pool_configuration[0]));
746    #endif /* CONFIGURE_INIT */
747  #endif /* CONFIGURE_HAS_OWN_BDBUF_TABLE        */
748#endif /* CONFIGURE_APPLICATION_NEEDS_LIBBLOCK */
749
750#if defined(RTEMS_MULTIPROCESSING)
751  /*
752   *  Default Multiprocessing Configuration Table.  The defaults are
753   *  appropriate for most of the RTEMS Multiprocessor Test Suite.  Each
754   *  value may be overridden within each test to customize the environment.
755   */
756
757  #ifdef CONFIGURE_MP_APPLICATION
758    #define CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER 1
759
760    #ifndef CONFIGURE_HAS_OWN_MULTIPROCESSING_TABLE
761
762      #ifndef CONFIGURE_MP_NODE_NUMBER
763        #define CONFIGURE_MP_NODE_NUMBER                NODE_NUMBER
764      #endif
765
766      #ifndef CONFIGURE_MP_MAXIMUM_NODES
767        #define CONFIGURE_MP_MAXIMUM_NODES              2
768      #endif
769
770      #ifndef CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS
771        #define CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS     32
772      #endif
773      #define CONFIGURE_MEMORY_FOR_GLOBAL_OBJECTS(_global_objects) \
774        _Configure_Object_RAM((_global_objects), sizeof(Objects_MP_Control))
775
776      #ifndef CONFIGURE_MP_MAXIMUM_PROXIES
777        #define CONFIGURE_MP_MAXIMUM_PROXIES            32
778      #endif
779      #define CONFIGURE_MEMORY_FOR_PROXIES(_proxies) \
780        _Configure_Object_RAM((_proxies) + 1, sizeof(Thread_Proxy_control) )
781
782      #ifndef CONFIGURE_EXTRA_MPCI_RECEIVE_SERVER_STACK
783        #define CONFIGURE_EXTRA_MPCI_RECEIVE_SERVER_STACK 0
784      #endif
785
786      #ifndef CONFIGURE_MP_MPCI_TABLE_POINTER
787        #include <mpci.h>
788        #define CONFIGURE_MP_MPCI_TABLE_POINTER         &MPCI_table
789      #endif
790
791      #ifdef CONFIGURE_INIT
792        rtems_multiprocessing_table Multiprocessing_configuration = {
793          CONFIGURE_MP_NODE_NUMBER,               /* local node number */
794          CONFIGURE_MP_MAXIMUM_NODES,             /* maximum # nodes */
795          CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS,    /* maximum # global objects */
796          CONFIGURE_MP_MAXIMUM_PROXIES,           /* maximum # proxies */
797          CONFIGURE_EXTRA_MPCI_RECEIVE_SERVER_STACK, /* MPCI stack > minimum */
798          CONFIGURE_MP_MPCI_TABLE_POINTER         /* ptr to MPCI config table */
799        };
800      #endif
801
802      #define CONFIGURE_MULTIPROCESSING_TABLE    &Multiprocessing_configuration
803
804    #endif /* CONFIGURE_HAS_OWN_MULTIPROCESSING_TABLE */
805
806  #else
807
808    #define CONFIGURE_MULTIPROCESSING_TABLE    NULL
809
810  #endif /* CONFIGURE_MP_APPLICATION */
811#endif /* RTEMS_MULTIPROCESSING */
812
813#ifndef CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER
814  #define CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER 0
815#endif
816
817
818/*
819 *  Default Configuration Table.
820 */
821
822#ifndef CONFIGURE_HAS_OWN_CONFIGURATION_TABLE
823
824  #ifndef CONFIGURE_MAXIMUM_TASKS
825    #define CONFIGURE_MAXIMUM_TASKS               0
826  #endif
827
828  #ifndef CONFIGURE_DISABLE_CLASSIC_API_NOTEPADS
829    #define CONFIGURE_NOTEPADS_ENABLED           TRUE
830  #else
831    #define CONFIGURE_NOTEPADS_ENABLED           FALSE
832  #endif
833
834  #ifndef CONFIGURE_DISABLE_CLASSIC_NOTEPADS
835    #define CONFIGURE_MEMORY_PER_TASK_FOR_CLASSIC_API \
836      _Configure_From_workspace( sizeof(RTEMS_API_Control) )
837  #else
838    #define CONFIGURE_MEMORY_PER_TASK_FOR_CLASSIC_API \
839      _Configure_From_workspace( sizeof(RTEMS_API_Control) - \
840        (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)))
841  #endif
842
843  /**
844   *  This macro calculates the memory required for task variables.
845   *
846   *  @note Each task variable is individually allocated from the Workspace.
847   *        Hence, we do the multiplication on the configured size.
848   */
849  #ifndef CONFIGURE_MAXIMUM_TASK_VARIABLES
850    #define CONFIGURE_MAXIMUM_TASK_VARIABLES                     0
851    #define CONFIGURE_MEMORY_FOR_TASK_VARIABLES(_task_variables) 0
852  #else
853    #define CONFIGURE_MEMORY_FOR_TASK_VARIABLES(_task_variables) \
854      (_task_variables) * \
855         _Configure_From_workspace(sizeof(rtems_task_variable_t))
856  #endif
857
858  #ifndef CONFIGURE_MAXIMUM_TIMERS
859    #define CONFIGURE_MAXIMUM_TIMERS             0
860    #define CONFIGURE_MEMORY_FOR_TIMERS(_timers) 0
861  #else
862    #define CONFIGURE_MEMORY_FOR_TIMERS(_timers) \
863      _Configure_Object_RAM(_timers, sizeof(Timer_Control) )
864  #endif
865
866  #ifndef CONFIGURE_MAXIMUM_SEMAPHORES
867    #define CONFIGURE_MAXIMUM_SEMAPHORES                 0
868  #else
869  #endif
870
871  /*
872   * If there are no user or support semaphores defined, then we can assume
873   * that no memory need be allocated at all for semaphores.
874   */
875  #if  ((CONFIGURE_MAXIMUM_SEMAPHORES == 0) && \
876        (CONFIGURE_LIBIO_SEMAPHORES == 0) && \
877        (CONFIGURE_TERMIOS_SEMAPHORES == 0))
878    #define CONFIGURE_MEMORY_FOR_SEMAPHORES(_semaphores) 0
879  #else
880    #define CONFIGURE_MEMORY_FOR_SEMAPHORES(_semaphores) \
881      _Configure_Object_RAM(_semaphores, sizeof(Semaphore_Control) )
882  #endif
883
884  #ifndef CONFIGURE_MAXIMUM_MESSAGE_QUEUES
885    #define CONFIGURE_MAXIMUM_MESSAGE_QUEUES             0
886    #define CONFIGURE_MEMORY_FOR_MESSAGE_QUEUES(_queues) 0
887  #else
888    #define CONFIGURE_MEMORY_FOR_MESSAGE_QUEUES(_queues) \
889      _Configure_Object_RAM(_queues, sizeof(Message_queue_Control) )
890  #endif
891
892  #ifndef CONFIGURE_MAXIMUM_PARTITIONS
893    #define CONFIGURE_MAXIMUM_PARTITIONS                 0
894    #define CONFIGURE_MEMORY_FOR_PARTITIONS(_partitions) 0
895  #else
896    #define CONFIGURE_MEMORY_FOR_PARTITIONS(_partitions) \
897      _Configure_Object_RAM(_partitions, sizeof(Partition_Control) )
898  #endif
899
900  #ifndef CONFIGURE_MAXIMUM_REGIONS
901    #define CONFIGURE_MAXIMUM_REGIONS              0
902    #define CONFIGURE_MEMORY_FOR_REGIONS(_regions) 0
903  #else
904    #define CONFIGURE_MEMORY_FOR_REGIONS(_regions) \
905      _Configure_Object_RAM(_regions, sizeof(Region_Control) )
906  #endif
907
908  #ifndef CONFIGURE_MAXIMUM_PORTS
909    #define CONFIGURE_MAXIMUM_PORTS            0
910    #define CONFIGURE_MEMORY_FOR_PORTS(_ports) 0
911  #else
912    #define CONFIGURE_MEMORY_FOR_PORTS(_ports) \
913      _Configure_Object_RAM(_ports, sizeof(Dual_ported_memory_Control) )
914  #endif
915
916  #ifndef CONFIGURE_MAXIMUM_PERIODS
917    #define CONFIGURE_MAXIMUM_PERIODS              0
918    #define CONFIGURE_MEMORY_FOR_PERIODS(_periods) 0
919  #else
920    #define CONFIGURE_MEMORY_FOR_PERIODS(_periods) \
921      _Configure_Object_RAM(_periods, sizeof(Rate_monotonic_Control) )
922  #endif
923
924  #ifndef CONFIGURE_MAXIMUM_BARRIERS
925    #define CONFIGURE_MAXIMUM_BARRIERS               0
926    #define CONFIGURE_MEMORY_FOR_BARRIERS(_barriers) 0
927  #else
928    #define CONFIGURE_MEMORY_FOR_BARRIERS(_barriers) \
929      _Configure_Object_RAM(_barriers, sizeof(Barrier_Control) )
930  #endif
931
932  #ifndef CONFIGURE_MAXIMUM_USER_EXTENSIONS
933    #define CONFIGURE_MAXIMUM_USER_EXTENSIONS                 0
934    #define CONFIGURE_MEMORY_FOR_USER_EXTENSIONS(_extensions) 0
935  #else
936    #define CONFIGURE_MEMORY_FOR_USER_EXTENSIONS(_extensions) \
937      _Configure_Object_RAM(_extensions, sizeof(Extension_Control) )
938  #endif
939
940  #ifndef CONFIGURE_MICROSECONDS_PER_TICK
941    #define CONFIGURE_MICROSECONDS_PER_TICK \
942            RTEMS_MILLISECONDS_TO_MICROSECONDS(10)
943  #endif
944
945  #ifndef CONFIGURE_TICKS_PER_TIMESLICE
946    #define CONFIGURE_TICKS_PER_TIMESLICE        50
947  #endif
948
949/*
950 *  Initial Extension Set
951 */
952
953#ifdef CONFIGURE_INIT
954#ifdef CONFIGURE_STACK_CHECKER_ENABLED
955#include <rtems/stackchk.h>
956#endif
957#include <rtems/libcsupport.h>
958
959#if defined(CONFIGURE_INITIAL_EXTENSIONS) || \
960    defined(CONFIGURE_STACK_CHECKER_ENABLED) || \
961    (defined(RTEMS_NEWLIB) && !defined(CONFIGURE_DISABLE_NEWLIB_REENTRANCY))
962  rtems_extensions_table Configuration_Initial_Extensions[] = {
963    #if !defined(CONFIGURE_DISABLE_NEWLIB_REENTRANCY)
964      RTEMS_NEWLIB_EXTENSION,
965    #endif
966    #if defined(CONFIGURE_STACK_CHECKER_ENABLED)
967      RTEMS_STACK_CHECKER_EXTENSION,
968    #endif
969    #if defined(CONFIGURE_INITIAL_EXTENSIONS)
970      CONFIGURE_INITIAL_EXTENSIONS,
971    #endif
972  };
973
974  #define CONFIGURE_INITIAL_EXTENSION_TABLE Configuration_Initial_Extensions
975  #define CONFIGURE_NUMBER_OF_INITIAL_EXTENSIONS \
976    ((sizeof(Configuration_Initial_Extensions) / \
977      sizeof(rtems_extensions_table)))
978#else
979  #define CONFIGURE_INITIAL_EXTENSION_TABLE NULL
980  #define CONFIGURE_NUMBER_OF_INITIAL_EXTENSIONS 0
981#endif
982
983
984#endif
985
986/*
987 *  POSIX API Configuration Parameters
988 */
989
990#ifdef RTEMS_POSIX_API
991
992  #include <sys/types.h>
993  #include <signal.h>
994  #include <limits.h>
995  #include <mqueue.h>
996  #include <rtems/posix/barrier.h>
997  #include <rtems/posix/cond.h>
998  #include <rtems/posix/mqueue.h>
999  #include <rtems/posix/mutex.h>
1000  #include <rtems/posix/key.h>
1001  #include <rtems/posix/psignal.h>
1002  #include <rtems/posix/rwlock.h>
1003  #include <rtems/posix/semaphore.h>
1004  #include <rtems/posix/spinlock.h>
1005  #include <rtems/posix/threadsup.h>
1006  #include <rtems/posix/timer.h>
1007
1008  /**
1009   *  Account for the object control structures plus the name
1010   *  of the object to be duplicated.
1011   */
1012  #define _Configure_POSIX_Named_Object_RAM(_number, _size) \
1013    _Configure_Object_RAM( (_number), _size ) + \
1014    ((_number) + _Configure_From_workspace(NAME_MAX) )
1015
1016  #ifndef CONFIGURE_MAXIMUM_POSIX_THREADS
1017    #define CONFIGURE_MAXIMUM_POSIX_THREADS      0
1018  #endif
1019
1020  #define CONFIGURE_MEMORY_PER_TASK_FOR_POSIX_API \
1021    _Configure_From_workspace( \
1022      sizeof (POSIX_API_Control) + \
1023     (sizeof (void *) * (CONFIGURE_MAXIMUM_POSIX_KEYS)) \
1024    )
1025
1026  #ifndef CONFIGURE_MAXIMUM_POSIX_MUTEXES
1027    #define CONFIGURE_MAXIMUM_POSIX_MUTEXES              0
1028    #define CONFIGURE_MEMORY_FOR_POSIX_MUTEXES(_mutexes) 0
1029  #else
1030    #define CONFIGURE_MEMORY_FOR_POSIX_MUTEXES(_mutexes) \
1031      _Configure_Object_RAM(_mutexes, sizeof(POSIX_Mutex_Control) )
1032  #endif
1033
1034  #ifndef CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES
1035    #define CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES               0
1036    #define CONFIGURE_MEMORY_FOR_POSIX_CONDITION_VARIABLES(_condvars) 0
1037  #else
1038    #define CONFIGURE_MEMORY_FOR_POSIX_CONDITION_VARIABLES(_condvars) \
1039        _Configure_Object_RAM(_condvars, \
1040                            sizeof(POSIX_Condition_variables_Control) )
1041  #endif
1042
1043  #ifndef CONFIGURE_MAXIMUM_POSIX_KEYS
1044    #define CONFIGURE_MAXIMUM_POSIX_KEYS           0
1045    #define CONFIGURE_MEMORY_FOR_POSIX_KEYS(_keys) 0
1046  #else
1047    #define CONFIGURE_MEMORY_FOR_POSIX_KEYS(_keys) \
1048      _Configure_Object_RAM(_keys, sizeof(POSIX_Keys_Control) )
1049  #endif
1050
1051  #ifndef CONFIGURE_MAXIMUM_POSIX_TIMERS
1052    #define CONFIGURE_MAXIMUM_POSIX_TIMERS             0
1053    #define CONFIGURE_MEMORY_FOR_POSIX_TIMERS(_timers) 0
1054  #else
1055    #define CONFIGURE_MEMORY_FOR_POSIX_TIMERS(_timers) \
1056      _Configure_Object_RAM(_timers, sizeof(POSIX_Timer_Control) )
1057  #endif
1058
1059  #ifndef CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS
1060    #define CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS                     0
1061    #define CONFIGURE_MEMORY_FOR_POSIX_QUEUED_SIGNALS(_queued_signals) 0
1062  #else
1063    #define CONFIGURE_MEMORY_FOR_POSIX_QUEUED_SIGNALS(_queued_signals) \
1064      _Configure_From_workspace( \
1065        (_queued_signals) * (sizeof(POSIX_signals_Siginfo_node)) )
1066  #endif
1067
1068  #ifndef CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES
1069    #define CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES                     0
1070    #define CONFIGURE_MEMORY_FOR_POSIX_MESSAGE_QUEUES(_message_queues) 0
1071  #else
1072    #define CONFIGURE_MEMORY_FOR_POSIX_MESSAGE_QUEUES(_message_queues) \
1073      _Configure_POSIX_Named_Object_RAM( \
1074         _message_queues, sizeof(POSIX_Message_queue_Control) )
1075  #endif
1076
1077  #ifndef CONFIGURE_MAXIMUM_POSIX_SEMAPHORES
1078    #define CONFIGURE_MAXIMUM_POSIX_SEMAPHORES                 0
1079    #define CONFIGURE_MEMORY_FOR_POSIX_SEMAPHORES(_semaphores) 0
1080  #else
1081    #define CONFIGURE_MEMORY_FOR_POSIX_SEMAPHORES(_semaphores) \
1082      _Configure_POSIX_Named_Object_RAM( \
1083         _semaphores, sizeof(POSIX_Semaphore_Control) )
1084  #endif
1085
1086  #ifndef CONFIGURE_MAXIMUM_POSIX_BARRIERS
1087    #define CONFIGURE_MAXIMUM_POSIX_BARRIERS               0
1088    #define CONFIGURE_MEMORY_FOR_POSIX_BARRIERS(_barriers) 0
1089  #else
1090    #define CONFIGURE_MEMORY_FOR_POSIX_BARRIERS(_barriers) \
1091      _Configure_Object_RAM(_barriers, sizeof(POSIX_Barrier_Control) )
1092  #endif
1093
1094  #ifndef CONFIGURE_MAXIMUM_POSIX_SPINLOCKS
1095    #define CONFIGURE_MAXIMUM_POSIX_SPINLOCKS                0
1096    #define CONFIGURE_MEMORY_FOR_POSIX_SPINLOCKS(_spinlocks) 0
1097  #else
1098    #define CONFIGURE_MEMORY_FOR_POSIX_SPINLOCKS(_spinlocks) \
1099      _Configure_Object_RAM(_spinlocks, sizeof(POSIX_Spinlock_Control) )
1100  #endif
1101
1102  #ifndef CONFIGURE_MAXIMUM_POSIX_RWLOCKS
1103    #define CONFIGURE_MAXIMUM_POSIX_RWLOCKS              0
1104    #define CONFIGURE_MEMORY_FOR_POSIX_RWLOCKS(_rwlocks) 0
1105  #else
1106    #define CONFIGURE_MEMORY_FOR_POSIX_RWLOCKS(_rwlocks) \
1107      _Configure_Object_RAM(_rwlocks, sizeof(POSIX_RWLock_Control) )
1108  #endif
1109
1110  #ifdef CONFIGURE_POSIX_INIT_THREAD_TABLE
1111
1112    #ifdef CONFIGURE_POSIX_HAS_OWN_INIT_THREAD_TABLE
1113
1114      /*
1115       *  The user is defining their own table information and setting the
1116       *  appropriate variables for the POSIX Initialization Thread Table.
1117       */
1118
1119    #else
1120
1121      #ifndef CONFIGURE_POSIX_INIT_THREAD_ENTRY_POINT
1122        #define CONFIGURE_POSIX_INIT_THREAD_ENTRY_POINT   POSIX_Init
1123      #endif
1124
1125      #ifndef CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE
1126        #define CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE \
1127                (CONFIGURE_MINIMUM_TASK_STACK_SIZE * 2)
1128      #endif
1129
1130      #ifdef CONFIGURE_INIT
1131        posix_initialization_threads_table POSIX_Initialization_threads[] = {
1132          { CONFIGURE_POSIX_INIT_THREAD_ENTRY_POINT, \
1133              CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE }
1134        };
1135      #endif
1136
1137      #define CONFIGURE_POSIX_INIT_THREAD_TABLE_NAME \
1138              POSIX_Initialization_threads
1139
1140      #define CONFIGURE_POSIX_INIT_THREAD_TABLE_SIZE \
1141        sizeof(CONFIGURE_POSIX_INIT_THREAD_TABLE_NAME) / \
1142            sizeof(posix_initialization_threads_table)
1143
1144    #endif    /* CONFIGURE_POSIX_HAS_OWN_INIT_TASK_TABLE */
1145
1146  #else     /* CONFIGURE_POSIX_INIT_THREAD_TABLE */
1147
1148    #define CONFIGURE_POSIX_INIT_THREAD_TABLE_NAME NULL
1149    #define CONFIGURE_POSIX_INIT_THREAD_TABLE_SIZE 0
1150
1151  #endif
1152
1153  #define CONFIGURE_MEMORY_FOR_POSIX \
1154    ( CONFIGURE_MEMORY_FOR_POSIX_MUTEXES( CONFIGURE_MAXIMUM_POSIX_MUTEXES ) + \
1155      CONFIGURE_MEMORY_FOR_POSIX_CONDITION_VARIABLES( \
1156          CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES ) + \
1157      CONFIGURE_MEMORY_FOR_POSIX_KEYS( CONFIGURE_MAXIMUM_POSIX_KEYS ) + \
1158      CONFIGURE_MEMORY_FOR_POSIX_QUEUED_SIGNALS( \
1159          CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS ) + \
1160      CONFIGURE_MEMORY_FOR_POSIX_MESSAGE_QUEUES( \
1161          CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES ) + \
1162      CONFIGURE_MEMORY_FOR_POSIX_SEMAPHORES( \
1163          CONFIGURE_MAXIMUM_POSIX_SEMAPHORES ) + \
1164      CONFIGURE_MEMORY_FOR_POSIX_BARRIERS(CONFIGURE_MAXIMUM_POSIX_BARRIERS) + \
1165      CONFIGURE_MEMORY_FOR_POSIX_SPINLOCKS( \
1166          CONFIGURE_MAXIMUM_POSIX_SPINLOCKS ) + \
1167      CONFIGURE_MEMORY_FOR_POSIX_RWLOCKS( \
1168          CONFIGURE_MAXIMUM_POSIX_RWLOCKS ) + \
1169      CONFIGURE_MEMORY_FOR_POSIX_TIMERS( CONFIGURE_MAXIMUM_POSIX_TIMERS ) + \
1170      (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE) \
1171     )
1172#else
1173
1174  #define CONFIGURE_MAXIMUM_POSIX_THREADS         0
1175  #define CONFIGURE_MEMORY_PER_TASK_FOR_POSIX_API 0
1176  #define CONFIGURE_MEMORY_FOR_POSIX              0
1177
1178#endif    /* RTEMS_POSIX_API */
1179
1180#ifndef CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE
1181  #define CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE    0
1182#endif
1183
1184/*
1185 *  This block of defines are for applications which use GNAT/RTEMS.
1186 *  GNAT implements each Ada task as a POSIX thread.
1187 */
1188#ifdef CONFIGURE_GNAT_RTEMS
1189
1190  /**
1191   *  The GNAT run-time needs something less than (10) POSIX mutexes.
1192   *  We may be able to get by with less but why bother.
1193   */
1194  #define CONFIGURE_GNAT_MUTEXES 10
1195
1196  /**
1197   *  This is the maximum number of Ada tasks which can be concurrently
1198   *  in existence.  Twenty (20) are required to run all tests in the
1199   *  ACATS (formerly ACVC).
1200   */
1201  #ifndef CONFIGURE_MAXIMUM_ADA_TASKS
1202    #define CONFIGURE_MAXIMUM_ADA_TASKS  20
1203  #endif
1204
1205  /**
1206   * This is the number of non-Ada tasks which invoked Ada code.
1207   */
1208  #ifndef CONFIGURE_MAXIMUM_FAKE_ADA_TASKS
1209    #define CONFIGURE_MAXIMUM_FAKE_ADA_TASKS 0
1210  #endif
1211
1212  /**
1213   * Ada tasks are allocated twice the minimum stack space.
1214   */
1215  #define CONFIGURE_ADA_TASKS_STACK \
1216    (CONFIGURE_MAXIMUM_ADA_TASKS * \
1217      (CONFIGURE_MINIMUM_TASK_STACK_SIZE + (6 * 1024)))
1218
1219#else
1220  #define CONFIGURE_GNAT_MUTEXES           0
1221  #define CONFIGURE_MAXIMUM_ADA_TASKS      0
1222  #define CONFIGURE_MAXIMUM_FAKE_ADA_TASKS 0
1223  #define CONFIGURE_ADA_TASKS_STACK        0
1224#endif
1225
1226/*
1227 *  ITRON API Configuration Parameters
1228 */
1229
1230#ifdef RTEMS_ITRON_API
1231
1232  #include <rtems/itron.h>
1233  #include <rtems/itron/config.h>
1234  #include <rtems/itron/eventflags.h>
1235  #include <rtems/itron/fmempool.h>
1236  #include <rtems/itron/mbox.h>
1237  #include <rtems/itron/msgbuffer.h>
1238  #include <rtems/itron/port.h>
1239  #include <rtems/itron/semaphore.h>
1240  #include <rtems/itron/task.h>
1241  #include <rtems/itron/vmempool.h>
1242
1243  #ifndef CONFIGURE_MAXIMUM_ITRON_TASKS
1244    #define CONFIGURE_MAXIMUM_ITRON_TASKS      0
1245  #endif
1246  #define CONFIGURE_MEMORY_PER_TASK_FOR_ITRON_API 0
1247
1248  #ifndef CONFIGURE_MAXIMUM_ITRON_SEMAPHORES
1249    #define CONFIGURE_MAXIMUM_ITRON_SEMAPHORES                 0
1250    #define CONFIGURE_MEMORY_FOR_ITRON_SEMAPHORES(_semaphores) 0
1251  #else
1252    #define CONFIGURE_MEMORY_FOR_ITRON_SEMAPHORES(_semaphores) \
1253      _Configure_Object_RAM(_semaphores, sizeof(ITRON_Semaphore_Control))
1254  #endif
1255
1256  #ifndef CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS
1257    #define CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS                 0
1258    #define CONFIGURE_MEMORY_FOR_ITRON_EVENTFLAGS(_eventflags) 0
1259  #else
1260    #define CONFIGURE_MEMORY_FOR_ITRON_EVENTFLAGS(_eventflags) \
1261      _Configure_Object_RAM(_eventflags, sizeof(ITRON_Eventflags_Control))
1262  #endif
1263
1264  #ifndef CONFIGURE_MAXIMUM_ITRON_MAILBOXES
1265    #define CONFIGURE_MAXIMUM_ITRON_MAILBOXES                0
1266    #define CONFIGURE_MEMORY_FOR_ITRON_MAILBOXES(_mailboxes) 0
1267  #else
1268    #define CONFIGURE_MEMORY_FOR_ITRON_MAILBOXES(_mailboxes) \
1269      _Configure_Object_RAM(_mailboxes, sizeof(ITRON_Mailbox_Control))
1270  #endif
1271
1272  #ifndef CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS
1273    #define CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS                      0
1274    #define CONFIGURE_MEMORY_FOR_ITRON_MESSAGE_BUFFERS(_message_buffers) 0
1275  #else
1276    #define CONFIGURE_MEMORY_FOR_ITRON_MESSAGE_BUFFERS(_message_buffers) \
1277      _Configure_Object_RAM(_message_buffers, \
1278        sizeof(ITRON_Message_buffer_Control))
1279  #endif
1280
1281  #ifndef CONFIGURE_MAXIMUM_ITRON_PORTS
1282    #define CONFIGURE_MAXIMUM_ITRON_PORTS            0
1283    #define CONFIGURE_MEMORY_FOR_ITRON_PORTS(_ports) 0
1284  #else
1285    #define CONFIGURE_MEMORY_FOR_ITRON_PORTS(_ports) \
1286      _Configure_Object_RAM(_ports, sizeof(ITRON_Port_Control))
1287  #endif
1288
1289  #ifndef CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS
1290    #define CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS            0
1291    #define CONFIGURE_MEMORY_FOR_ITRON_MEMORY_POOLS(_pools) 0
1292  #else
1293    #define CONFIGURE_MEMORY_FOR_ITRON_MEMORY_POOLS(_pools) \
1294      _Configure_Object_RAM( _pools, sizeof(ITRON_Variable_memory_pool_Control))
1295  #endif
1296
1297  #ifndef CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS
1298    #define CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS            0
1299    #define CONFIGURE_MEMORY_FOR_ITRON_FIXED_MEMORY_POOLS(_pools) 0
1300  #else
1301    #define CONFIGURE_MEMORY_FOR_ITRON_FIXED_MEMORY_POOLS(_pools) \
1302      _Configure_Object_RAM(_pools, sizeof(ITRON_Fixed_memory_pool_Control))
1303  #endif
1304
1305  #ifdef CONFIGURE_ITRON_INIT_TASK_TABLE
1306
1307    #ifdef CONFIGURE_ITRON_HAS_OWN_INIT_TASK_TABLE
1308
1309      /*
1310       *  The user is defining their own table information and setting the
1311       *  appropriate variables for the ITRON Initialization Task Table.
1312       */
1313
1314    #else
1315
1316      #ifndef CONFIGURE_ITRON_INIT_TASK_ENTRY_POINT
1317        #define CONFIGURE_ITRON_INIT_TASK_ENTRY_POINT   ITRON_Init
1318      #endif
1319
1320      #ifndef CONFIGURE_ITRON_INIT_TASK_ATTRIBUTES
1321        #define CONFIGURE_ITRON_INIT_TASK_ATTRIBUTES    TA_HLNG
1322      #endif
1323
1324      #ifndef CONFIGURE_ITRON_INIT_TASK_PRIORITY
1325        #define CONFIGURE_ITRON_INIT_TASK_PRIORITY      1
1326      #endif
1327
1328      #ifndef CONFIGURE_ITRON_INIT_TASK_STACK_SIZE
1329        #define CONFIGURE_ITRON_INIT_TASK_STACK_SIZE \
1330                CONFIGURE_MINIMUM_TASK_STACK_SIZE
1331      #endif
1332
1333      #ifdef CONFIGURE_INIT
1334        itron_initialization_tasks_table ITRON_Initialization_tasks[] = {
1335          { 1,                                    /* ID */
1336            { (VP) 0,                                /* exinfo */
1337              CONFIGURE_ITRON_INIT_TASK_ATTRIBUTES,  /* task attributes */
1338              CONFIGURE_ITRON_INIT_TASK_ENTRY_POINT, /* task start address */
1339              CONFIGURE_ITRON_INIT_TASK_PRIORITY,    /* initial task priority */
1340              CONFIGURE_ITRON_INIT_TASK_STACK_SIZE   /* stack size */
1341            }
1342          }
1343        };
1344      #endif
1345
1346      #define CONFIGURE_ITRON_INIT_TASK_TABLE_NAME ITRON_Initialization_tasks
1347
1348      #define CONFIGURE_ITRON_INIT_TASK_TABLE_SIZE \
1349        sizeof(CONFIGURE_ITRON_INIT_TASK_TABLE_NAME) / \
1350            sizeof(itron_initialization_tasks_table)
1351
1352    #endif    /* CONFIGURE_ITRON_HAS_OWN_INIT_TASK_TABLE */
1353
1354  #else     /* CONFIGURE_ITRON_INIT_TASK_TABLE */
1355
1356    #define CONFIGURE_ITRON_INIT_TASK_TABLE_NAME NULL
1357    #define CONFIGURE_ITRON_INIT_TASK_TABLE_SIZE 0
1358    #define CONFIGURE_ITRON_INIT_TASK_STACK_SIZE 0
1359
1360  #endif
1361
1362  #define CONFIGURE_MEMORY_FOR_ITRON \
1363    ( CONFIGURE_MEMORY_FOR_ITRON_SEMAPHORES( \
1364          CONFIGURE_MAXIMUM_ITRON_SEMAPHORES ) + \
1365      CONFIGURE_MEMORY_FOR_ITRON_EVENTFLAGS( \
1366          CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS ) + \
1367      CONFIGURE_MEMORY_FOR_ITRON_MAILBOXES( \
1368          CONFIGURE_MAXIMUM_ITRON_MAILBOXES ) + \
1369      CONFIGURE_MEMORY_FOR_ITRON_MESSAGE_BUFFERS( \
1370          CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS ) + \
1371      CONFIGURE_MEMORY_FOR_ITRON_PORTS( \
1372          CONFIGURE_MAXIMUM_ITRON_PORTS ) + \
1373      CONFIGURE_MEMORY_FOR_ITRON_MEMORY_POOLS( \
1374          CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS ) + \
1375      CONFIGURE_MEMORY_FOR_ITRON_FIXED_MEMORY_POOLS( \
1376          CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS ) + \
1377      CONFIGURE_ITRON_INIT_TASK_STACK_SIZE \
1378     )
1379
1380#else
1381
1382  #define CONFIGURE_MAXIMUM_ITRON_TASKS               0
1383  #define CONFIGURE_MAXIMUM_ITRON_SEMAPHORES          0
1384  #define CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS          0
1385  #define CONFIGURE_MAXIMUM_ITRON_MAILBOXES           0
1386  #define CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS     0
1387  #define CONFIGURE_MAXIMUM_ITRON_PORTS               0
1388  #define CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS        0
1389  #define CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS  0
1390  #define CONFIGURE_MEMORY_PER_TASK_FOR_ITRON_API     0
1391  #define CONFIGURE_MEMORY_FOR_ITRON                  0
1392
1393#endif    /* RTEMS_ITRON_API */
1394
1395/**
1396 *  This macro specifies the amount of memory to be reserved for the
1397 *  Newlib C Library reentrancy structure -- if we are using newlib.
1398 */
1399
1400#if (defined(RTEMS_NEWLIB) && !defined(CONFIGURE_DISABLE_NEWLIB_REENTRANCY))
1401  #include <reent.h>
1402
1403  #define CONFIGURE_MEMORY_PER_TASK_FOR_NEWLIB \
1404    _Configure_From_workspace(sizeof(struct _reent))
1405#else
1406  #define CONFIGURE_MEMORY_PER_TASK_FOR_NEWLIB 0
1407#endif
1408
1409/*
1410 *  Calculate the RAM size based on the maximum number of objects configured.
1411 */
1412
1413#ifndef CONFIGURE_EXECUTIVE_RAM_SIZE
1414
1415/**
1416 *  Account for allocating the following per object
1417 *    + array of object control structures
1418 *    + local pointer table -- pointer per object plus a zero'th
1419 *      entry in the local pointer table.
1420 */
1421
1422#define CONFIGURE_MEMORY_FOR_TASKS(_tasks, _number_FP_tasks) \
1423 ( \
1424  _Configure_Object_RAM(_tasks, sizeof(Thread_Control)) + \
1425  (_Configure_Max_Objects(_tasks) * \
1426   (_Configure_From_workspace(CONFIGURE_MINIMUM_TASK_STACK_SIZE) + \
1427    _Configure_From_workspace(CONFIGURE_MEMORY_PER_TASK_FOR_CLASSIC_API) + \
1428    CONFIGURE_MEMORY_PER_TASK_FOR_NEWLIB + \
1429    CONFIGURE_MEMORY_PER_TASK_FOR_POSIX_API + \
1430    CONFIGURE_MEMORY_PER_TASK_FOR_ITRON_API))  + \
1431  _Configure_From_workspace( \
1432    _Configure_Max_Objects(_number_FP_tasks) * CONTEXT_FP_SIZE) \
1433 )
1434
1435/**
1436 *  This defines the amount of memory configured for the multiprocessing
1437 *  support required by this application.
1438 */
1439#ifdef CONFIGURE_MP_APPLICATION
1440  #define CONFIGURE_MEMORY_FOR_MP \
1441    (CONFIGURE_MEMORY_FOR_PROXIES(CONFIGURE_MP_MAXIMUM_PROXIES) + \
1442     CONFIGURE_MEMORY_FOR_GLOBAL_OBJECTS( \
1443             CONFIGURE_MP_MAXIMUM_GLOBAL_OBJECTS) + \
1444     CONFIGURE_MEMORY_FOR_TASKS(1, 1) + \
1445     CONFIGURE_EXTRA_MPCI_RECEIVE_SERVER_STACK \
1446  )
1447#else
1448  #define CONFIGURE_MEMORY_FOR_MP  0
1449#endif
1450
1451/**
1452 *  This is so we can account for tasks with stacks greater than minimum
1453 *  size.  This is in bytes.
1454 */
1455#ifndef CONFIGURE_EXTRA_TASK_STACKS
1456  #define CONFIGURE_EXTRA_TASK_STACKS 0
1457#endif
1458
1459/**
1460 *  The following macro is used to calculate the memory allocated by RTEMS
1461 *  for the message buffers associated with a particular message queue.
1462 *  There is a fixed amount of overhead per message.
1463 */
1464#define CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE(_messages, _size) \
1465    _Configure_From_workspace( \
1466      (_messages) * ((_size) + sizeof(CORE_message_queue_Buffer_control)))
1467
1468/**
1469 *  This macros is set to the amount of memory required for pending message
1470 *  buffers in bytes.  It should be constructed by adding together a
1471 *  set of values determined by CONFIGURE_MESSAGE_BUFFERS_FOR_QUEUE.
1472 */
1473#ifndef CONFIGURE_MESSAGE_BUFFER_MEMORY
1474  #define CONFIGURE_MESSAGE_BUFFER_MEMORY 0
1475#endif
1476
1477/**
1478 *  This macro is available just in case the confdefs.h file underallocates
1479 *  memory for a particular application.  This lets the user add some extra
1480 *  memory in case something broken and underestimates.
1481 *
1482 *  It is also possible for cases where confdefs.h overallocates memory,
1483 *  you could substract memory from the allocated.  The estimate is just
1484 *  that, an estimate, and assumes worst case alignment and padding on
1485 *  each allocated element.  So in some cases it could be too conservative.
1486 *
1487 *  @note Historically this was used for message buffers.
1488 */
1489#ifndef CONFIGURE_MEMORY_OVERHEAD
1490  #define CONFIGURE_MEMORY_OVERHEAD 0
1491#endif
1492
1493/**
1494 *  On architectures that use Simple Vectored Interrupts, it is RTEMS
1495 *  responsibility to allocate the vector table.  This avoids reserving
1496 *  the memory on architectures that use the Programmable Interrupt
1497 *  Controller Vectored Interrupts.
1498 */
1499#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
1500  /*
1501   *  This is a (hopefully) temporary hack.  On the mips, the number of
1502   *  vectors is NOT statically defined.  But it has to be statically
1503   *  defined for this to work.  This is an issue looking for a nice
1504   *  solution.
1505   */
1506  #if defined(__mips__)
1507    #define CONFIGURE_INTERRUPT_VECTOR_TABLE \
1508      _Configure_From_workspace( (sizeof(ISR_Handler_entry) * 256))
1509  #else
1510    #define CONFIGURE_INTERRUPT_VECTOR_TABLE \
1511      _Configure_From_workspace( \
1512        (sizeof(ISR_Handler_entry) * ISR_NUMBER_OF_VECTORS))
1513  #endif
1514#else
1515  #define CONFIGURE_INTERRUPT_VECTOR_TABLE 0
1516#endif
1517
1518/**
1519 *  RTEMS uses one instance of an internal mutex class.  This accounts
1520 *  for that mutex
1521 */
1522#define CONFIGURE_API_MUTEX_MEMORY \
1523  _Configure_Object_RAM(1, sizeof(API_Mutex_Control))
1524
1525/**
1526 *  This defines the memory used by the thread ready chains.  There is
1527 *  one chain per priority.
1528 */
1529#define CONFIGURE_MEMORY_FOR_THREAD_READY_CHAINS \
1530    _Configure_From_workspace( \
1531        ((CONFIGURE_MAXIMUM_PRIORITY+1) * sizeof(Chain_Control)) )
1532/**
1533 *  This defines the amount of memory reserved for the IDLE task
1534 *  control structures and stack.
1535 */
1536#define CONFIGURE_MEMORY_FOR_IDLE_TASK \
1537    (CONFIGURE_MEMORY_FOR_TASKS(1, 0) + \
1538     (CONFIGURE_IDLE_TASK_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE))
1539
1540/**
1541 *  This macro accounts for general RTEMS system overhead.
1542 */
1543#define CONFIGURE_MEMORY_FOR_SYSTEM_OVERHEAD \
1544  ( CONFIGURE_MEMORY_FOR_IDLE_TASK +                /* IDLE and stack */ \
1545    CONFIGURE_MEMORY_FOR_THREAD_READY_CHAINS +     /* Ready chains */ \
1546    CONFIGURE_INTERRUPT_VECTOR_TABLE +             /* interrupt vectors */ \
1547    CONFIGURE_INTERRUPT_STACK_MEMORY +             /* interrupt stack */ \
1548    CONFIGURE_API_MUTEX_MEMORY                     /* allocation mutex */ \
1549  )
1550
1551/*
1552 *  Now account for any extra memory that initialization tasks or threads
1553 *  may have requested.
1554 */
1555
1556/**
1557 *  This accounts for any extra memory required by the Classic API
1558 *  Initialization Task.
1559 */
1560#if (CONFIGURE_INIT_TASK_STACK_SIZE > CONFIGURE_MINIMUM_TASK_STACK_SIZE)
1561  #define CONFIGURE_INITIALIZATION_THREADS_STACKS_CLASSIC_PART \
1562      (CONFIGURE_INIT_TASK_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE)
1563#else
1564  #define CONFIGURE_INITIALIZATION_THREADS_STACKS_CLASSIC_PART 0
1565#endif
1566
1567/**
1568 *  This accounts for any extra memory required by the POSIX API
1569 *  Initialization Thread.
1570 */
1571#if defined(RTEMS_POSIX_API) && \
1572    (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE > CONFIGURE_MINIMUM_TASK_STACK_SIZE)
1573  #define CONFIGURE_INITIALIZATION_THREADS_STACKS_POSIX_PART \
1574    (CONFIGURE_POSIX_INIT_THREAD_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE)
1575#else
1576  #define CONFIGURE_INITIALIZATION_THREADS_STACKS_POSIX_PART 0
1577#endif
1578
1579/**
1580 *  This accounts for any extra memory required by the ITRON API
1581 *  Initialization Task.
1582 */
1583#if defined(RTEMS_ITRON_API) && \
1584    (CONFIGURE_ITRON_INIT_TASK_STACK_SIZE > CONFIGURE_MINIMUM_TASK_STACK_SIZE)
1585  #define CONFIGURE_INITIALIZATION_THREADS_STACKS_ITRON_PART \
1586      (CONFIGURE_ITRON_INIT_TASK_STACK_SIZE - CONFIGURE_MINIMUM_TASK_STACK_SIZE)
1587#else
1588  #define CONFIGURE_INITIALIZATION_THREADS_STACKS_ITRON_PART 0
1589#endif
1590
1591/**
1592 *  This macro provides a summation of the various initialization task
1593 *  and thread stack requirements.
1594 */
1595#define CONFIGURE_INITIALIZATION_THREADS_STACKS \
1596    (CONFIGURE_INITIALIZATION_THREADS_STACKS_CLASSIC_PART + \
1597    CONFIGURE_INITIALIZATION_THREADS_STACKS_POSIX_PART + \
1598    CONFIGURE_INITIALIZATION_THREADS_STACKS_ITRON_PART)
1599
1600/**
1601 *  This macro provides a summation of the various task and thread
1602 *  requirements.
1603 */
1604#define CONFIGURE_TOTAL_TASKS_AND_THREADS \
1605   (CONFIGURE_MAXIMUM_TASKS + \
1606    CONFIGURE_MAXIMUM_POSIX_THREADS + CONFIGURE_MAXIMUM_ADA_TASKS + \
1607    CONFIGURE_MAXIMUM_ITRON_TASKS \
1608   )
1609
1610/**
1611 *  This macro reserves the memory required by the statically configured
1612 *  user extensions.
1613 */
1614#define CONFIGURE_MEMORY_FOR_STATIC_EXTENSIONS \
1615     ((CONFIGURE_NEWLIB_EXTENSION * \
1616        _Configure_From_workspace( sizeof(User_extensions_Control))) + \
1617      (CONFIGURE_STACK_CHECKER_EXTENSION * \
1618        _Configure_From_workspace( sizeof(User_extensions_Control))) \
1619     )
1620
1621/**
1622 *  This macro provides a summation of the memory required by the
1623 *  Classic API as configured.
1624 */
1625#define CONFIGURE_MEMORY_FOR_CLASSIC \
1626  (CONFIGURE_MEMORY_FOR_TASK_VARIABLES(CONFIGURE_MAXIMUM_TASK_VARIABLES) + \
1627   CONFIGURE_MEMORY_FOR_TIMERS(CONFIGURE_MAXIMUM_TIMERS + \
1628    CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER ) + \
1629   CONFIGURE_MEMORY_FOR_SEMAPHORES(CONFIGURE_MAXIMUM_SEMAPHORES + \
1630     CONFIGURE_LIBIO_SEMAPHORES + CONFIGURE_TERMIOS_SEMAPHORES) + \
1631   CONFIGURE_MEMORY_FOR_MESSAGE_QUEUES(CONFIGURE_MAXIMUM_MESSAGE_QUEUES) + \
1632   CONFIGURE_MEMORY_FOR_PARTITIONS(CONFIGURE_MAXIMUM_PARTITIONS) + \
1633   CONFIGURE_MEMORY_FOR_REGIONS( CONFIGURE_MAXIMUM_REGIONS ) + \
1634   CONFIGURE_MEMORY_FOR_PORTS(CONFIGURE_MAXIMUM_PORTS) + \
1635   CONFIGURE_MEMORY_FOR_PERIODS(CONFIGURE_MAXIMUM_PERIODS) + \
1636   CONFIGURE_MEMORY_FOR_BARRIERS(CONFIGURE_MAXIMUM_BARRIERS) + \
1637   CONFIGURE_MEMORY_FOR_USER_EXTENSIONS(CONFIGURE_MAXIMUM_USER_EXTENSIONS) \
1638  )
1639
1640#if defined(CONFIGURE_CONFDEFS_DEBUG) && defined(CONFIGURE_INIT)
1641  /**
1642   *  This is a debug mechanism, so if you need to, the executable will
1643   *  have a structure with various partial values.  Add to this as you
1644   *  need to.  Viewing this structure in gdb combined with dumping
1645   *  the Configuration structures generated should help a lot in tracing
1646   *  down errors and analyzing where over and under allocations are.
1647   */
1648  typedef struct {
1649    uint32_t SYSTEM_OVERHEAD;
1650    uint32_t STATIC_EXTENSIONS;
1651    uint32_t INITIALIZATION_THREADS_STACKS;
1652
1653    uint32_t PER_INTEGER_TASK;
1654    uint32_t FP_OVERHEAD;
1655    uint32_t CLASSIC;
1656    uint32_t POSIX;
1657    uint32_t ITRON;
1658
1659    /* System overhead pieces */
1660    uint32_t INTERRUPT_VECTOR_TABLE;
1661    uint32_t INTERRUPT_STACK_MEMORY;
1662    uint32_t THREAD_READY_CHAINS;
1663    uint32_t MEMORY_FOR_IDLE_TASK;
1664
1665    /* Classic API Pieces */
1666    uint32_t CLASSIC_TASKS;
1667    uint32_t TASK_VARIABLES;
1668    uint32_t TIMERS;
1669    uint32_t SEMAPHORES;
1670    uint32_t MESSAGE_QUEUES;
1671    uint32_t PARTITIONS;
1672    uint32_t REGIONS;
1673    uint32_t PORTS;
1674    uint32_t PERIODS;
1675    uint32_t BARRIERS;
1676    uint32_t USER_EXTENSIONS;
1677#ifdef RTEMS_POSIX_API
1678    /* POSIX API Pieces */
1679    uint32_t POSIX_MUTEXES;
1680    uint32_t POSIX_CONDITION_VARIABLES;
1681    uint32_t POSIX_KEYS;
1682    uint32_t POSIX_TIMERS;
1683    uint32_t POSIX_QUEUED_SIGNALS;
1684    uint32_t POSIX_MESSAGE_QUEUES;
1685    uint32_t POSIX_SEMAPHORES;
1686    uint32_t POSIX_BARRIERS;
1687    uint32_t POSIX_SPINLOCKS;
1688    uint32_t POSIX_RWLOCKS;
1689#endif
1690#ifdef RTEMS_ITRON_API
1691    /* ITRON API Pieces */
1692    uint32_t ITRON_SEMAPHORES;
1693    uint32_t ITRON_EVENTFLAGS;
1694    uint32_t ITRON_MAILBOXES;
1695    uint32_t ITRON_MESSAGE_BUFFERS;
1696    uint32_t ITRON_PORTS;
1697    uint32_t ITRON_MEMORY_POOLS;
1698    uint32_t ITRON_FIXED_MEMORY_POOLS;
1699#endif
1700  } Configuration_Debug_t;
1701
1702  Configuration_Debug_t Configuration_Memory_Debug = {
1703    /* General Information */
1704    CONFIGURE_MEMORY_FOR_SYSTEM_OVERHEAD,
1705    CONFIGURE_MEMORY_FOR_STATIC_EXTENSIONS,
1706    CONFIGURE_INITIALIZATION_THREADS_STACKS,
1707    CONFIGURE_MEMORY_FOR_TASKS(1, 0),
1708    CONFIGURE_MEMORY_FOR_TASKS(0, 1),
1709    CONFIGURE_MEMORY_FOR_CLASSIC,
1710    CONFIGURE_MEMORY_FOR_POSIX,
1711    CONFIGURE_MEMORY_FOR_ITRON,
1712
1713    /* System overhead pieces */
1714    CONFIGURE_INTERRUPT_VECTOR_TABLE,
1715    CONFIGURE_INTERRUPT_STACK_MEMORY,
1716    CONFIGURE_MEMORY_FOR_THREAD_READY_CHAINS,
1717    CONFIGURE_MEMORY_FOR_IDLE_TASK,
1718
1719    /* Classic API Pieces */
1720    CONFIGURE_MEMORY_FOR_TASKS(CONFIGURE_MAXIMUM_TASKS, 0),
1721    CONFIGURE_MEMORY_FOR_TASK_VARIABLES(CONFIGURE_MAXIMUM_TASK_VARIABLES),
1722    CONFIGURE_MEMORY_FOR_TIMERS(CONFIGURE_MAXIMUM_TIMERS),
1723    CONFIGURE_MEMORY_FOR_SEMAPHORES(CONFIGURE_MAXIMUM_SEMAPHORES +
1724       CONFIGURE_LIBIO_SEMAPHORES + CONFIGURE_TERMIOS_SEMAPHORES),
1725    CONFIGURE_MEMORY_FOR_MESSAGE_QUEUES(CONFIGURE_MAXIMUM_MESSAGE_QUEUES),
1726    CONFIGURE_MEMORY_FOR_PARTITIONS(CONFIGURE_MAXIMUM_PARTITIONS),
1727    CONFIGURE_MEMORY_FOR_REGIONS( CONFIGURE_MAXIMUM_REGIONS ),
1728    CONFIGURE_MEMORY_FOR_PORTS(CONFIGURE_MAXIMUM_PORTS),
1729    CONFIGURE_MEMORY_FOR_PERIODS(CONFIGURE_MAXIMUM_PERIODS),
1730    CONFIGURE_MEMORY_FOR_BARRIERS(CONFIGURE_MAXIMUM_BARRIERS),
1731    CONFIGURE_MEMORY_FOR_USER_EXTENSIONS(CONFIGURE_MAXIMUM_USER_EXTENSIONS),
1732
1733#ifdef RTEMS_POSIX_API
1734    /* POSIX API Pieces */
1735    CONFIGURE_MEMORY_FOR_POSIX_MUTEXES( CONFIGURE_MAXIMUM_POSIX_MUTEXES ),
1736    CONFIGURE_MEMORY_FOR_POSIX_CONDITION_VARIABLES(
1737      CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES ),
1738    CONFIGURE_MEMORY_FOR_POSIX_KEYS( CONFIGURE_MAXIMUM_POSIX_KEYS ),
1739    CONFIGURE_MEMORY_FOR_POSIX_QUEUED_SIGNALS(
1740      CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS ),
1741    CONFIGURE_MEMORY_FOR_POSIX_MESSAGE_QUEUES(
1742      CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES ),
1743    CONFIGURE_MEMORY_FOR_POSIX_SEMAPHORES( CONFIGURE_MAXIMUM_POSIX_SEMAPHORES ),
1744    CONFIGURE_MEMORY_FOR_POSIX_BARRIERS( CONFIGURE_MAXIMUM_POSIX_BARRIERS ),
1745    CONFIGURE_MEMORY_FOR_POSIX_SPINLOCKS( CONFIGURE_MAXIMUM_POSIX_SPINLOCKS ),
1746    CONFIGURE_MEMORY_FOR_POSIX_RWLOCKS( CONFIGURE_MAXIMUM_POSIX_RWLOCKS ),
1747    CONFIGURE_MEMORY_FOR_POSIX_TIMERS( CONFIGURE_MAXIMUM_POSIX_TIMERS ),
1748#endif
1749
1750#ifdef RTEMS_ITRON_API
1751    /* ITRON API Pieces */
1752    CONFIGURE_MEMORY_FOR_ITRON_SEMAPHORES( CONFIGURE_MAXIMUM_ITRON_SEMAPHORES ),
1753    CONFIGURE_MEMORY_FOR_ITRON_EVENTFLAGS( CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS ),
1754    CONFIGURE_MEMORY_FOR_ITRON_MAILBOXES( CONFIGURE_MAXIMUM_ITRON_MAILBOXES ),
1755    CONFIGURE_MEMORY_FOR_ITRON_MESSAGE_BUFFERS(
1756        CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS ),
1757    CONFIGURE_MEMORY_FOR_ITRON_PORTS( CONFIGURE_MAXIMUM_ITRON_PORTS ),
1758    CONFIGURE_MEMORY_FOR_ITRON_MEMORY_POOLS( 
1759        CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS ),
1760    CONFIGURE_MEMORY_FOR_ITRON_FIXED_MEMORY_POOLS(
1761        CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS ),
1762#endif
1763  };
1764#endif
1765
1766/**
1767 *  This calculates the memory required for the executive workspace.
1768 */
1769#define CONFIGURE_EXECUTIVE_RAM_SIZE \
1770(( \
1771   CONFIGURE_MEMORY_FOR_SYSTEM_OVERHEAD + \
1772   CONFIGURE_MEMORY_FOR_DEVFS + \
1773   CONFIGURE_MEMORY_FOR_TASKS( \
1774     CONFIGURE_TOTAL_TASKS_AND_THREADS, CONFIGURE_TOTAL_TASKS_AND_THREADS) + \
1775   CONFIGURE_MEMORY_FOR_CLASSIC + \
1776   CONFIGURE_MEMORY_FOR_POSIX + \
1777   (CONFIGURE_MAXIMUM_POSIX_THREADS * CONFIGURE_MINIMUM_TASK_STACK_SIZE ) + \
1778   CONFIGURE_MEMORY_FOR_ITRON + \
1779   CONFIGURE_INITIALIZATION_THREADS_STACKS + \
1780   CONFIGURE_MEMORY_FOR_STATIC_EXTENSIONS + \
1781   CONFIGURE_MEMORY_FOR_MP + \
1782   CONFIGURE_MESSAGE_BUFFER_MEMORY + \
1783   (CONFIGURE_MEMORY_OVERHEAD * 1024) + \
1784   (CONFIGURE_EXTRA_TASK_STACKS) + (CONFIGURE_ADA_TASKS_STACK) \
1785) & ~0x7)
1786#endif
1787
1788#ifdef CONFIGURE_INIT
1789  /**
1790   *  This is the Classic API Configuration Table.
1791   */
1792  rtems_api_configuration_table Configuration_RTEMS_API = {
1793    CONFIGURE_MAXIMUM_TASKS,
1794    CONFIGURE_NOTEPADS_ENABLED,
1795    CONFIGURE_MAXIMUM_TIMERS + CONFIGURE_TIMER_FOR_SHARED_MEMORY_DRIVER,
1796    CONFIGURE_MAXIMUM_SEMAPHORES + CONFIGURE_LIBIO_SEMAPHORES +
1797      CONFIGURE_TERMIOS_SEMAPHORES,
1798    CONFIGURE_MAXIMUM_MESSAGE_QUEUES,
1799    CONFIGURE_MAXIMUM_PARTITIONS,
1800    CONFIGURE_MAXIMUM_REGIONS,
1801    CONFIGURE_MAXIMUM_PORTS,
1802    CONFIGURE_MAXIMUM_PERIODS,
1803    CONFIGURE_MAXIMUM_BARRIERS,
1804    CONFIGURE_INIT_TASK_TABLE_SIZE,
1805    CONFIGURE_INIT_TASK_TABLE
1806  };
1807
1808  #ifdef RTEMS_POSIX_API
1809    /**
1810     *  This is the POSIX API Configuration Table.
1811     */
1812    posix_api_configuration_table Configuration_POSIX_API = {
1813      CONFIGURE_MAXIMUM_POSIX_THREADS + CONFIGURE_MAXIMUM_ADA_TASKS,
1814      CONFIGURE_MAXIMUM_POSIX_MUTEXES + CONFIGURE_GNAT_MUTEXES +
1815        CONFIGURE_MAXIMUM_ADA_TASKS + CONFIGURE_MAXIMUM_FAKE_ADA_TASKS,
1816      CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES +
1817        CONFIGURE_MAXIMUM_ADA_TASKS + CONFIGURE_MAXIMUM_FAKE_ADA_TASKS,
1818      CONFIGURE_MAXIMUM_POSIX_KEYS,
1819      CONFIGURE_MAXIMUM_POSIX_TIMERS,
1820      CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS,
1821      CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES,
1822      CONFIGURE_MAXIMUM_POSIX_SEMAPHORES,
1823      CONFIGURE_MAXIMUM_POSIX_BARRIERS,
1824      CONFIGURE_MAXIMUM_POSIX_RWLOCKS,
1825      CONFIGURE_MAXIMUM_POSIX_SPINLOCKS,
1826      CONFIGURE_POSIX_INIT_THREAD_TABLE_SIZE,
1827      CONFIGURE_POSIX_INIT_THREAD_TABLE_NAME
1828    };
1829  #endif
1830
1831  #ifdef RTEMS_ITRON_API
1832    /**
1833     *  This is the ITRON API Configuration Table.
1834     */
1835    itron_api_configuration_table Configuration_ITRON_API = {
1836      CONFIGURE_MAXIMUM_ITRON_TASKS,
1837      CONFIGURE_MAXIMUM_ITRON_SEMAPHORES,
1838      CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS,
1839      CONFIGURE_MAXIMUM_ITRON_MAILBOXES,
1840      CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS,
1841      CONFIGURE_MAXIMUM_ITRON_PORTS,
1842      CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS,
1843      CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS,
1844      CONFIGURE_ITRON_INIT_TASK_TABLE_SIZE,
1845      CONFIGURE_ITRON_INIT_TASK_TABLE_NAME
1846    };
1847  #endif
1848
1849  /** This variable specifies the minimum stack size for tasks in an RTEMS
1850   *  application.
1851   *
1852   *  @note This is left as a simple uint32_t so it can be externed as
1853   *        needed without requring being high enough logical to
1854   *        include the full configuration table.
1855   */
1856  uint32_t rtems_minimum_stack_size = 
1857    CONFIGURE_MINIMUM_TASK_STACK_SIZE;
1858
1859  /** This variable specifies the maximum priority value that
1860   *  a task may have.  This must be a power of 2 between 4
1861   *  and 256 and is specified in terms of Classic API
1862   *  priority values.
1863   *
1864   *  @note This is left as a simple uint8_t so it can be externed as
1865   *        needed without requring being high enough logical to
1866   *        include the full configuration table.
1867   */
1868  uint8_t rtems_maximum_priority = CONFIGURE_MAXIMUM_PRIORITY;
1869
1870  /**
1871   *  This is the primary Configuration Table for this application.
1872   */
1873  rtems_configuration_table Configuration = {
1874    NULL,                                     /* filled in by BSP */
1875    CONFIGURE_EXECUTIVE_RAM_SIZE,             /* required RTEMS workspace */
1876    CONFIGURE_MAXIMUM_USER_EXTENSIONS,        /* maximum dynamic extensions */
1877    CONFIGURE_MICROSECONDS_PER_TICK,          /* microseconds per clock tick */
1878    CONFIGURE_TICKS_PER_TIMESLICE,            /* ticks per timeslice quantum */
1879    CONFIGURE_IDLE_TASK_BODY,                 /* user's IDLE task */
1880    CONFIGURE_IDLE_TASK_STACK_SIZE,           /* IDLE task stack size */
1881    CONFIGURE_INTERRUPT_STACK_SIZE,           /* interrupt stack size */
1882    CONFIGURE_TASK_STACK_ALLOCATOR,           /* stack allocator */
1883    CONFIGURE_TASK_STACK_DEALLOCATOR,         /* stack deallocator */
1884    CONFIGURE_ZERO_WORKSPACE_AUTOMATICALLY,   /* true to clear memory */
1885    CONFIGURE_MAXIMUM_DRIVERS,                /* maximum device drivers */
1886    CONFIGURE_NUMBER_OF_DRIVERS,              /* static device drivers */
1887    Device_drivers,                           /* pointer to driver table */
1888    CONFIGURE_NUMBER_OF_INITIAL_EXTENSIONS,   /* number of static extensions */
1889    CONFIGURE_INITIAL_EXTENSION_TABLE,        /* pointer to static extensions */
1890    #if defined(RTEMS_MULTIPROCESSING)
1891      CONFIGURE_MULTIPROCESSING_TABLE,        /* pointer to MP config table */
1892    #endif
1893  };
1894#endif
1895
1896#endif /* CONFIGURE_HAS_OWN_CONFIGURATION_TABLE */
1897
1898/*
1899 *  If the user has configured a set of Classic API Initialization Tasks,
1900 *  then we need to install the code that runs that loop.
1901 */
1902#ifdef CONFIGURE_INIT
1903  #ifdef CONFIGURE_RTEMS_INIT_TASKS_TABLE
1904    void (_RTEMS_tasks_Initialize_user_tasks_body)(void);
1905    void (*_RTEMS_tasks_Initialize_user_tasks_p)(void) =
1906              _RTEMS_tasks_Initialize_user_tasks_body;
1907  #else
1908    void (*_RTEMS_tasks_Initialize_user_tasks_p)(void) = NULL;
1909  #endif
1910#endif
1911
1912/*
1913 *  If the user has configured a set of POSIX Initialization Threads,
1914 *  then we need to install the code that runs that loop.
1915 */
1916#ifdef RTEMS_POSIX_API
1917  #ifdef CONFIGURE_INIT
1918    #ifdef CONFIGURE_POSIX_INIT_THREAD_TABLE
1919      void _POSIX_Threads_Initialize_user_threads_body(void);
1920      void (*_POSIX_Threads_Initialize_user_threads_p)(void) = 
1921                _POSIX_Threads_Initialize_user_threads_body;
1922    #else
1923      void (*_POSIX_Threads_Initialize_user_threads_p)(void) = NULL;
1924    #endif
1925  #endif
1926#endif
1927
1928/*
1929 *  If the user has configured a set of ITRON Initialization Tasks,
1930 *  then we need to install the code that runs that loop.
1931 */
1932#ifdef RTEMS_ITRON_API
1933  #ifdef CONFIGURE_INIT
1934    #ifdef CONFIGURE_ITRON_INIT_TASK_TABLE
1935      void _ITRON_Task_Initialize_user_tasks_body(void);
1936      void (*_ITRON_Initialize_user_tasks_p)(void) = 
1937                _ITRON_Task_Initialize_user_tasks_body;
1938    #else
1939      void (*_ITRON_Initialize_user_tasks_p)(void) = NULL;
1940    #endif
1941  #endif
1942#endif
1943
1944#ifdef __cplusplus
1945}
1946#endif
1947
1948/******************************************************************
1949 ******************************************************************
1950 ******************************************************************
1951 *         CONFIGURATION WARNINGS AND ERROR CHECKING              *
1952 ******************************************************************
1953 ******************************************************************
1954 ******************************************************************
1955 */
1956
1957/*
1958 *  Make sure a task/thread of some sort is configured.
1959 *
1960 *  When analyzing RTEMS to find the smallest possible of memory
1961 *  that must be allocated, you probably do want to configure 0
1962 *  tasks/threads so there is a smaller set of calls to _Workspace_Allocate
1963 *  to analyze.
1964 */
1965#if !defined(CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION)
1966  #if (CONFIGURE_MAXIMUM_TASKS == 0) && \
1967      (CONFIGURE_MAXIMUM_POSIX_THREADS == 0) && \
1968      (CONFIGURE_MAXIMUM_ADA_TASKS == 0) &&  \
1969      (CONFIGURE_MAXIMUM_ITRON_TASKS == 0)
1970    #error "CONFIGURATION ERROR: No tasks or threads configured!!"
1971  #endif
1972#endif
1973
1974/*
1975 *  Make sure at least one of the initialization task/thread
1976 *  tables was defined.
1977 */
1978#if !defined(CONFIGURE_RTEMS_INIT_TASKS_TABLE) && \
1979    !defined(CONFIGURE_POSIX_INIT_THREAD_TABLE) && \
1980    !defined(CONFIGURE_ITRON_INIT_TASK_TABLE) && \
1981    !defined(CONFIGURE_IDLE_TASK_INITIALIZES_APPLICATION)
1982#error "CONFIGURATION ERROR: No initialization tasks or threads configured!!"
1983#endif
1984
1985/*
1986 *  If the user is trying to configure a multiprocessing application and
1987 *  RTEMS was not configured and built multiprocessing, then error out.
1988 */
1989#if defined(CONFIGURE_MP_APPLICATION) && \
1990    !defined(RTEMS_MULTIPROCESSING)
1991#error "CONFIGURATION ERROR: RTEMS not configured for multiprocessing!!"
1992#endif
1993
1994/*
1995 *  If an attempt was made to configure POSIX objects and
1996 *  the POSIX API was not configured into RTEMS, error out.
1997 */
1998#if !defined(RTEMS_POSIX_API)
1999  #if ((CONFIGURE_MAXIMUM_POSIX_THREADS != 0) || \
2000       (CONFIGURE_MAXIMUM_POSIX_MUTEXES != 0) || \
2001       (CONFIGURE_MAXIMUM_POSIX_CONDITION_VARIABLES != 0) || \
2002       (CONFIGURE_MAXIMUM_POSIX_KEYS != 0) || \
2003       (CONFIGURE_MAXIMUM_POSIX_TIMERS != 0) || \
2004       (CONFIGURE_MAXIMUM_POSIX_QUEUED_SIGNALS != 0) || \
2005       (CONFIGURE_MAXIMUM_POSIX_MESSAGE_QUEUES != 0) || \
2006       (CONFIGURE_MAXIMUM_POSIX_SEMAPHORES != 0) || \
2007       (CONFIGURE_MAXIMUM_POSIX_BARRIERS != 0) || \
2008       (CONFIGURE_MAXIMUM_POSIX_SPINLOCKS != 0) || \
2009       (CONFIGURE_MAXIMUM_POSIX_RWLOCKS != 0) || \
2010      defined(CONFIGURE_POSIX_INIT_THREAD_TABLE))
2011  #error "CONFIGURATION ERROR: POSIX API support not configured!!"
2012  #endif
2013#endif
2014
2015/*
2016 *  If an attempt was made to configure ITRON objects and
2017 *  the ITRON API was not configured into RTEMS, error out.
2018 */
2019#if !defined(RTEMS_ITRON_API)
2020  #if ((CONFIGURE_MAXIMUM_ITRON_TASKS != 0) || \
2021       (CONFIGURE_MAXIMUM_ITRON_SEMAPHORES != 0) || \
2022       (CONFIGURE_MAXIMUM_ITRON_EVENTFLAGS != 0) || \
2023       (CONFIGURE_MAXIMUM_ITRON_MAILBOXES != 0) || \
2024       (CONFIGURE_MAXIMUM_ITRON_MESSAGE_BUFFERS != 0) || \
2025       (CONFIGURE_MAXIMUM_ITRON_PORTS != 0) || \
2026       (CONFIGURE_MAXIMUM_ITRON_MEMORY_POOLS != 0) || \
2027       (CONFIGURE_MAXIMUM_ITRON_FIXED_MEMORY_POOLS != 0) || \
2028      defined(CONFIGURE_ITRON_INIT_TASK_TABLE))
2029  #error "CONFIGURATION ERROR: ITRON API support not configured!!"
2030  #endif
2031#endif
2032
2033/*
2034 *  You must either explicity include or exclude the clock driver.
2035 *  It is such a common newbie error to leave it out.  Maybe this
2036 *  will put an end to it.
2037 * 
2038 *  NOTE: If you are using the timer driver, it is considered
2039 *        mutually exclusive with the clock driver because the
2040 *        drivers are assumed to use the same "timer" hardware
2041 *        on many boards.
2042 */
2043#if !defined(CONFIGURE_HAS_OWN_DEVICE_DRIVER_TABLE)
2044  #if !defined(CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER) && \
2045      !defined(CONFIGURE_APPLICATION_DOES_NOT_NEED_CLOCK_DRIVER) && \
2046      !defined(CONFIGURE_APPLICATION_NEEDS_TIMER_DRIVER)
2047    #error "CONFIGURATION ERROR: Do you want the clock driver or not?!?"
2048   #endif
2049#endif
2050
2051/*
2052 *  These names have been obsoleted so make the user application stop compiling
2053 */
2054#if defined(CONFIGURE_TEST_NEEDS_TIMER_DRIVER) || \
2055    defined(CONFIGURE_TEST_NEEDS_CONSOLE_DRIVER) || \
2056    defined(CONFIGURE_TEST_NEEDS_CLOCK_DRIVER) || \
2057    defined(CONFIGURE_TEST_NEEDS_RTC_DRIVER) || \
2058    defined(CONFIGURE_TEST_NEEDS_STUB_DRIVER)
2059#error "CONFIGURATION ERROR: CONFIGURE_TEST_XXX constants are obsolete"
2060#endif
2061
2062/*
2063 *  Validate the configured maximum priority
2064 */
2065#if ((CONFIGURE_MAXIMUM_PRIORITY != 3) && \
2066     (CONFIGURE_MAXIMUM_PRIORITY != 7) && \
2067     (CONFIGURE_MAXIMUM_PRIORITY != 15) && \
2068     (CONFIGURE_MAXIMUM_PRIORITY != 31) && \
2069     (CONFIGURE_MAXIMUM_PRIORITY != 63) && \
2070     (CONFIGURE_MAXIMUM_PRIORITY != 127) && \
2071     (CONFIGURE_MAXIMUM_PRIORITY != 255))
2072  #error "Maximum priority is not 1 less than a power of 2 between 4 and 256"
2073#endif
2074   
2075#if (CONFIGURE_MAXIMUM_PRIORITY > PRIORITY_DEFAULT_MAXIMUM)
2076  #error "Maximum priority configured higher than supported by target."
2077#endif
2078
2079#endif
2080/* end of include file */
Note: See TracBrowser for help on using the repository browser.