auto import from //depot/cupcake/@135843
[android/platform/external/neven.git] / Embedded / common / src / b_BasicEm / MemTbl.c
1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /* ---- includes ----------------------------------------------------------- */
18
19 #include "b_BasicEm/Context.h"
20 #include "b_BasicEm/MemTbl.h"
21 #include "b_BasicEm/Functions.h"
22
23 /* ------------------------------------------------------------------------- */
24
25 /* ========================================================================= */
26 /*                                                                           */
27 /* ---- \ghd{ auxiliary functions } ---------------------------------------- */
28 /*                                                                           */
29 /* ========================================================================= */
30
31 /* ------------------------------------------------------------------------- */
32
33 flag bbs_MemTbl_memOverlap( const uint16* memPtr1A, uint32 size1A, 
34                                                     const uint16* memPtr2A, uint32 size2A )
35 {
36         int32 diffL = memPtr2A - memPtr1A;
37         if( diffL >= 0 && diffL < ( int32 )size1A ) return TRUE;
38         diffL += ( int32 )size2A;
39         if( diffL >= 0 && diffL < ( int32 )size1A ) return TRUE;
40         return FALSE;
41 }
42
43 /* ------------------------------------------------------------------------- */
44
45 /* ========================================================================= */
46 /*                                                                           */
47 /* ---- \ghd{ constructor / destructor } ----------------------------------- */
48 /*                                                                           */
49 /* ========================================================================= */
50
51 /* ------------------------------------------------------------------------- */
52
53 void bbs_MemTbl_init( struct bbs_Context* cpA,
54                                           struct bbs_MemTbl* ptrA )
55 {
56         uint32 iL;
57         for( iL = 0; iL < bbs_MAX_MEM_SEGS; iL++ )
58         {
59                 bbs_MemSeg_init( cpA, &ptrA->esArrE[ iL ] );
60                 bbs_MemSeg_init( cpA, &ptrA->ssArrE[ iL ] );
61                 ptrA->espArrE[ iL ] = NULL;
62         }
63         ptrA->esSizeE = 0;
64         ptrA->ssSizeE = 0;
65 }
66
67 /* ------------------------------------------------------------------------- */
68
69 void bbs_MemTbl_exit( struct bbs_Context* cpA,
70                                           struct bbs_MemTbl* ptrA )
71 {
72         uint32 iL;
73         for( iL = 0; iL < bbs_MAX_MEM_SEGS; iL++ )
74         {
75                 bbs_MemSeg_exit( cpA, &ptrA->esArrE[ iL ] );
76                 bbs_MemSeg_exit( cpA, &ptrA->ssArrE[ iL ] );
77                 ptrA->espArrE[ iL ] = NULL;
78         }
79         ptrA->esSizeE = 0;
80         ptrA->ssSizeE = 0;
81 }
82
83 /* ------------------------------------------------------------------------- */
84
85 /* ========================================================================= */
86 /*                                                                           */
87 /* ---- \ghd{ operators } -------------------------------------------------- */
88 /*                                                                           */
89 /* ========================================================================= */
90
91 /* ------------------------------------------------------------------------- */
92
93 /* ========================================================================= */
94 /*                                                                           */
95 /* ---- \ghd{ query functions } -------------------------------------------- */
96 /*                                                                           */
97 /* ========================================================================= */
98
99 /* ------------------------------------------------------------------------- */
100
101 flag bbs_MemTbl_overlap( struct bbs_Context* cpA,
102                                                  struct bbs_MemTbl* ptrA, 
103                                                  const void* memPtrA, uint32 sizeA )
104 {
105         uint32 iL;
106         for( iL = 0; iL < ptrA->esSizeE; iL++ )
107         {
108                 if( bbs_MemTbl_memOverlap( ptrA->espArrE[ iL ]->memPtrE, 
109                                                                    ptrA->espArrE[ iL ]->sizeE,
110                                                                    memPtrA, sizeA ) )
111                 {
112                         return TRUE;
113                 }
114         }
115
116         for( iL = 0; iL < ptrA->ssSizeE; iL++ )
117         {
118                 if( bbs_MemTbl_memOverlap( ptrA->ssArrE[ iL ].memPtrE, 
119                                                                    ptrA->ssArrE[ iL ].sizeE,
120                                                                    memPtrA, sizeA ) )
121                 {
122                         return TRUE;
123                 }
124         }
125
126         return FALSE;
127 }
128
129 /* ------------------------------------------------------------------------- */
130
131 /* ========================================================================= */
132 /*                                                                           */
133 /* ---- \ghd{ modify functions } ------------------------------------------- */
134 /*                                                                           */
135 /* ========================================================================= */
136
137 /* ------------------------------------------------------------------------- */
138         
139 /* ========================================================================= */
140 /*                                                                           */
141 /* ---- \ghd{ I/O } -------------------------------------------------------- */
142 /*                                                                           */
143 /* ========================================================================= */
144
145 /* ------------------------------------------------------------------------- */
146         
147 /* ========================================================================= */
148 /*                                                                           */
149 /* ---- \ghd{ exec functions } --------------------------------------------- */
150 /*                                                                           */
151 /* ========================================================================= */
152         
153 /* ------------------------------------------------------------------------- */
154
155 void bbs_MemTbl_create( struct bbs_Context* cpA,
156                                             struct bbs_MemTbl* ptrA, 
157                                                 void* memPtrA, 
158                                                 uint32 sizeA, 
159                                                 uint32 sharedSubSizeA )
160 {
161         if( sharedSubSizeA > sizeA )
162         {
163                 bbs_ERROR0( "struct bbs_MemTbl bbs_MemTbl_create( void* memPtrA, uint32 sizeA, uint32 sharedSubSizeA ):\n"
164                                "sharedSubSizeA > sizeA" );
165                 return;
166         }
167         bbs_MemTbl_init( cpA, ptrA );
168
169         
170         ptrA->esArrE[ 0 ] = bbs_MemSeg_create( cpA, memPtrA, sizeA - sharedSubSizeA );
171         #ifdef HW_TMS320C5x             
172                 ptrA->ssArrE[ 0 ] = bbs_MemSeg_createShared( cpA, ( uint16* ) ( ( int32 ) ( ( uint16* )memPtrA ) + sizeA - sharedSubSizeA ), sharedSubSizeA );
173         #else
174                 ptrA->ssArrE[ 0 ] = bbs_MemSeg_createShared( cpA, ( uint16* )memPtrA + sizeA - sharedSubSizeA, sharedSubSizeA );
175         #endif
176         ptrA->espArrE[ 0 ] = &ptrA->esArrE[ 0 ];
177
178         ptrA->esSizeE = 1;
179         ptrA->ssSizeE = 1;
180 }
181
182 /* ------------------------------------------------------------------------- */
183
184 void bbs_MemTbl_add( struct bbs_Context* cpA,
185                                          struct bbs_MemTbl* ptrA, 
186                                          void* memPtrA, 
187                                          uint32 sizeA, 
188                                          uint32 idA )
189 {
190         if( ptrA->esSizeE == bbs_MAX_MEM_SEGS )
191         {
192                 bbs_ERROR0( "void bbs_MemTbl_add( struct bbs_MemTbl* ptrA, void* memPtrA, uint32 sizeA ):\n"
193                                "Table is full! Increase constant bbs_MAX_MEM_SEGS" );
194                 return;
195         }
196         ptrA->esArrE[ ptrA->esSizeE ] = bbs_MemSeg_create( cpA, memPtrA, sizeA );
197         ptrA->esArrE[ ptrA->esSizeE ].idE = idA;
198         ptrA->espArrE[ ptrA->esSizeE ] = &ptrA->esArrE[ ptrA->esSizeE ];
199         ptrA->esSizeE++;
200 }
201
202 /* ------------------------------------------------------------------------- */
203
204 void bbs_MemTbl_addShared( struct bbs_Context* cpA,
205                                                    struct bbs_MemTbl* ptrA, 
206                                                    void* memPtrA, 
207                                                    uint32 sizeA, 
208                                                    uint32 idA )
209 {
210         if( ptrA->ssSizeE == bbs_MAX_MEM_SEGS )
211         {
212                 bbs_ERROR0( "void bbs_MemTbl_addShared( struct bbs_MemTbl* ptrA, void* memPtrA, uint32 sizeA ):\n"
213                                "Table is full! Increase constant bbs_MAX_MEM_SEGS" );
214                 return;
215         }
216         ptrA->ssArrE[ ptrA->ssSizeE ] = bbs_MemSeg_createShared( cpA, memPtrA, sizeA );
217         ptrA->ssArrE[ ptrA->ssSizeE ].idE = idA;
218         ptrA->ssSizeE++;
219 }
220
221 /* ------------------------------------------------------------------------- */
222
223 struct bbs_MemSeg* bbs_MemTbl_segPtr( struct bbs_Context* cpA,
224                                                                           struct bbs_MemTbl* ptrA, 
225                                                                           uint32 idA )
226 {
227         uint32 iL;
228         if( ptrA->esSizeE == 0 )
229         {
230                 bbs_ERROR0( "bbs_MemTbl_segPtr(): Table contains no exclusive segments." );
231                 return NULL;
232         }
233         if( idA > 0 ) 
234         {
235                 for( iL = 0; iL < ptrA->esSizeE; iL++ )
236                 {
237                         if( idA == ptrA->espArrE[ iL ]->idE ) return ptrA->espArrE[ iL ];
238                 }
239         }
240         for( iL = 0; iL < ptrA->esSizeE; iL++ )
241         {
242                 if( ptrA->espArrE[ iL ]->sizeE > 0 ||
243                         ptrA->espArrE[ iL ]->dynMemManagerPtrE != 0 )
244                 {
245                         return ptrA->espArrE[ iL ];
246                 }
247         }
248         bbs_ERR0( bbs_ERR_MEMORY_OVERFLOW,
249                           "bbs_MemTbl_segPtr(): Table contains no valid exclusive segments." );
250         return 0;
251 }
252
253 /* ------------------------------------------------------------------------- */
254
255 struct bbs_MemSeg* bbs_MemTbl_sharedSegPtr( struct bbs_Context* cpA,
256                                                                                     struct bbs_MemTbl* ptrA, 
257                                                                                         uint32 idA )
258 {
259         uint32 iL;
260         if( ptrA->ssSizeE == 0 )
261         {
262                 bbs_ERROR0( "bbs_MemTbl_sharedSegPtr(): Table contains no shared segments." );
263                 return NULL;
264         }
265         if( idA > 0 ) 
266         {
267                 for( iL = 0; iL < ptrA->ssSizeE; iL++ )
268                 {
269                         if( idA == ptrA->ssArrE[ iL ].idE ) return &ptrA->ssArrE[ iL ];
270                 }
271         }
272         for( iL = 0; iL < ptrA->ssSizeE; iL++ )
273         {
274                 if( ptrA->ssArrE[ iL ].sizeE > 0 ||
275                         ptrA->ssArrE[ iL ].dynMemManagerPtrE != 0 )
276                 {
277                         return &ptrA->ssArrE[ iL ];
278                 }
279         }
280         bbs_ERR0( bbs_ERR_MEMORY_OVERFLOW,
281                           "bbs_MemTbl_sharedSegPtr(): Table contains no valid shared segments." );
282         return 0;
283 }
284
285 /* ------------------------------------------------------------------------- */
286
287 struct bbs_MemSeg* bbs_MemTbl_fastestSegPtr( struct bbs_Context* cpA,
288                                                                                          struct bbs_MemTbl* ptrA, 
289                                                                                          uint32 minSizeA )
290 {
291         uint32 iL;
292         for( iL = 0; iL < ptrA->esSizeE; iL++ )
293         {
294                 if( bbs_MemSeg_availableSize( cpA, ptrA->espArrE[ iL ] ) >= minSizeA ) break;
295         }
296         if( iL == ptrA->esSizeE )
297         {
298                 if( ptrA->esSizeE == 0 )
299                 {
300                         bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_fastestSegPtr( struct bbs_MemTbl* ptrA, uint32 minSizeA ):\n"
301                                            "Table contains no exclusive segments" );
302                         return NULL;
303                 }
304                 else
305                 {
306                         bbs_ERR0( bbs_ERR_MEMORY_OVERFLOW,
307                                           "struct bbs_MemSeg* bbs_MemTbl_fastestSegPtr( struct bbs_MemTbl* ptrA, uint32 minSizeA ):\n"
308                                           "Could not find segment with sufficient free space" );
309                         return NULL;
310                 }
311         }
312         if( ptrA->espArrE[ iL ]->sharedE )
313         {
314                 bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_fastestSegPtr( struct bbs_MemTbl* ptrA, uint32 minSizeA ):\n"
315                                "Table corrupt: Found shared segment in exclusive table" );
316                 return NULL;
317         }
318
319         return ptrA->espArrE[ iL ];
320 }
321
322 /* ------------------------------------------------------------------------- */
323
324 struct bbs_MemSeg* bbs_MemTbl_largestSegPtr( struct bbs_Context* cpA,
325                                                                                          struct bbs_MemTbl* ptrA )
326 {
327         uint32 iL;
328         uint32 maxIndexL = 0;
329         uint32 maxSizeL = 0;
330
331         if( ptrA->esSizeE == 0 )
332         {
333                 bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_largestSegPtr( struct bbs_MemTbl* ptrA ):\n"
334                                "No exclusive segments available" );
335                 return NULL;
336         }
337
338         for( iL = 0; iL < ptrA->esSizeE; iL++ )
339         {
340                 uint32 sizeL = bbs_MemSeg_availableSize( cpA, ptrA->espArrE[ iL ] );
341                 if( sizeL > maxSizeL )
342                 {
343                         maxSizeL = sizeL;
344                         maxIndexL = iL;
345                 }
346         }
347
348         if( ptrA->espArrE[ maxIndexL ]->sharedE )
349         {
350                 bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_largestSegPtr( struct bbs_MemTbl* ptrA ):\n"
351                                "Table corrupt: Found shared segment in exclusive table" );
352                 return NULL;
353         }
354
355         return ptrA->espArrE[ maxIndexL ];
356 }
357
358 /* ------------------------------------------------------------------------- */
359
360 struct bbs_MemSeg* bbs_MemTbl_fastestSharedSegPtr( struct bbs_Context* cpA,
361                                                                                                    struct bbs_MemTbl* ptrA, 
362                                                                                                    uint32 minSizeA )
363 {
364         uint32 iL;
365         for( iL = 0; iL < ptrA->ssSizeE; iL++ )
366         {
367                 if( bbs_MemSeg_availableSize( cpA, &ptrA->ssArrE[ iL ] ) >= minSizeA ) break;
368         }
369         if( iL == ptrA->ssSizeE )
370         {
371                 if( ptrA->esSizeE == 0 )
372                 {
373                         bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_fastestSegPtr( struct bbs_MemTbl* ptrA, uint32 minSizeA ):\n"
374                                            "Table contains no shared segments" );
375                         return NULL;
376                 }
377                 else
378                 {
379                         bbs_ERR0( bbs_ERR_MEMORY_OVERFLOW, 
380                                           "struct bbs_MemSeg* bbs_MemTbl_fastestSharedSegPtr( struct bbs_MemTbl* ptrA, uint32 minSizeA ):\n"
381                                           "Could not find segment with sufficient free space" );
382                         return NULL;
383                 }
384         }
385         if( !ptrA->ssArrE[ iL ].sharedE )
386         {
387                 bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_fastestSharedSegPtr( struct bbs_MemTbl* ptrA, uint32 minSizeA ):\n"
388                                "Table corrupt: Found exclusive segment in shared table" );
389                 return NULL;
390         }
391
392         return &ptrA->ssArrE[ iL ];
393 }
394
395 /* ------------------------------------------------------------------------- */
396
397 struct bbs_MemSeg* bbs_MemTbl_largestSharedSegPtr( struct bbs_Context* cpA,
398                                                                                                    struct bbs_MemTbl* ptrA )
399 {
400         uint32 iL;
401         uint32 maxIndexL = 0;
402         uint32 maxSizeL = 0;
403
404         if( ptrA->ssSizeE == 0 )
405         {
406                 bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_largestSharedSegPtr( struct bbs_MemTbl* ptrA ):\n"
407                                "No shared segments available" );
408                 return NULL;
409         }
410
411         for( iL = 0; iL < ptrA->ssSizeE; iL++ )
412         {
413                 uint32 sizeL = bbs_MemSeg_availableSize( cpA, &ptrA->ssArrE[ iL ] );
414                 if( sizeL > maxSizeL )
415                 {
416                         maxSizeL = sizeL;
417                         maxIndexL = iL;
418                 }
419         }
420
421         if( !ptrA->ssArrE[ maxIndexL ].sharedE )
422         {
423                 bbs_ERROR0( "struct bbs_MemSeg* bbs_MemTbl_largestSharedSegPtr( struct bbs_MemTbl* ptrA ):\n"
424                                "Table corrupt: Found exclusive segment in shared table" );
425                 return NULL;
426         }
427
428         return &ptrA->ssArrE[ maxIndexL ];
429 }
430
431 /* ------------------------------------------------------------------------- */
432
433 /* ========================================================================= */
434
435