FreeCalypso > hg > fc-tourmaline
comparison src/cs/riviera/rvf/rvf_pool_size.h @ 0:4e78acac3d88
src/{condat,cs,gpf,nucleus}: import from Selenite
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Fri, 16 Oct 2020 06:23:26 +0000 |
parents | |
children | 7b71cbbc140b |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4e78acac3d88 |
---|---|
1 /****************************************************************************/ | |
2 /* */ | |
3 /* Name rvf_pool_size.h */ | |
4 /* */ | |
5 /* Function this file contains definitions for buffer pool sizes */ | |
6 /* */ | |
7 /* */ | |
8 /* */ | |
9 /* */ | |
10 /* Version 0.3 */ | |
11 /* */ | |
12 /* Date Modification */ | |
13 /* ------------------------------------ */ | |
14 /* 4/19/1999 Create */ | |
15 /* 10/27/1999 Remove declaration of ntohs, htons, ntohl, htonl */ | |
16 /* in order to avoid conflict with winsock.h */ | |
17 /* 12/23/1999 Add buffer and memory bank related definition */ | |
18 /* 07/12/2000 Implement dynamic memory allocation. */ | |
19 /* 01/13/2002 Extracted buffer pool size info from rvf_target.h */ | |
20 /* to prevent useless full recompilation when those datas */ | |
21 /* are changed */ | |
22 /* 10/01/2002 Completely reworked in order to be modular */ | |
23 /* 07/08/2003 Rework */ | |
24 /* */ | |
25 /* Author David Lamy-Charrier (dlamy@tif.ti.com) */ | |
26 /* */ | |
27 /* (C) Copyright 1999 by Texas Instruments Incorporated, All Rights Reserved*/ | |
28 /****************************************************************************/ | |
29 | |
30 #ifndef _RVF_POOL_SIZE_H | |
31 #define _RVF_POOL_SIZE_H | |
32 | |
33 #ifndef _WINDOWS | |
34 #include "config/r2d.cfg" | |
35 #include "config/rv.cfg" | |
36 #include "config/debug.cfg" | |
37 #include "config/board.cfg" | |
38 #include "config/l1sw.cfg" | |
39 #include "config/swconfig.cfg" | |
40 #endif | |
41 | |
42 #include "rv/rv_defined_swe.h" | |
43 | |
44 | |
45 /* | |
46 * RPC SWE | |
47 */ | |
48 #ifdef RVM_RPC_SWE | |
49 #include "widcomm/rpc/rpc_pool_size.h" | |
50 #define RVF_RPC_POOL_SIZE (RPC_POOL_SIZE) | |
51 #else | |
52 #define RVF_RPC_POOL_SIZE (0) | |
53 #endif | |
54 | |
55 /* | |
56 * BTA SWE | |
57 */ | |
58 #ifdef RVM_BTA_SWE | |
59 #include "widcomm/bta/bta_pool_size.h" | |
60 #define RVF_BTA_POOL_SIZE (BTA_POOL_SIZE) | |
61 #else | |
62 #define RVF_BTA_POOL_SIZE (0) | |
63 #endif | |
64 | |
65 /* | |
66 * BTU SWE | |
67 */ | |
68 #ifdef RVM_BTU_SWE | |
69 #include "widcomm/btu/btu_pool_size.h" | |
70 #define RVF_BTU_POOL_SIZE (BTU_POOL_SIZE) | |
71 #else | |
72 #define RVF_BTU_POOL_SIZE (0) | |
73 #endif | |
74 | |
75 /* | |
76 * BTUI SWE | |
77 */ | |
78 #ifdef RVM_BTUI_SWE | |
79 #include "widcomm/btui/btui_pool_size.h" | |
80 #define RVF_BTUI_POOL_SIZE (BTUI_POOL_SIZE) | |
81 #else | |
82 #define RVF_BTUI_POOL_SIZE (0) | |
83 #endif | |
84 | |
85 /* | |
86 * BTH SWE | |
87 */ | |
88 #ifdef RVM_BTH_SWE | |
89 #include "widcomm/hci/pc/bth/bth_pool_size.h" | |
90 #define RVF_BTH_POOL_SIZE (BTU_POOL_SIZE) | |
91 #else | |
92 #define RVF_BTH_POOL_SIZE (0) | |
93 #endif | |
94 | |
95 /* | |
96 * GKI SWE | |
97 */ | |
98 #ifdef RVM_GKI_SWE | |
99 #include "widcomm/gki/gki_pool_size.h" | |
100 #define RVF_GKI_POOL_SIZE (GKI_POOL_SIZE) | |
101 #else | |
102 #define RVF_GKI_POOL_SIZE (0) | |
103 #endif | |
104 | |
105 /* | |
106 * HCI SWE | |
107 */ | |
108 #ifdef RVM_HCI_SWE | |
109 #include "widcomm/hci/hci_pool_size.h" | |
110 #define RVF_HCI_POOL_SIZE (HCI_POOL_SIZE) | |
111 #else | |
112 #define RVF_HCI_POOL_SIZE (0) | |
113 #endif | |
114 | |
115 | |
116 | |
117 /* | |
118 * ATP SWE | |
119 */ | |
120 #ifdef RVM_ATP_SWE | |
121 #include "atp/atp_pool_size.h" | |
122 #define RVF_ATP_POOL_SIZE (ATP_POOL_SIZE) | |
123 #else | |
124 #define RVF_ATP_POOL_SIZE (0) | |
125 #endif | |
126 | |
127 /* | |
128 * ATP_UART SWE | |
129 */ | |
130 #ifdef RVM_ATP_UART_SWE | |
131 #include "atp/atp_pool_size.h" | |
132 #define RVF_ATP_UART_POOL_SIZE (ATP_UART_POOL_SIZE) | |
133 #else | |
134 #define RVF_ATP_UART_POOL_SIZE (0) | |
135 #endif | |
136 | |
137 /* | |
138 * AUDIO SWE and background | |
139 */ | |
140 #ifdef RVM_AUDIO_MAIN_SWE | |
141 #include "audio/audio_pool_size.h" | |
142 #define RVF_AUDIO_POOL_SIZE (AUDIO_POOL_SIZE) | |
143 #else | |
144 #define RVF_AUDIO_POOL_SIZE (0) | |
145 #endif | |
146 | |
147 #ifdef RVM_AUDIO_BGD_SWE | |
148 #include "audio/audio_pool_size.h" | |
149 #define RVF_AUDIO_BGD_POOL_SIZE (AUDIO_BGD_POOL_SIZE) | |
150 #else | |
151 #define RVF_AUDIO_BGD_POOL_SIZE (0) | |
152 #endif | |
153 | |
154 /* | |
155 * DAR SWE | |
156 */ | |
157 #ifdef RVM_DAR_SWE | |
158 #include "dar/dar_pool_size.h" | |
159 #define RVF_DAR_POOL_SIZE (DAR_POOL_SIZE) | |
160 #else | |
161 #define RVF_DAR_POOL_SIZE (0) | |
162 #endif | |
163 | |
164 /* | |
165 * ETM SWE | |
166 */ | |
167 #ifdef RVM_ETM_SWE | |
168 #include "etm/etm_pool_size.h" | |
169 #define RVF_ETM_POOL_SIZE (ETM_POOL_SIZE) | |
170 #else | |
171 #define RVF_ETM_POOL_SIZE (0) | |
172 #endif | |
173 | |
174 /* | |
175 * FFS SWE | |
176 */ | |
177 #ifdef RVM_FFS_SWE | |
178 #include "ffs/ffs_pool_size.h" | |
179 #define RVF_FFS_POOL_SIZE (FFS_POOL_SIZE) | |
180 #else | |
181 #define RVF_FFS_POOL_SIZE (0) | |
182 #endif | |
183 | |
184 | |
185 /* | |
186 * KCL SWE | |
187 */ | |
188 #ifdef RVM_KCL_SWE | |
189 #include "j2me_k/kcl/kcl_pool_size.h" | |
190 #define RVF_KCL_POOL_SIZE (KCL_POOL_SIZE) | |
191 #else | |
192 #define RVF_KCL_POOL_SIZE (0) | |
193 #endif | |
194 | |
195 /* | |
196 * KGC SWE | |
197 */ | |
198 #ifdef RVM_KGC_SWE | |
199 #include "j2me_k/kgc/kgc_pool_size.h" | |
200 #define RVF_KGC_POOL_SIZE (KGC_POOL_SIZE) | |
201 #else | |
202 #define RVF_KGC_POOL_SIZE (0) | |
203 #endif | |
204 | |
205 /* | |
206 * KIL SWE | |
207 */ | |
208 #ifdef RVM_KIL_SWE | |
209 #include "j2me_k/kil/kil_pool_size.h" | |
210 #define RVF_KIL_POOL_SIZE (KIL_POOL_SIZE) | |
211 #else | |
212 #define RVF_KIL_POOL_SIZE (0) | |
213 #endif | |
214 | |
215 /* | |
216 * KMM SWE | |
217 */ | |
218 #ifdef RVM_KMM_SWE | |
219 #include "j2me_k/kmm/kmm_pool_size.h" | |
220 #define RVF_KMM_POOL_SIZE (KMM_POOL_SIZE) | |
221 #else | |
222 #define RVF_KMM_POOL_SIZE (0) | |
223 #endif | |
224 | |
225 /* | |
226 * KNM SWE | |
227 */ | |
228 #ifdef RVM_KNM_SWE | |
229 #include "j2me_k/knm/knm_pool_size.h" | |
230 #define RVF_KNM_POOL_SIZE (KNM_POOL_SIZE) | |
231 #else | |
232 #define RVF_KNM_POOL_SIZE (0) | |
233 #endif | |
234 | |
235 /* | |
236 * KPG SWE | |
237 */ | |
238 #ifdef RVM_KPG_SWE | |
239 #include "j2me_k/kpg/kpg_pool_size.h" | |
240 #define RVF_KPG_POOL_SIZE (KPG_POOL_SIZE) | |
241 #else | |
242 #define RVF_KPG_POOL_SIZE (0) | |
243 #endif | |
244 | |
245 /* | |
246 * KZP SWE | |
247 */ | |
248 #ifdef RVM_KZP_SWE | |
249 #include "j2me_k/kzp/kzp_pool_size.h" | |
250 #define RVF_KZP_POOL_SIZE (KZP_POOL_SIZE) | |
251 #else | |
252 #define RVF_KZP_POOL_SIZE (0) | |
253 #endif | |
254 | |
255 | |
256 /* | |
257 * KPD SWE | |
258 */ | |
259 #ifdef RVM_KPD_SWE | |
260 #include "kpd/kpd_pool_size.h" | |
261 #define RVF_KPD_POOL_SIZE (KPD_POOL_SIZE) | |
262 #else | |
263 #define RVF_KPD_POOL_SIZE (0) | |
264 #endif | |
265 | |
266 | |
267 /* | |
268 * LLS SWE | |
269 */ | |
270 #ifdef RVM_LLS_SWE | |
271 #include "lls/lls_pool_size.h" | |
272 #define RVF_LLS_POOL_SIZE (LLS_POOL_SIZE) | |
273 #else | |
274 #define RVF_LLS_POOL_SIZE (0) | |
275 #endif | |
276 | |
277 /* | |
278 * MKS SWE | |
279 */ | |
280 #ifdef RVM_MKS_SWE | |
281 #include "mks/mks_pool_size.h" | |
282 #define RVF_MKS_POOL_SIZE (MKS_POOL_SIZE) | |
283 #else | |
284 #define RVF_MKS_POOL_SIZE (0) | |
285 #endif | |
286 | |
287 /* | |
288 * MPM SWE | |
289 */ | |
290 #ifdef RVM_MPM_SWE | |
291 #include "mpm/mpm_pool_size.h" | |
292 #define RVF_MPM_POOL_SIZE (MPM_POOL_SIZE) | |
293 #else | |
294 #define RVF_MPM_POOL_SIZE (0) | |
295 #endif | |
296 | |
297 /* | |
298 * PWR SWE | |
299 */ | |
300 #ifdef RVM_PWR_SWE | |
301 #include "pwr/pwr_pool_size.h" | |
302 #define RVF_PWR_POOL_SIZE (PWR_POOL_SIZE) | |
303 #else | |
304 #define RVF_PWR_POOL_SIZE (0) | |
305 #endif | |
306 | |
307 /* | |
308 * LCC (PWR) SWE | |
309 */ | |
310 #ifdef RVM_LCC_SWE | |
311 #include "lcc/lcc_pool_size.h" | |
312 #define RVF_LCC_POOL_SIZE (LCC_POOL_SIZE) | |
313 #else | |
314 #define RVF_LCC_POOL_SIZE (0) | |
315 #endif | |
316 | |
317 /* | |
318 * FCHG (Yet Another PWR) SWE | |
319 */ | |
320 #ifdef RVM_FCHG_SWE | |
321 #include "fchg/fchg_pool_size.h" | |
322 #define RVF_FCHG_POOL_SIZE (FCHG_POOL_SIZE) | |
323 #else | |
324 #define RVF_FCHG_POOL_SIZE (0) | |
325 #endif | |
326 | |
327 /* | |
328 * R2D SWE | |
329 */ | |
330 #ifdef RVM_R2D_SWE | |
331 #include "r2d/r2d_pool_size.h" | |
332 #define RVF_R2D_POOL_SIZE (R2D_POOL_SIZE) | |
333 #else | |
334 #define RVF_R2D_POOL_SIZE (0) | |
335 #endif | |
336 | |
337 /* | |
338 * RGUI SWE | |
339 */ | |
340 #ifdef RVM_RGUI_SWE | |
341 #include "rgui/rgui_pool_size.h" | |
342 #define RVF_RGUI_POOL_SIZE (RGUI_POOL_SIZE) | |
343 #else | |
344 #define RVF_RGUI_POOL_SIZE (0) | |
345 #endif | |
346 | |
347 | |
348 /* | |
349 * RNET SWE | |
350 */ | |
351 #ifdef RVM_RNET_SWE | |
352 #include "rnet/rnet_pool_size.h" | |
353 #define RVF_RNET_POOL_SIZE (RNET_POOL_SIZE) | |
354 #else | |
355 #define RVF_RNET_POOL_SIZE (0) | |
356 #endif | |
357 | |
358 /* | |
359 * RNET_BR SWE | |
360 */ | |
361 #ifdef RVM_RNET_BR_SWE | |
362 #include "rnet/rnet_br/rnet_br_pool_size.h" | |
363 #define RVF_RNET_BR_POOL_SIZE (RNET_BR_POOL_SIZE) | |
364 #else | |
365 #define RVF_RNET_BR_POOL_SIZE (0) | |
366 #endif | |
367 | |
368 /* | |
369 * RNET_RT SWE | |
370 */ | |
371 #ifdef RVM_RNET_RT_SWE | |
372 #include "rnet/rnet_rt/rnet_rt_pool_size.h" | |
373 #define RVF_RNET_RT_POOL_SIZE (RNET_RT_POOL_SIZE) | |
374 #else | |
375 #define RVF_RNET_RT_POOL_SIZE (0) | |
376 #endif | |
377 | |
378 /* | |
379 * RNET_WS SWE | |
380 */ | |
381 #ifdef RVM_RNET_WS_SWE | |
382 #include "rnet/rnet_ws/rnet_ws_pool_size.h" | |
383 #define RVF_RNET_WS_POOL_SIZE (RNET_WS_POOL_SIZE) | |
384 #else | |
385 #define RVF_RNET_WS_POOL_SIZE (0) | |
386 #endif | |
387 | |
388 | |
389 /* | |
390 * DCM SWE | |
391 */ | |
392 #ifdef RVM_DCM_SWE | |
393 #include "dcm/dcm_pool_size.h" | |
394 #define RVF_DCM_POOL_SIZE (DCM_POOL_SIZE) | |
395 #else | |
396 #define RVF_DCM_POOL_SIZE (0) | |
397 #endif | |
398 | |
399 /* | |
400 * DCFG SWE | |
401 */ | |
402 | |
403 #ifdef RVM_DCFG_SWE | |
404 #include "dcfg/dcfg_pool_size.h" | |
405 #define RVF_DCFG_POOL_SIZE (DCFG_POOL_SIZE) | |
406 #else | |
407 #define RVF_DCFG_POOL_SIZE (0) | |
408 #endif | |
409 | |
410 /* | |
411 * RTC SWE | |
412 */ | |
413 #ifdef RVM_RTC_SWE | |
414 #include "rtc/rtc_pool_size.h" | |
415 #define RVF_RTC_POOL_SIZE (RTC_POOL_SIZE) | |
416 #else | |
417 #define RVF_RTC_POOL_SIZE (0) | |
418 #endif | |
419 | |
420 /* | |
421 * RTEST SWE | |
422 */ | |
423 #ifdef RVM_RTEST_SWE | |
424 #include "tests/rtest/rtest_pool_size.h" | |
425 #define RVF_RTEST_POOL_SIZE (RTEST_POOL_SIZE) | |
426 #else | |
427 #define RVF_RTEST_POOL_SIZE (0) | |
428 #endif | |
429 | |
430 /* | |
431 * RVM SWE; This SWE is of course always enabled. | |
432 * TO CLEAN?? | |
433 */ | |
434 #include "rvm/rvm_pool_size.h" | |
435 | |
436 | |
437 /* | |
438 * SPI SWE | |
439 */ | |
440 #ifdef RVM_SPI_SWE | |
441 #include "spi/spi_pool_size.h" | |
442 #define RVF_SPI_POOL_SIZE (SPI_POOL_SIZE) | |
443 #else | |
444 #define RVF_SPI_POOL_SIZE (0) | |
445 #endif | |
446 | |
447 | |
448 | |
449 /* | |
450 * TI_PRF SWE | |
451 */ | |
452 #ifdef RVM_TI_PRF_SWE | |
453 #include "rvt/ti_profiler/ti_prf_pool_size.h" | |
454 #define RVF_TI_PRF_POOL_SIZE (TI_PRF_POOL_SIZE) | |
455 #else | |
456 #define RVF_TI_PRF_POOL_SIZE (0) | |
457 #endif | |
458 | |
459 /* | |
460 * TRACE SWE | |
461 */ | |
462 #ifdef RVM_RVT_SWE | |
463 #include "rvt/rvt_pool_size.h" | |
464 #define RVF_TRACE_POOL_SIZE (TRACE_POOL_SIZE) | |
465 #else | |
466 #define RVF_TRACE_POOL_SIZE (0) | |
467 #endif | |
468 | |
469 /* | |
470 * TUT SWE | |
471 */ | |
472 #ifdef RVM_TUT_SWE | |
473 #include "tut/tut_pool_size.h" | |
474 #define RVF_TUT_POOL_SIZE (TUT_POOL_SIZE) | |
475 #else | |
476 #define RVF_TUT_POOL_SIZE (0) | |
477 #endif | |
478 | |
479 /* | |
480 * UVM SWE | |
481 */ | |
482 #ifdef RVM_UVM_SWE | |
483 #include "j2me_k/uvm/uvm_pool_size.h" | |
484 #define RVF_UVM_POOL_SIZE (UVM_POOL_SIZE) | |
485 #else | |
486 #define RVF_UVM_POOL_SIZE (0) | |
487 #endif | |
488 | |
489 /* | |
490 * JTM SWE | |
491 */ | |
492 #ifdef RVM_JTM_SWE | |
493 #include "j2me_k/jtm/jtm_pool_size.h" | |
494 #define RVF_JTM_POOL_SIZE (JTM_POOL_SIZE) | |
495 #else | |
496 #define RVF_JTM_POOL_SIZE (0) | |
497 #endif | |
498 | |
499 /* | |
500 * MDC SWE | |
501 */ | |
502 #ifdef RVM_MDC_SWE | |
503 #include "mdc/mdc_pool_size.h" | |
504 #define RVF_MDC_POOL_SIZE (MDC_POOL_SIZE) | |
505 #else | |
506 #define RVF_MDC_POOL_SIZE (0) | |
507 #endif | |
508 | |
509 /* | |
510 * TTY SWE | |
511 */ | |
512 #ifdef RVM_TTY_SWE | |
513 #include "tty/tty_pool_size.h" | |
514 #define RVF_TTY_POOL_SIZE (TTY_POOL_SIZE) | |
515 #else | |
516 #define RVF_TTY_POOL_SIZE (0) | |
517 #endif | |
518 | |
519 | |
520 /* | |
521 * Obigo SWEs | |
522 */ | |
523 /* BRAE SWE */ | |
524 #ifdef RVM_BRAE_SWE | |
525 #include "obigo/brae/brae_pool_size.h" | |
526 #define RVF_BRAE_POOL_SIZE BRAE_POOL_SIZE | |
527 #else | |
528 #define RVF_BRAE_POOL_SIZE (0) | |
529 #endif | |
530 /* BRSE SWE */ | |
531 #ifdef RVM_BRSE_SWE | |
532 #include "obigo/brse/brse_pool_size.h" | |
533 #define RVF_BRSE_POOL_SIZE BRSE_POOL_SIZE | |
534 #else | |
535 #define RVF_BRSE_POOL_SIZE (0) | |
536 #endif | |
537 | |
538 /* UISE SWE */ | |
539 #ifdef RVM_UISE_SWE | |
540 #include "obigo/uise/uise_pool_size.h" | |
541 #define RVF_UISE_POOL_SIZE UISE_POOL_SIZE | |
542 #else | |
543 #define RVF_UISE_POOL_SIZE (0) | |
544 #endif | |
545 | |
546 /* UIAE SWE */ | |
547 #ifdef RVM_UIAE_SWE | |
548 #include "obigo/uiae/uiae_pool_size.h" | |
549 #define RVF_UIAE_POOL_SIZE UIAE_POOL_SIZE | |
550 #else | |
551 #define RVF_UIAE_POOL_SIZE (0) | |
552 #endif | |
553 | |
554 /* MEAE SWE */ | |
555 #ifdef RVM_MEAE_SWE | |
556 #include "obigo/meae/meae_pool_size.h" | |
557 #define RVF_MEAE_POOL_SIZE MEAE_POOL_SIZE | |
558 #else | |
559 #define RVF_MEAE_POOL_SIZE (0) | |
560 #endif | |
561 /* MMSE SWE */ | |
562 #ifdef RVM_MMSE_SWE | |
563 #include "obigo/mmse/mmse_pool_size.h" | |
564 #define RVF_MMSE_POOL_SIZE MMSE_POOL_SIZE | |
565 #else | |
566 #define RVF_MMSE_POOL_SIZE (0) | |
567 #endif | |
568 /* MSFE SWE */ | |
569 #ifdef RVM_MSFE_SWE | |
570 #include "obigo/msfe/msfe_pool_size.h" | |
571 #define RVF_MSFE_POOL_SIZE MSFE_POOL_SIZE | |
572 #else | |
573 #define RVF_MSFE_POOL_SIZE (0) | |
574 #endif | |
575 /* MSME SWE */ | |
576 #ifdef RVM_MSME_SWE | |
577 #include "obigo/msme/msme_pool_size.h" | |
578 #define RVF_MSME_POOL_SIZE MSME_POOL_SIZE | |
579 #else | |
580 #define RVF_MSME_POOL_SIZE (0) | |
581 #endif | |
582 /* PHSE SWE */ | |
583 #ifdef RVM_PHSE_SWE | |
584 #include "obigo/phse/phse_pool_size.h" | |
585 #define RVF_PHSE_POOL_SIZE PHSE_POOL_SIZE | |
586 #else | |
587 #define RVF_PHSE_POOL_SIZE (0) | |
588 #endif | |
589 /* PRSE SWE */ | |
590 #ifdef RVM_PRSE_SWE | |
591 #include "obigo/prse/prse_pool_size.h" | |
592 #define RVF_PRSE_POOL_SIZE PRSE_POOL_SIZE | |
593 #else | |
594 #define RVF_PRSE_POOL_SIZE (0) | |
595 #endif | |
596 /* SECE SWE */ | |
597 #ifdef RVM_SECE_SWE | |
598 #include "obigo/sece/sece_pool_size.h" | |
599 #define RVF_SECE_POOL_SIZE SECE_POOL_SIZE | |
600 #else | |
601 #define RVF_SECE_POOL_SIZE (0) | |
602 #endif | |
603 /* SELE SWE */ | |
604 #ifdef RVM_SELE_SWE | |
605 #include "obigo/sele/sele_pool_size.h" | |
606 #define RVF_SELE_POOL_SIZE SELE_POOL_SIZE | |
607 #else | |
608 #define RVF_SELE_POOL_SIZE (0) | |
609 #endif | |
610 /* SLSE SWE */ | |
611 #ifdef RVM_SLSE_SWE | |
612 #include "obigo/slse/slse_pool_size.h" | |
613 #define RVF_SLSE_POOL_SIZE SLSE_POOL_SIZE | |
614 #else | |
615 #define RVF_SLSE_POOL_SIZE (0) | |
616 #endif | |
617 /* SMAE SWE */ | |
618 #ifdef RVM_SMAE_SWE | |
619 #include "obigo/smae/smae_pool_size.h" | |
620 #define RVF_SMAE_POOL_SIZE SMAE_POOL_SIZE | |
621 #else | |
622 #define RVF_SMAE_POOL_SIZE (0) | |
623 #endif | |
624 /* STKE SWE */ | |
625 #ifdef RVM_STKE_SWE | |
626 #include "obigo/stke/stke_pool_size.h" | |
627 #define RVF_STKE_POOL_SIZE STKE_POOL_SIZE | |
628 #else | |
629 #define RVF_STKE_POOL_SIZE (0) | |
630 #endif | |
631 /* EMAE SWE */ | |
632 #ifdef RVM_EMAE_SWE | |
633 #include "obigo/emae/emae_pool_size.h" | |
634 #define RVF_EMAE_POOL_SIZE EMAE_POOL_SIZE | |
635 #else | |
636 #define RVF_EMAE_POOL_SIZE (0) | |
637 #endif | |
638 /* EMSE SWE */ | |
639 #ifdef RVM_EMSE_SWE | |
640 #include "obigo/emse/emse_pool_size.h" | |
641 #define RVF_EMSE_POOL_SIZE EMSE_POOL_SIZE | |
642 #else | |
643 #define RVF_EMSE_POOL_SIZE (0) | |
644 #endif | |
645 | |
646 /* IT0E SWE */ | |
647 #ifdef RVM_IT0E_SWE | |
648 #include "obigo/tests/it0e/it0e_pool_size.h" | |
649 #define RVF_IT0E_POOL_SIZE IT0E_POOL_SIZE | |
650 #else | |
651 #define RVF_IT0E_POOL_SIZE (0) | |
652 #endif | |
653 /* IT1E SWE */ | |
654 #ifdef RVM_IT1E_SWE | |
655 #include "obigo/tests/it1e/it1e_pool_size.h" | |
656 #define RVF_IT1E_POOL_SIZE IT1E_POOL_SIZE | |
657 #else | |
658 #define RVF_IT1E_POOL_SIZE (0) | |
659 #endif | |
660 /* IT2E SWE */ | |
661 #ifdef RVM_IT2E_SWE | |
662 #include "obigo/tests/it2e/it2e_pool_size.h" | |
663 #define RVF_IT2E_POOL_SIZE IT2E_POOL_SIZE | |
664 #else | |
665 #define RVF_IT2E_POOL_SIZE (0) | |
666 #endif | |
667 | |
668 | |
669 /* | |
670 * MFW SWE | |
671 */ | |
672 #ifdef RVM_MFW_SWE | |
673 #include "mfw/mfw_pool_size.h" | |
674 #define RVF_MFW_POOL_SIZE (MFW_POOL_SIZE) | |
675 #else | |
676 #define RVF_MFW_POOL_SIZE (0) | |
677 #endif | |
678 | |
679 /* | |
680 * IMG SWE | |
681 */ | |
682 #ifdef RVM_IMG_SWE | |
683 #include "img/img_pool_size.h" | |
684 #define RVF_IMG_POOL_SIZE IMG_POOL_SIZE | |
685 #else | |
686 #define RVF_IMG_POOL_SIZE (0) | |
687 #endif | |
688 | |
689 /* | |
690 MMS | |
691 //TISHMMS Project add 10K for buffer mms message | |
692 */ | |
693 #ifdef RVM_MMS_SWE | |
694 /* | |
695 * Values used in mms_env.h | |
696 */ | |
697 #include "mms/mms_pool_size.h" | |
698 | |
699 #define RVF_MMS_POOL_SIZE MMS_POOL_SIZE | |
700 #else | |
701 #define RVF_MMS_POOL_SIZE (0) | |
702 #endif | |
703 | |
704 /* | |
705 * SMBS SWE | |
706 */ | |
707 #ifdef RVM_SMBS_SWE | |
708 #include "smbs/smbs_pool_size.h" | |
709 #define RVF_SMBS_POOL_SIZE (SMBS_POOL_SIZE) | |
710 #else | |
711 #define RVF_SMBS_POOL_SIZE (0) | |
712 #endif | |
713 | |
714 /* | |
715 * MDL SWE | |
716 */ | |
717 #ifdef RVM_MDL_SWE | |
718 #include "mdl/mdl_pool_size.h" | |
719 #define RVF_MDL_POOL_SIZE (MDL_POOL_SIZE) | |
720 #else | |
721 #define RVF_MDL_POOL_SIZE (0) | |
722 #endif | |
723 | |
724 | |
725 | |
726 /* define the memory pools used by the RVF */ | |
727 | |
728 /* define RVF_NB_POOLS to 1 or 2 if you want to use 2 buffers in RAM, | |
729 for example 1 in internal RAM, 1 in external RAM */ | |
730 #define RVF_NB_POOLS 1 | |
731 /* 500 corresponds to a "hard-coded" value for RVM_STACKS Memory Bank defined in rvm_i.h */ | |
732 #define RVF_POOL_0_SIZE (RVF_ATP_POOL_SIZE + RVF_ATP_UART_POOL_SIZE + RVF_AUDIO_POOL_SIZE + \ | |
733 RVF_DAR_POOL_SIZE + RVF_HCI_POOL_SIZE + RVF_ETM_POOL_SIZE + \ | |
734 RVF_FFS_POOL_SIZE + RVF_KCL_POOL_SIZE + RVF_KGC_POOL_SIZE + \ | |
735 RVF_KIL_POOL_SIZE + RVF_KMM_POOL_SIZE + RVF_KNM_POOL_SIZE + \ | |
736 RVF_KPD_POOL_SIZE + RVF_KPG_POOL_SIZE + RVF_KZP_POOL_SIZE + \ | |
737 RVF_LLS_POOL_SIZE + RVF_MKS_POOL_SIZE + RVF_TTY_POOL_SIZE + \ | |
738 RVF_MPM_POOL_SIZE + RVF_PWR_POOL_SIZE + RVF_LCC_POOL_SIZE + \ | |
739 RVF_FCHG_POOL_SIZE + \ | |
740 RVF_R2D_POOL_SIZE + RVF_MMS_POOL_SIZE +\ | |
741 RVF_RGUI_POOL_SIZE + RVF_RNET_POOL_SIZE + RVF_RNET_BR_POOL_SIZE + \ | |
742 RVF_MDC_POOL_SIZE + RVF_RNET_RT_POOL_SIZE + RVF_RNET_WS_POOL_SIZE + \ | |
743 RVF_RTC_POOL_SIZE + RVF_RTEST_POOL_SIZE + RVF_RVM_POOL_SIZE + \ | |
744 RVF_SPI_POOL_SIZE + RVF_TI_PRF_POOL_SIZE + RVF_TRACE_POOL_SIZE + \ | |
745 RVF_TUT_POOL_SIZE + RVF_UVM_POOL_SIZE + RVF_JTM_POOL_SIZE + \ | |
746 RVF_DCM_POOL_SIZE + RVF_BRAE_POOL_SIZE + RVF_BRSE_POOL_SIZE + \ | |
747 RVF_UISE_POOL_SIZE + RVF_UIAE_POOL_SIZE + RVF_MEAE_POOL_SIZE + \ | |
748 RVF_MMSE_POOL_SIZE + \ | |
749 RVF_MSFE_POOL_SIZE + RVF_MSME_POOL_SIZE + RVF_PHSE_POOL_SIZE + \ | |
750 RVF_PRSE_POOL_SIZE + RVF_SECE_POOL_SIZE + RVF_SELE_POOL_SIZE + \ | |
751 RVF_SLSE_POOL_SIZE + RVF_SMAE_POOL_SIZE + RVF_STKE_POOL_SIZE + \ | |
752 RVF_IT0E_POOL_SIZE + RVF_EMAE_POOL_SIZE + RVF_EMSE_POOL_SIZE + \ | |
753 RVF_IT1E_POOL_SIZE + RVF_IT2E_POOL_SIZE + RVF_IMG_POOL_SIZE + \ | |
754 RVF_SMBS_POOL_SIZE + RVF_MFW_POOL_SIZE + RVF_AUDIO_BGD_POOL_SIZE + \ | |
755 RVF_BTA_POOL_SIZE + RVF_BTU_POOL_SIZE + RVF_GKI_POOL_SIZE + \ | |
756 RVF_BTUI_POOL_SIZE + RVF_BTH_POOL_SIZE + RVF_RPC_POOL_SIZE + \ | |
757 RVF_DCFG_POOL_SIZE + RVF_MDL_POOL_SIZE) | |
758 | |
759 #if (RVF_NB_POOLS > 1 ) | |
760 #define RVF_POOL_1_SIZE 0 | |
761 #endif | |
762 | |
763 /* define the memory usage ratio */ | |
764 /* e.g. the ratio between the sum of the memory banks sizes and the memory available in the system */ | |
765 /* for example: 90 for 90 % to be sure to always satisfy memory requests*/ | |
766 /* 120 for 120 % to optimize memory usage */ | |
767 #define RVF_MEM_USAGE_RATIO 100 | |
768 | |
769 #endif /* _RVF_POOL_SIZE_H */ | |
770 |