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