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