Mercurial > flash_v2

comparison packages/kernel/current/include/pkgconf/kernel.h @ 0:3111d98ba7b3 ecos-v1_1-release

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial commit of eCos version 1.1
author jlarmour
date Tue, 11 May 1999 11:16:07 +0000
parents
children 443894e2e912
comparison
equal deleted inserted replaced
-1:000000000000 0:3111d98ba7b3
1 #ifndef CYGONCE_PKGCONF_KERNEL_H
2 #define CYGONCE_PKGCONF_KERNEL_H
3 // ====================================================================
4 //
5 // pkgconf/kernel.h
6 //
7 // Kernel configuration file
8 //
9 // ====================================================================
10 //####COPYRIGHTBEGIN####
11 //
12 // -------------------------------------------
13 // The contents of this file are subject to the Cygnus eCos Public License
14 // Version 1.0 (the "License"); you may not use this file except in
15 // compliance with the License. You may obtain a copy of the License at
16 // http://sourceware.cygnus.com/ecos
17 //
18 // Software distributed under the License is distributed on an "AS IS"
19 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
20 // License for the specific language governing rights and limitations under
21 // the License.
22 //
23 // The Original Code is eCos - Embedded Cygnus Operating System, released
24 // September 30, 1998.
25 //
26 // The Initial Developer of the Original Code is Cygnus. Portions created
27 // by Cygnus are Copyright (C) 1998 Cygnus Solutions. All Rights Reserved.
28 // -------------------------------------------
29 //
30 //####COPYRIGHTEND####
31 // ====================================================================
32 //#####DESCRIPTIONBEGIN####
33 //
34 // Author(s): nickg
35 // Contributors: nickg
36 // Date: 1997-09-29
37 // Purpose: To allow the user to edit kernel configuration options.
38 // Description:
39 //
40 //####DESCRIPTIONEND####
41 //
42 // ====================================================================
43
44 /* ---------------------------------------------------------------------
45 * Some of the kernel configuration options depend on global options,
46 * so it is necessary to include the global options first.
47 */
48
49 #include <pkgconf/system.h>
50
51 /* Only define options if the kernel is to be present */
52 #ifdef CYGPKG_KERNEL
53
54 #include <pkgconf/hal.h>
55 #include <pkgconf/infra.h>
56
57 /* ---------------------------------------------------------------------
58 * The overall package definition.
59
60 {{CFG_DATA
61
62 cdl_package CYGPKG_KERNEL {
63 display "eCos kernel"
64 type boolean
65 requires CYGFUN_HAL_COMMON_KERNEL_SUPPORT
66 description "
67 This package contains the core functionality of the eCos
68 kernel. It relies on functionality provided by various HAL
69 packages and by the eCos infrastructure. In turn the eCos
70 kernel provides support for other packages such as the device
71 drivers and the uITRON compatibility layer."
72 doc ref/ecos-ref/ecos-kernel-overview.html
73 }
74
75 }}CFG_DATA */
76
77 /* ---------------------------------------------------------------------
78 * The first component within the kernel is related to interrupt
79 * handling.
80 {{CFG_DATA
81
82 cdl_component CYGPKG_KERNEL_INTERRUPTS {
83 display "Kernel interrupt handling"
84 parent CYGPKG_KERNEL
85 type dummy
86 description "
87 The majority of configuration options related to interrupt
88 handling are in the HAL packages, since usually the code has
89 to be platform-specific. There are a number of options
90 provided within the kernel related to slightly higher-level
91 concepts, for example Delayed Service Routines."
92 doc ref/ecos-ref/interrupts.html
93 }
94
95 # In the absence of active-if support this has to be
96 # a sub-component. It does not use the CYGPKG_ prefix to make
97 # it easier to change back into an ordinary option later on.
98 cdl_component CYGIMP_KERNEL_INTERRUPTS_DSRS {
99 display "Use delayed service routines (DSRs)"
100 parent CYGPKG_KERNEL_INTERRUPTS
101 description "
102 In eCos the recommended way to handle device interrupts is to
103 do a minimum amount of work inside the low level interrupt
104 handler itself, and instead do as much as possible in a
105 Delayed Service Routine or DSR. If an application does not
106 make use of DSRs directly or indirectly then it is possible
107 to disable the DSR support completely, which reduces the
108 overheads of context switches and interrupt handling. Note
109 that the kernel real-time clock makes use of DSRs, as do many
110 of the device drivers. "
111 doc ref/ecos-ref/interrupt-and-exception-handlers.html
112 }
113
114 # NOTE: the choice of list vs table should not be two separate
115 # options. There is a single option which must have one of
116 # two legal values.
117 cdl_option CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST {
118 display "Use linked lists for DSRs"
119 parent CYGIMP_KERNEL_INTERRUPTS_DSRS
120 type radio
121 description "
122 When DSR support is enabled the kernel must keep track of all
123 the DSRs that are pending. This information can be kept in a
124 fixed-size table or in a linked list. The list implementation
125 requires that the kernel disable interrupts for a very short
126 period of time outside interrupt handlers, but there is no
127 possibility of a table overflow occurring."
128 doc ref/ecos-ref/interrupts.html
129 }
130
131 cdl_option CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE {
132 display "Use fixed-size table for DSRs"
133 parent CYGIMP_KERNEL_INTERRUPTS_DSRS
134 type radio
135 description "
136 When DSR support is enabled the kernel must keep track of all
137 the DSRs that are pending. This information can be kept in a
138 fixed-size table or in a linked list. The table
139 implementation involves a very small risk of overflow at
140 run-time if a given interrupt source is able to have more
141 than one pending DSR. However it has the advantage that
142 the kernel does not need to disable interrupts outside
143 interrupt handlers."
144 doc ref/ecos-ref/interrupts.html
145 }
146
147 cdl_option CYGNUM_KERNEL_INTERRUPTS_DSRS_TABLE_SIZE {
148 display "Number of entries in fixed-size DSR table"
149 parent CYGIMP_KERNEL_INTERRUPTS_DSRS
150 type count
151 legal_values 2 to 1024
152 #active_if CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE
153 description "
154 When DSR support is enabled the kernel must keep track of all
155 the DSRs that are pending. One approach involves a fixed-size
156 table, which involves a very small risk of overflow at
157 run-time. By increasing the table size it is possible to reduce
158 this risk."
159 doc ref/ecos-ref/interrupts.html
160 }
161
162 cdl_option CYGIMP_KERNEL_INTERRUPTS_CHAIN {
163 display "Chain all interrupts together"
164 parent CYGPKG_KERNEL_INTERRUPTS
165 requires CYGIMP_HAL_COMMON_INTERRUPTS_CHAIN
166 description "
167 Interrupts can be attached to vectors either singly, or be
168 chained together. The latter is necessary if there is no way
169 of discovering which device has interrupted without
170 inspecting the device itself. It can also reduce the amount
171 of RAM needed for interrupt decoding tables and code."
172 doc ref/ecos-ref/interrupts.html
173 }
174
175 }}CFG_DATA */
176
177 #define CYGIMP_KERNEL_INTERRUPTS_DSRS
178 #define CYGIMP_KERNEL_INTERRUPTS_DSRS_LIST
179 #undef CYGIMP_KERNEL_INTERRUPTS_DSRS_TABLE
180 #define CYGNUM_KERNEL_INTERRUPTS_DSRS_TABLE_SIZE 32
181 #undef CYGIMP_KERNEL_INTERRUPTS_CHAIN
182
183 /* ---------------------------------------------------------------------
184 * Exceptions. Currently there are only two options. The first
185 * determines whether or not exceptions are enabled at all. The
186 * second controls whether they apply globally or on a per-thread
187 * basis. There should probably be more options, but the boundary
188 * between the HAL and kernel becomes blurred.
189
190 {{CFG_DATA
191
192 cdl_component CYGPKG_KERNEL_EXCEPTIONS {
193 display "Exception handling"
194 parent CYGPKG_KERNEL
195 requires CYGPKG_HAL_EXCEPTIONS
196 description "
197 In the context of the eCos kernel exceptions are unexpected
198 events detected by the hardware, for example an attempt to
199 execute an illegal instruction. There is no relation with
200 other forms of exception, for example the catch and throw
201 facilities of languages like C++. It is possible to disable
202 all support for exceptions and thus save some memory."
203 doc ref/ecos-ref/exceptions.html
204 }
205
206 cdl_option CYGSEM_KERNEL_EXCEPTIONS_DECODE {
207 display "Decode exception types in kernel"
208 parent CYGPKG_KERNEL_EXCEPTIONS
209 description "
210 On targets where several different types of exception are
211 possible, for example executing an illegal instruction and
212 division by zero, it is possible for the kernel to do some
213 decoding of the exception type and deliver the different
214 types of exception to different handlers in the application
215 code. Alternatively the kernel can simply pass all
216 exceptions directly to application code, leaving the
217 decoding to be done by the application"
218 doc ref/ecos-ref/exceptions.html
219 }
220
221 cdl_option CYGSEM_KERNEL_EXCEPTIONS_GLOBAL {
222 display "Use global exception handlers"
223 parent CYGPKG_KERNEL_EXCEPTIONS
224 description "
225 In the context of the eCos kernel exceptions are unexpected
226 events detected by the hardware, for example an attempt to
227 execute an illegal instruction. If the kernel is configured
228 to support exceptions then two implementations are
229 possible. The default implementation involves a single set
230 of exception handlers that are in use for the entire
231 system. The alternative implementation allows different
232 exception handlers to be specified for each thread."
233 doc ref/ecos-ref/exceptions.html
234 }
235
236 }}CFG_DATA */
237
238 #define CYGPKG_KERNEL_EXCEPTIONS
239 #undef CYGSEM_KERNEL_EXCEPTIONS_DECODE
240 #define CYGSEM_KERNEL_EXCEPTIONS_GLOBAL
241
242
243 /* ---------------------------------------------------------------------
244 * {{CFG_DATA
245
246 cdl_component CYGPKG_KERNEL_SCHED {
247 display "Kernel schedulers"
248 type dummy
249 parent CYGPKG_KERNEL
250 description "
251 The eCos kernel provides a choice of schedulers. In addition
252 there are a number of configuration options to control the
253 detailed behaviour of these schedulers.
254 "
255 doc ref/ecos-ref/ecos-kernel-overview.html#THE-SCHEDULER
256 }
257
258 cdl_option CYGSEM_KERNEL_SCHED_MLQUEUE {
259 display "Multi-level queue scheduler"
260 type radio
261 parent CYGPKG_KERNEL_SCHED
262 description "
263 The multi-level queue scheduler supports multiple priority
264 levels and multiple threads at each priority level.
265 Preemption between priority levels is automatic. Timeslicing
266 within a given priority level is controlled by a separate
267 configuration option"
268 doc ref/ecos-ref/ecos-kernel-overview.html#THE-SCHEDULER
269 }
270
271 cdl_option CYGSEM_KERNEL_SCHED_BITMAP {
272 display "Bitmap scheduler"
273 type radio
274 parent CYGPKG_KERNEL_SCHED
275 description "
276 The bitmap scheduler supports multiple priority levels but
277 only one thread can exist at each priority level. This means
278 that scheduling decisions are very simple and hence the
279 scheduler is efficient. Preemption between priority levels is
280 automatic. Timeslicing within a given priority level is
281 irrelevant since there can be only one thread at each
282 priority level."
283 doc ref/ecos-ref/ecos-kernel-overview.html#THE-SCHEDULER
284 }
285
286 #cdl_option CYGSEM_KERNEL_SCHED_LOTTERY {
287 # display "Lottery scheduler"
288 # type radio
289 # parent CYGPKG_KERNEL_SCHED
290 # description "
291 # This scheduler is not yet available."
292 #}
293
294 # NOTE: this option only makes sense if the current scheduler
295 # supports multiple priority levels.
296 cdl_option CYGNUM_KERNEL_SCHED_PRIORITIES {
297 display "Number of priority levels"
298 type count
299 legal_values 1 to 32
300 parent CYGPKG_KERNEL_SCHED
301 #active_if CYGINT_KERNEL_SCHED_PRIORITY_SCHEDULER
302 description "
303 This option controls the number of priority levels that are
304 available. For some types of scheduler including the bitmap
305 scheduler this may impose an upper bound on the number of
306 threads in the system. For other schedulers such as the
307 mlqueue scheduler the number of threads is independent from
308 the number of priority levels. Note that the lowest priority
309 level is normally used only by the idle thread, although
310 application threads can run at this priority if necessary."
311 doc ref/ecos-ref/ecos-kernel-overview.html#THE-SCHEDULER
312 }
313
314 # NOTE: this option only makes sense for some of the schedulers.
315 # Timeslicing is irrelevant for bitmap schedulers.
316 cdl_option CYGSEM_KERNEL_SCHED_TIMESLICE {
317 display "Scheduler timeslicing"
318 parent CYGPKG_KERNEL_SCHED
319 requires !CYGSEM_KERNEL_SCHED_BITMAP
320 requires CYGVAR_KERNEL_COUNTERS_CLOCK
321 description "
322 Some schedulers including the mlqueue scheduler support
323 timeslicing. This means that the kernel will check regularly
324 whether or not there is another runnable thread with the
325 same priority, and if there is such a thread there will be
326 an automatic context switch. Not all applications require
327 timeslicing, for example because every thread performs a
328 blocking operation regularly. For these applications it is
329 possible to disable timeslicing, which reduces the overheads
330 associated with timer interrupts."
331 }
332
333 cdl_option CYGNUM_KERNEL_SCHED_TIMESLICE_TICKS {
334 display "Number of clock ticks between timeslices"
335 parent CYGPKG_KERNEL_SCHED
336 type count
337 legal_values 1 to 65535
338 #active_if CYGSEM_KERNEL_SCHED_TIMESLICE
339 description "
340 Assuming timeslicing is enabled, how frequently should it
341 take place? The value of this option corresponds to the
342 number of clock ticks that should occur before a timeslice
343 takes place, so increasing the value reduces the frequency
344 of timeslices."
345 }
346
347 }}CFG_DATA */
348
349 #define CYGSEM_KERNEL_SCHED_MLQUEUE
350 #undef CYGSEM_KERNEL_SCHED_BITMAP
351 #undef CYGSEM_KERNEL_SCHED_LOTTERY
352 #define CYGNUM_KERNEL_SCHED_PRIORITIES 32
353 #define CYGSEM_KERNEL_SCHED_TIMESLICE
354 #define CYGNUM_KERNEL_SCHED_TIMESLICE_TICKS 5
355
356 /* ---------------------------------------------------------------------
357 * Counters and clocks.
358
359 {{CFG_DATA
360
361 cdl_component CYGPKG_KERNEL_COUNTERS {
362 display "Counters and clocks"
363 parent CYGPKG_KERNEL
364 type dummy
365 description "
366 The counter objects provided by the kernel provide an
367 abstraction of the clock facility that is generally provided.
368 Application code can associate alarms with counters, where an
369 alarm is identified by the number of ticks until it triggers,
370 the action to be taken on triggering, and whether or not the
371 alarm should be repeated."
372 doc ref/ecos-ref/counters-clocks-and-alarms.html
373 }
374
375 cdl_option CYGVAR_KERNEL_COUNTERS_CLOCK {
376 display "Provide real-time clock"
377 parent CYGPKG_KERNEL_COUNTERS
378 requires CYGIMP_KERNEL_INTERRUPTS_DSRS
379 description "
380 On all current target systems the kernel can provide a
381 real-time clock. This clock serves two purposes. First it is
382 necessary to support clock and alarm related functions.
383 Second it is needed to implement timeslicing in some of the
384 schedulers including the mlqueue scheduler. If the
385 application does not require any of these facilities then it
386 is possible to disable the real time clock support
387 completely."
388 doc ref/ecos-ref/counters-clocks-and-alarms.html
389 }
390
391 cdl_component CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE {
392 display "Override default clock settings"
393 parent CYGPKG_KERNEL_COUNTERS
394 requires CYGVAR_KERNEL_COUNTERS_CLOCK
395 type bool
396 description "
397 The kernel has default settings for the clock interrupt
398 frequency. These settings will vary from platform to
399 platform, but typically there will be a 100 clock interrupts
400 every second. It is possible to change this frequency, but
401 it requires some knowledge of the target hardware.
402 "
403 }
404
405 cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD {
406 display "Clock hardware initialization value"
407 parent CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE
408 type count
409 legal_values 1 to 0x7fffffff
410 description "
411 During system initialization this value is used to initialize
412 the clock hardware. The exact meaning of the value and the
413 range of legal values therefore depends on the target hardware,
414 and the hardware documentation should be consulted for further
415 details. In addition the clock resolution numerator and
416 denominator values should be updated. Typical values for
417 this option would be 150000 on the MN10300 stdeval1 board,
418 15625 on the tx39 jmr3904 board, and 20625 on the powerpc
419 cogent board."
420 }
421
422 cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR {
423 display "Clock resolution numerator"
424 parent CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE
425 type count
426 legal_values 1 to 0x7fffffff
427 description "
428 If a non-default clock interrupt frequency is used then it
429 is necessary to specify the clock resolution explicitly.
430 This resolution involves two separate values, the numerator
431 and the denominator. The result of dividing the numerator by
432 the denominator should correspond to the number of
433 nanoseconds between clock interrupts. For example a
434 numerator of 1000000000 and a denominator of 100 means that
435 there are 10000000 nanoseconds (or 10 milliseconds) between
436 clock interrupts. Expressing the resolution as a fraction
437 should minimize clock drift even for frequencies that cannot
438 be expressed as a simple integer. For example a frequency of
439 60Hz corresponds to a clock resolution of 16666666.66...
440 nanoseconds. This can be expressed accurately as 1000000000
441 over 60."
442 }
443
444 cdl_option CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR {
445 display "Clock resolution denominator"
446 parent CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE
447 type count
448 legal_values 1 to 0x7fffffff
449 description "
450 If a non-default clock interrupt frequency is used then it
451 is necessary to specify the clock resolution explicitly.
452 This resolution involves two separate values, the numerator
453 and the denominator. The result of dividing the numerator by
454 the denominator should correspond to the number of
455 nanoseconds between clock interrupts. For example a
456 numerator of 1000000000 and a denominator of 100 means that
457 there are 10000000 nanoseconds (or 10 milliseconds) between
458 clock interrupts. Expressing the resolution as a fraction
459 should minimize clock drift even for frequencies that cannot
460 be expressed as a simple integer. For example a frequency of
461 60Hz corresponds to a clock resolution of 16666666.66...
462 nanoseconds. This can be expressed accurately as 1000000000
463 over 60."
464 }
465
466
467 # NOTE: these option should really be a single enum.
468 cdl_option CYGIMP_KERNEL_COUNTERS_SINGLE_LIST {
469 display "Implement counters using a single list"
470 parent CYGPKG_KERNEL_COUNTERS
471 type radio
472 description "
473 There are two different implementations of the counter
474 objects. The first implementation stores all alarms in a
475 single linked list. The alternative implementation uses a
476 table of linked lists. A single list is more efficient in
477 terms of memory usage and is generally adequate when the
478 application only makes use of a small number of alarms."
479 doc ref/ecos-ref/counters-clocks-and-alarms.html
480 }
481
482 cdl_option CYGIMP_KERNEL_COUNTERS_MULTI_LIST {
483 display "Implement counters using a table of lists"
484 parent CYGPKG_KERNEL_COUNTERS
485 type radio
486 description "
487 There are two different implementations of the counter
488 objects. The first implementation stores all alarms in a
489 single linked list. The alternative implementation uses a
490 table of linked lists, with the size of the table being a
491 separate configurable option. For more complicated
492 operations it is better to have a table of lists since this
493 reduces the amount of computation whenever the timer goes
494 off. Assuming a table size of 8 (the default value) on
495 average the timer code will only need to check 1/8 of the
496 pending alarms instead of all of them."
497 doc ref/ecos-ref/counters-clocks-and-alarms.html
498 }
499
500 cdl_option CYGNUM_KERNEL_COUNTERS_MULTI_LIST_SIZE {
501 display "Size of counter list table"
502 parent CYGPKG_KERNEL_COUNTERS
503 type count
504 legal_values 1 to 1024
505 #active_if CYGIMP_KERNEL_COUNTERS_MULTI_LIST
506 description "
507 If counters are implemented using an array of linked lists
508 then this option controls the size of the array. A larger
509 size reduces the amount of computation that needs to take
510 place whenever the timer goes off, but requires extra
511 memory."
512 doc ref/ecos-ref/counters-clocks-and-alarms.html
513 }
514
515 }}CFG_DATA */
516
517 #define CYGVAR_KERNEL_COUNTERS_CLOCK
518 #undef CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE
519 #define CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD 9999
520 #define CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR 1000000000
521 #define CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR 100
522 #define CYGIMP_KERNEL_COUNTERS_SINGLE_LIST
523 #undef CYGIMP_KERNEL_COUNTERS_MULTI_LIST
524 #define CYGNUM_KERNEL_COUNTERS_MULTI_LIST_SIZE 8
525
526 /* ---------------------------------------------------------------------
527 * Thread-related options
528 {{CFG_DATA
529
530 cdl_component CYGPKG_KERNEL_THREADS {
531 display "Thread-related options"
532 type dummy
533 parent CYGPKG_KERNEL
534 description "
535 There are a number of configuration options related to the
536 implementation of threads, for example whether or not the
537 eCos kernel supports per-thread data."
538 doc ref/ecos-ref/thread-operations.html
539 }
540
541 cdl_option CYGFUN_KERNEL_THREADS_TIMER {
542 display "Allow per-thread timers"
543 parent CYGPKG_KERNEL_THREADS
544 requires CYGVAR_KERNEL_COUNTERS_CLOCK
545 description "
546 This option controls whether or not the kernel should support
547 per-thread clock and alarm related functions. Also some of
548 the synchronization primitives such as semaphore and
549 condition variable timed wait operations require per-thread
550 timer support. If none of these facilities are required then
551 the option can be disabled."
552 doc ref/ecos-ref/thread-operations.html
553 }
554
555 cdl_option CYGVAR_KERNEL_THREADS_NAME {
556 display "Support optional name for each thread"
557 parent CYGPKG_KERNEL_THREADS
558 description "
559 Threads may optionally be supplied with a name string that is
560 used to identify them during debugging. This name is only
561 present if `this option is defined. Disabling it reduces both
562 code and data size."
563 doc ref/ecos-ref/thread-operations.html
564 }
565
566 cdl_option CYGVAR_KERNEL_THREADS_LIST {
567 display "Keep track of all threads using a linked list"
568 parent CYGPKG_KERNEL_THREADS
569 description "
570 Threads may optionally be placed on a housekeeping list so
571 that all threads may be located easily. This is useful mainly
572 in conjunction with source-level debugging."
573 doc ref/ecos-ref/thread-operations.html
574 }
575
576 cdl_option CYGFUN_KERNEL_THREADS_STACK_LIMIT {
577 display "Keep track of the base of each thread's stack"
578 parent CYGPKG_KERNEL_THREADS
579 description "
580 This option makes the kernel keep track of the lower limit on
581 each thread's stack. It allows the kernel to adjust the lower
582 limit, thus making space for per-thread data. Note that it
583 does not imply any form of run-time stack overflow checking."
584 doc ref/ecos-ref/thread-operations.html
585 }
586
587 cdl_option CYGVAR_KERNEL_THREADS_DATA {
588 display "Support for per-thread data"
589 parent CYGPKG_KERNEL_THREADS
590 requires CYGFUN_KERNEL_THREADS_STACK_LIMIT
591 description "
592 It is possible for the kernel to support per-thread data, in
593 other words an area of memory specific to each thread which
594 can be used to store data for that thread. This per-thread
595 data can be used by applications or by other packages such as
596 the ISO C library."
597 doc ref/ecos-ref/thread-operations.html
598 }
599
600 cdl_option CYGNUM_KERNEL_THREADS_DATA_MAX {
601 display "Number of words of per-thread data"
602 parent CYGPKG_KERNEL_THREADS
603 #active_if CYGVAR_KERNEL_THREADS_DATA
604 type count
605 legal_values 1 to 65535
606 description "
607 It is possible for the kernel to support per-thread data, in
608 other words an area of memory specific to each thread which
609 can be used to store data for that thread. This per-thread
610 data can be used by applications or by other packages such as
611 the ISO C library. This configuration option controls the
612 number of words of per-thread data that the kernel will
613 allow."
614 doc ref/ecos-ref/thread-operations.html
615 }
616
617 cdl_option CYGNUM_KERNEL_THREADS_IDLE_STACK_SIZE {
618 display "Stack size for the idle thread"
619 parent CYGPKG_KERNEL_THREADS
620 type count
621 legal_values 512 to 65536
622 description "
623 This configuration option specifies the stack size in bytes
624 for the idle thread. Unless the HAL is configured to use a
625 separate interrupt stack this size must be sufficient to meet
626 the requirements of all interrupt handlers - these
627 requirements are cumulative if nested interrupted are
628 enabled. Depending on the target architecture, the stack size
629 typically has to be a multiple of eight or sixteen bytes."
630
631 doc ref/ecos-ref/thread-operations.html
632 }
633
634 }}CFG_DATA */
635
636 #define CYGFUN_KERNEL_THREADS_TIMER
637 #define CYGVAR_KERNEL_THREADS_NAME
638 #define CYGVAR_KERNEL_THREADS_LIST
639 #define CYGFUN_KERNEL_THREADS_STACK_LIMIT
640 #define CYGVAR_KERNEL_THREADS_DATA
641 #define CYGNUM_KERNEL_THREADS_DATA_MAX 6
642 #define CYGNUM_KERNEL_THREADS_IDLE_STACK_SIZE 2048
643
644
645 /* ---------------------------------------------------------------------
646 * Synchronization primitives.
647
648 {{CFG_DATA
649
650 cdl_component CYGPKG_KERNEL_SYNCH {
651 display "Synchronization primitives"
652 type dummy
653 parent CYGPKG_KERNEL
654 description "
655 The eCos kernel supports a number of different
656 synchronization primitives such as mutexes, semaphores,
657 condition variables, and message boxes. There are
658 configuration options to control the exact behaviour of some
659 of these synchronization primitives.
660 "
661 doc ref/ecos-ref/thread-synchronization.html
662 }
663
664 # NOTE: the requires statement is only valid for the current kernel.
665 # Priority inheritance is possible in other schedulers as well
666 # but is not yet implemented.
667 cdl_option CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE_SIMPLE {
668 display "Simple mutex priority inheritance"
669 requires CYGSEM_KERNEL_SCHED_MLQUEUE
670 parent CYGPKG_KERNEL_SYNCH
671 description "
672 This option enables a relatively simple implementation of
673 mutex priority inheritance. The implementation will only work
674 in the mlqueue scheduler, and it does not handle the rare
675 case of nested mutexes completely correctly. However it is
676 both fast and deterministic. Mutex priority inheritance can
677 be disabled if the application does not require it, which
678 will reduce both code size and data space."
679 doc ref/ecos-ref/synchronization.html#MUTEXES
680 }
681
682 cdl_option CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT {
683 display "Message box blocking put support"
684 parent CYGPKG_KERNEL_SYNCH
685 description "
686 Message boxes can support three different versions of the
687 put-message operation. The first is tryput(), which will fail
688 if the message box is already full. The other two are the
689 ordinary put() function which will block if the message box
690 is full, and a timed put() operation which will block for
691 upto a certain length of time if the message box is currently
692 full. The blocking versions require extra memory in the
693 message box data structure and extra code in the other
694 message box functions, so they can be disabled if the
695 application does not require them. If this option is enabled
696 then the system will always provide the blocking put()
697 function, and it will also provide the timed put() function
698 if thread timers are enabled."
699 doc ref/ecos-ref/message-boxes.html
700 }
701
702 cdl_option CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE {
703 display "Message box queue size"
704 parent CYGPKG_KERNEL_SYNCH
705 type count
706 legal_values 1 to 65535
707 description "
708 This configuration option controls the number of messages
709 that can be queued in a message box before a non-blocking
710 put() operation will fail or a blocking put() operation will
711 block. The cost in memory is one pointer per message box for
712 each possible message."
713 }
714
715 cdl_option CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT {
716 display "Condition variable timed-wait support"
717 parent CYGPKG_KERNEL_SYNCH
718 requires CYGVAR_KERNEL_COUNTERS_CLOCK
719 description "
720 This option enables the condition variable timed wait
721 facility."
722 doc ref/ecos-ref/synchronization.html#CONDITION-VARIABLES
723 }
724
725 }}CFG_DATA
726
727 */
728
729 #define CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE_SIMPLE
730 #define CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
731 #define CYGNUM_KERNEL_SYNCH_MBOX_QUEUE_SIZE 10
732 #define CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT
733
734 /* ---------------------------------------------------------------------
735 {{CFG_DATA
736
737 cdl_component CYGPKG_KERNEL_INSTRUMENT {
738 display "Kernel instrumentation"
739 parent CYGPKG_KERNEL
740 description "
741 The current release of the kernel contains an initial version
742 of instrumentation support. The various parts of the kernel
743 will invoke instrumentation routines whenever appropriate
744 events occur, and these will be stored in a circular buffer
745 for later reference."
746 }
747
748
749 cdl_option CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE {
750 display "Size of instrumentation buffer size"
751 parent CYGPKG_KERNEL_INSTRUMENT
752 type count
753 legal_values 16 to 0x100000
754 description "
755 If kernel instrumentation is enabled then the instrumentation
756 data goes into a circular buffer. A larger buffer allows
757 more data to be stored, but at a significant cost in memory.
758 The value of this option corresponds to the number of entries
759 in the table, and typically each entry will require 16 bytes
760 of memory."
761 }
762
763 cdl_option CYGDBG_KERNEL_INSTRUMENT_FLAGS {
764 display "Perform selective instrumentation"
765 parent CYGPKG_KERNEL_INSTRUMENT
766 description "
767 The kernel can either collect all instrumentation events, or
768 it can filter out events at runtime based on a set of flags.
769 For example it would be possible to decide at runtime that
770 only scheduler and interrupt instrumentation flags are of
771 interest and that all other flags should be ignored. This
772 flag mechanism involves extra code and processor cycle
773 overhead in the instrumentation code, so it can be disabled
774 if the application developer is interested in all
775 instrumentation events."
776 }
777
778 # NOTE: many of these options should only be active if the appropriate
779 # component is active.
780 cdl_option CYGDBG_KERNEL_INSTRUMENT_SCHED {
781 display "Instrument the scheduler"
782 parent CYGPKG_KERNEL_INSTRUMENT
783 description "
784 It is possible to perform selective instrumentation at
785 run-time. It is also possible to disable instrumentation
786 in various kernel components at compile-time, thus
787 reducing the code size overheads. This option controls
788 whether or not instrumentation support is compiled into
789 the scheduling code."
790 }
791
792 cdl_option CYGDBG_KERNEL_INSTRUMENT_THREAD {
793 display "Instrument thread operations"
794 parent CYGPKG_KERNEL_INSTRUMENT
795 description "
796 It is possible to perform selective instrumentation at
797 run-time. It is also possible to disable instrumentation
798 in various kernel components at compile-time, thus
799 reducing the code size overheads. This option controls
800 whether or not instrumentation support is compiled into
801 the code that manipulates threads."
802 }
803
804 cdl_option CYGDBG_KERNEL_INSTRUMENT_INTR {
805 display "Instrument interrupts"
806 parent CYGPKG_KERNEL_INSTRUMENT
807 description "
808 It is possible to perform selective instrumentation at
809 run-time. It is also possible to disable instrumentation
810 in various kernel components at compile-time, thus
811 reducing the code size overheads. This option controls
812 whether or not instrumentation support is compiled into
813 the interrupt handling code."
814 }
815
816 cdl_option CYGDBG_KERNEL_INSTRUMENT_MUTEX {
817 display "Instrument mutex operations"
818 parent CYGPKG_KERNEL_INSTRUMENT
819 description "
820 It is possible to perform selective instrumentation at
821 run-time. It is also possible to disable instrumentation
822 in various kernel components at compile-time, thus
823 reducing the code size overheads. This option controls
824 whether or not instrumentation support is compiled into
825 the mutex code."
826 }
827
828 cdl_option CYGDBG_KERNEL_INSTRUMENT_CONDVAR {
829 display "Instrument condition variable operations"
830 parent CYGPKG_KERNEL_INSTRUMENT
831 description "
832 It is possible to perform selective instrumentation at
833 run-time. It is also possible to disable instrumentation
834 in various kernel components at compile-time, thus
835 reducing the code size overheads. This option controls
836 whether or not instrumentation support is compiled into
837 the condition variable code."
838 }
839
840 cdl_option CYGDBG_KERNEL_INSTRUMENT_BINSEM {
841 display "Instrument binary semaphore operations"
842 parent CYGPKG_KERNEL_INSTRUMENT
843 description "
844 It is possible to perform selective instrumentation at
845 run-time. It is also possible to disable instrumentation
846 in various kernel components at compile-time, thus
847 reducing the code size overheads. This option controls
848 whether or not instrumentation support is compiled into
849 the binary semaphore code."
850 }
851
852 cdl_option CYGDBG_KERNEL_INSTRUMENT_CNTSEM {
853 display "Instrument counting semaphore operations"
854 parent CYGPKG_KERNEL_INSTRUMENT
855 description "
856 It is possible to perform selective instrumentation at
857 run-time. It is also possible to disable instrumentation
858 in various kernel components at compile-time, thus
859 reducing the code size overheads. This option controls
860 whether or not instrumentation support is compiled into
861 the counting semaphore code."
862 }
863
864 cdl_option CYGDBG_KERNEL_INSTRUMENT_MBOXT {
865 display "Instrument message box operations"
866 parent CYGPKG_KERNEL_INSTRUMENT
867 description "
868 It is possible to perform selective instrumentation at
869 run-time. It is also possible to disable instrumentation
870 in various kernel components at compile-time, thus
871 reducing the code size overheads. This option controls
872 whether or not instrumentation support is compiled into
873 the message box code."
874 }
875
876 cdl_option CYGDBG_KERNEL_INSTRUMENT_CLOCK {
877 display "Instrument clock operations"
878 parent CYGPKG_KERNEL_INSTRUMENT
879 description "
880 It is possible to perform selective instrumentation at
881 run-time. It is also possible to disable instrumentation
882 in various kernel components at compile-time, thus
883 reducing the code size overheads. This option controls
884 whether or not instrumentation support is compiled into
885 the real-time clock code."
886 }
887
888 cdl_option CYGDBG_KERNEL_INSTRUMENT_ALARM {
889 display "Instrument alarm-related operations"
890 parent CYGPKG_KERNEL_INSTRUMENT
891 description "
892 It is possible to perform selective instrumentation at
893 run-time. It is also possible to disable instrumentation
894 in various kernel components at compile-time, thus
895 reducing the code size overheads. This option controls
896 whether or not instrumentation support is compiled into
897 the code related to alarm operations."
898 }
899
900 cdl_option CYGDBG_KERNEL_INSTRUMENT_USER {
901 display "Support application-level instrumentation"
902 parent CYGPKG_KERNEL_INSTRUMENT
903 description "
904 It is possible to perform selective instrumentation at
905 run-time. It is also possible to disable instrumentation
906 in various kernel components at compile-time, thus
907 reducing the code size overheads. This option controls
908 whether or not application-level instrumentation gets
909 compiled in."
910 }
911
912 }}CFG_DATA
913 */
914
915 #undef CYGPKG_KERNEL_INSTRUMENT
916 #undef CYGVAR_KERNEL_INSTRUMENT_EXTERNAL_BUFFER
917 #define CYGNUM_KERNEL_INSTRUMENT_BUFFER_SIZE 256
918 #define CYGDBG_KERNEL_INSTRUMENT_FLAGS
919 #define CYGDBG_KERNEL_INSTRUMENT_SCHED
920 #define CYGDBG_KERNEL_INSTRUMENT_THREAD
921 #define CYGDBG_KERNEL_INSTRUMENT_INTR
922 #define CYGDBG_KERNEL_INSTRUMENT_MUTEX
923 #define CYGDBG_KERNEL_INSTRUMENT_CONDVAR
924 #define CYGDBG_KERNEL_INSTRUMENT_BINSEM
925 #define CYGDBG_KERNEL_INSTRUMENT_CNTSEM
926 #define CYGDBG_KERNEL_INSTRUMENT_CLOCK
927 #define CYGDBG_KERNEL_INSTRUMENT_ALARM
928 #define CYGDBG_KERNEL_INSTRUMENT_MBOXT
929 #define CYGDBG_KERNEL_INSTRUMENT_USER
930
931 /* ---------------------------------------------------------------------
932 * There appears to be somewhat of a lack of configuration options here.
933 {{CFG_DATA
934
935 cdl_component CYGPKG_KERNEL_MEMORY {
936 display "Memory allocators"
937 type dummy
938 parent CYGPKG_KERNEL
939 description "
940 Configuration options related to the kernel memory allocation
941 support."
942 }
943
944 cdl_option CYGSEM_KERNEL_MEMORY_COALESCE {
945 display "Coalesce memory in the variable-block allocator"
946 parent CYGPKG_KERNEL_MEMORY
947 description "
948 The variable-block memory allocator can perform coalescing
949 of memory whenever the application code releases memory back
950 to the pool. This coalescing reduces the possibility of
951 memory fragmentation problems, but involves extra code and
952 processor cycles."
953 }
954
955 }}CFG_DATA */
956
957 #define CYGSEM_KERNEL_MEMORY_COALESCE
958
959 /* ---------------------------------------------------------------------
960 * Options related to source-level debugging and diagnostics.
961
962 {{CFG_DATA
963
964 cdl_component CYGPKG_KERNEL_DEBUG {
965 display "Source-level debugging support"
966 type dummy
967 parent CYGPKG_KERNEL
968 description "
969 If the source level debugger gdb is to be used for debugging
970 application code then it may be necessary to configure in support
971 for this in the kernel."
972 }
973
974 # NOTE: does this require any other support ?
975 cdl_option CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT {
976 display "Include GDB multi-threading debug support"
977 parent CYGPKG_KERNEL_DEBUG
978 requires CYGVAR_KERNEL_THREADS_LIST
979 requires CYGDBG_HAL_DEBUG_GDB_THREAD_SUPPORT
980 description "
981 This option enables some extra kernel code which is needed
982 to support multi-threaded source level debugging."
983 }
984
985 }}CFG_DATA */
986
987 #define CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT
988
989 /* ---------------------------------------------------------------------
990 * Kernel API's. The C++ one is the default. A C API is optional.
991 * Support for other languages is possible.
992
993 {{CFG_DATA
994
995 cdl_component CYGPKG_KERNEL_API {
996 display "Kernel APIs"
997 type dummy
998 parent CYGPKG_KERNEL
999 description "
1000 The eCos kernel is implemented in C++, so a C++ interface
1001 to the kernel is always available. There is also an optional
1002 C API. Additional API's may be provided in future versions."
1003 doc ref/ecos-ref/kernel-apis.html
1004 }
1005
1006 cdl_option CYGFUN_KERNEL_API_C {
1007 display "Provide C API"
1008 parent CYGPKG_KERNEL_API
1009 description "
1010 The eCos kernel is implemented in C++, but there is an
1011 optional C API for use by application code. This C API can be
1012 disabled if the application code does not invoke the kernel
1013 directly, but instead uses higher level code such as the
1014 uITRON compatibility layer."
1015 }
1016
1017 }}CFG_DATA */
1018
1019 #define CYGFUN_KERNEL_API_C
1020
1021 /* ---------------------------------------------------------------------
1022 * The rest of this header file contains various fix-ups and
1023 * options which cannot yet be controlled via the GUI tool.
1024 *
1025 * First some miscellaneous scheduler support, all calculated.
1026 */
1027
1028 #if defined(CYGSEM_KERNEL_SCHED_TIMESLICE) && defined(CYGSEM_KERNEL_SCHED_BITMAP)
1029 # error Timeslicing cannot be enabled if the bitmap scheduler is used.
1030 #endif
1031
1032 /*
1033 * These #define's are for the system's internal use only and should
1034 * not be edited by users. */
1035 #ifdef CYGSEM_KERNEL_SCHED_BITMAP
1036 # define CYGPRI_KERNEL_SCHED_IMPL_HXX <cyg/kernel/bitmap.hxx>
1037 #elif defined(CYGSEM_KERNEL_SCHED_MLQUEUE)
1038 # define CYGPRI_KERNEL_SCHED_IMPL_HXX <cyg/kernel/mlqueue.hxx>
1039 #elif defined(CYGSEM_KERNEL_SCHED_LOTTERY)
1040 # define CYGPRI_KERNEL_SCHED_IMPL_HXX <cyg/kernel/lottery.hxx>
1041 #else
1042 #error No Scheduler defined
1043 #endif
1044
1045 #define CYGNUM_KERNEL_SCHED_BITMAP_SIZE CYGNUM_KERNEL_SCHED_PRIORITIES
1046
1047 /* ---------------------------------------------------------------------
1048 * Counter and clock related miscellania.
1049 *
1050 * If a real-time clock is enabled then there are additional
1051 * configuration options controlling the resolution of the clock,
1052 * CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION and
1053 * CYGNUM_KERNEL_COUNTERS_RTC_PERIOD. Different targets require
1054 * different default values, and the current configuration tool cannot
1055 * deal with this yet. Also the exact details of the resolution and
1056 * period values are still subject to change.
1057 *
1058 * To allow the clock settings to be controlled in some fashion,
1059 * there is a configuration option to override the default settings.
1060 * If this option is enabled then the resolution and period
1061 * #define's will come from configuration options (which do not
1062 * necessarily have sensible defaults, and which are not validated).
1063 * Otherwise the platform-specific numbers below are used. On
1064 * hardware this result in 100 clock interrupts every second.
1065 * For simulators slightly different values are used, so that the
1066 * various test cases run faster.
1067 */
1068
1069 #ifdef CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE
1070
1071 # define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION \
1072 { CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_NUMERATOR, \
1073 CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_DENOMINATOR }
1074
1075 # define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD CYGNUM_KERNEL_COUNTERS_CLOCK_OVERRIDE_PERIOD
1076
1077 #else /* CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE */
1078
1079 #if defined(CYG_HAL_MN10300_STDEVAL1)
1080
1081 #define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {1000000000, 100}
1082 #define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD 150000
1083
1084 #endif
1085 #if defined(CYG_HAL_MN10300_SIM)
1086
1087 #define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {1000000000, 100}
1088 #define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD 9999
1089
1090 #endif
1091
1092 #if defined(CYG_HAL_MIPS_JMR3904)
1093
1094 #define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {1000000000, 100}
1095 #define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD 15360
1096
1097 #endif
1098
1099 #if defined(CYG_HAL_MIPS_SIM)
1100
1101 #define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {1000000000, 100}
1102 #define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD 999
1103
1104 #endif
1105
1106 #if defined(CYG_HAL_POWERPC_MP860)
1107
1108 #define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {1000000000, 100}
1109 #define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD 20625
1110
1111 #endif
1112
1113
1114 #ifndef CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION
1115
1116 #define CYGNUM_KERNEL_COUNTERS_RTC_RESOLUTION {1000000000, 100}
1117 #define CYGNUM_KERNEL_COUNTERS_RTC_PERIOD 9999
1118
1119 #endif
1120
1121 #endif /* CYGPKG_KERNEL_COUNTERS_CLOCK_OVERRIDE */
1122
1123 /* ---------------------------------------------------------------------
1124 * Thread-related miscellania.
1125 *
1126 * These options provide for an assertion that the count value for counted
1127 * thread wakeups or for thread suspends do not exceed set limits. This is
1128 * to help with debugging, to allow a runaaway loop, for example, to be
1129 * detected more easily.
1130 *
1131 * If the option is not defined, no assert is included. Whether asserts
1132 * are themselves included depends on infrastructure configury in infra.h
1133 *
1134 * It is hoped that these defaults are helpful rather than interfering.
1135 */
1136 #define CYGNUM_KERNEL_MAX_SUSPEND_COUNT_ASSERT (500)
1137 #define CYGNUM_KERNEL_MAX_COUNTED_WAKE_COUNT_ASSERT (500)
1138
1139 /*
1140 * If the scheduler configuration only has a single priority level,
1141 * then the idle thread must yield each time around its loop.
1142 */
1143
1144 #if CYGNUM_KERNEL_SCHED_PRIORITIES == 1
1145 # define CYGIMP_IDLE_THREAD_YIELD
1146 #endif
1147
1148 /*
1149 * Per thread data options. Per thread data suuport is based loosely
1150 * on that define by POSIX. Each thread has an array of slots, up to
1151 * CYGNUM_KERNEL_THREADS_DATA_MAX, that may contain data. Some of the
1152 * slots have been preallocated to specific packages. Others may be
1153 * allocated dynamically.
1154 */
1155
1156 #define CYGNUM_KERNEL_THREADS_DATA_KERNEL 0
1157 #define CYGNUM_KERNEL_THREADS_DATA_ITRON 1
1158 #define CYGNUM_KERNEL_THREADS_DATA_LIBC 2
1159 #define CYGNUM_KERNEL_THREADS_DATA_POSIX 3
1160
1161 #define CYGNUM_KERNEL_THREADS_DATA_ALL 0xF
1162
1163 /*
1164 * Some consistency checks.
1165 */
1166 #if defined(CYGFUN_KERNEL_THREADS_TIMER) && !defined(CYGVAR_KERNEL_COUNTERS_CLOCK)
1167 # error "Cannot have Thread Timers without Real Time Clock"
1168 #endif
1169
1170 #if defined(CYGDBG_KERNEL_DEBUG_GDB_THREAD_SUPPORT) && !defined(CYGVAR_KERNEL_THREADS_LIST)
1171 # error "GDB thread support requires a list of all known threads."
1172 #endif
1173
1174 /* ---------------------------------------------------------------------
1175 * Synchronization primitives miscellania.
1176 *
1177 * These lines should not be edited by users.
1178 */
1179 #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE_SIMPLE
1180 # define CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE
1181 #endif
1182 #if defined(CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE) && !defined(CYGSEM_KERNEL_SCHED_MLQUEUE)
1183 # error "Priority inheritance can only be enabled if the mlqueue scheduler is used."
1184 #endif
1185
1186 /* ---------------------------------------------------------------------
1187 * This code allows the kernel build to be configured as a GDB
1188 * stub ROM monitor. It is only intended for internal use.
1189 */
1190
1191 /*
1192 * BLV: This code must be kept commented out for now, as it can
1193 * confuse the configuration tool. The correct solution is to have a
1194 * standard configuration for the system as represented by e.g. a
1195 * .ptest file which does the right thing. A ROM monitor is an
1196 * application, and application-specific configuration stuff should
1197 * not live in the master header file.
1198 */
1199
1200 /*
1201 #undef CYG_HAL_ROM_MONITOR
1202
1203 #ifdef CYG_HAL_ROM_MONITOR
1204
1205 #undef CYGFUN_HAL_COMMON_KERNEL_SUPPORT
1206 #undef CYGDBG_HAL_COMMON_INTERRUPTS_SAVE_MINIMUM_CONTEXT
1207 #undef CYGIMP_HAL_COMMON_INTERRUPTS_USE_INTERRUPT_STACK
1208 #undef CYGSEM_HAL_COMMON_INTERRUPTS_ALLOW_NESTING
1209 #undef CYGIMP_KERNEL_INTERRUPTS_CHAIN
1210 #undef CYGVAR_KERNEL_COUNTERS_CLOCK
1211 #undef CYGFUN_KERNEL_THREADS_TIMER
1212 #undef CYGPKG_KERNEL_EXCEPTIONS
1213 #undef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE_SIMPLE
1214 #undef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INHERITANCE
1215 #undef CYGPKG_KERNEL_INSTRUMENT
1216 #undef CYGDBG_INFRA_DIAG_USE_DEVICE // now lives in infra
1217
1218 #define CYGDBG_KERNEL_DEBUG_GDB_INCLUDE_STUBS
1219
1220 #endif
1221 */
1222
1223 /* -------------------------------------------------------------------*/
1224
1225 #endif /* ifdef CYGPKG_KERNEL */
1226
1227 /* -------------------------------------------------------------------*/
1228 #endif /* CYGONCE_PKGCONF_KERNEL_H */
1229 /* EOF kernel.h */