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