Add VIDENC2 headers
[gstreamer-omap:libdce.git] / packages / codec_engine / ti / sdo / ce / osal / Memory.h
1 /* 
2  * Copyright (c) 2010, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  * 
32  */
33 /*
34  *  ======== Memory.h ========
35  */
36 /**
37  *  @file       ti/sdo/ce/osal/Memory.h
38  *
39  *  @brief      The Codec Engine OSAL Memory interface.  Provides the user
40  *              an OS-independent Memory abstraction.
41  */
42 /**
43  *  @defgroup   ti_sdo_ce_osal_Memory Memory - OS Independent Memory Interface
44  *
45  *  This Memory module provides services to manage memory in OS independent
46  *  environments.
47  *
48  *  @hasPackagePrefix{ti_sdo_ce_osal,Memory,alloc,ti/sdo/ce/osal}
49  */
50
51 #ifndef ti_sdo_ce_osal_Memory_
52 #define ti_sdo_ce_osal_Memory_
53
54 #ifdef __cplusplus
55 extern "C" {
56 #endif
57
58 /** @ingroup    ti_sdo_ce_osal_Memory */
59 /*@{*/
60
61 /**
62  *  @brief Default Alignment
63  *
64  *  @hasShortName{Memory_DEFAULTALIGNMENT}
65  *
66  *  @sa ti_sdo_ce_osal_Memory_AllocParams.align
67  */
68 #define ti_sdo_ce_osal_Memory_DEFAULTALIGNMENT ((UInt)(-1))
69
70 /**
71  * @brief       Name to pass to Diags_setMask() to enable logging for Memory
72  *              functions. For example,
73  *                  Diags_setMask(Memory_MODNAME"+EX1234567");
74  *              turns on all Log statements in this module.
75  *              Diags_setMask() must be called after initialization to take
76  *              effect.
77  */
78 #define Memory_MODNAME "ti.sdo.ce.osal.Memory"
79
80 /**
81  *  @brief GT name containing the trace mask for this module
82  *
83  *  @hasShortName{Memory_GTNAME}
84  */
85 #define ti_sdo_ce_osal_Memory_GTNAME "OM"
86
87 /** @cond INTERNAL */
88
89 /**
90  *  @brief      Statistics structure for a memory section.
91  *
92  *  @hasShortName{Memory_Stat}
93  *
94  *  @remarks    Applicable to BIOS only.
95  */
96 typedef struct ti_sdo_ce_osal_Memory_Stat {
97     String name;     /**< Name of memory segment. */
98     Uint32 base;     /**< Base of memory segment. */
99     UInt size;       /**< Original size of segment. */
100     UInt used;       /**< Number of bytes used in segment. */
101     UInt length;     /**< Length of largest contiguous block. */
102 } ti_sdo_ce_osal_Memory_Stat;
103
104 /** @endcond */
105
106 /**
107  *  @brief      Enum values for ti_sdo_ce_osal_Memory_AllocParams.type
108  *
109  *  @hasShortName{Memory_type}
110  *
111  *  @sa ti_sdo_ce_osal_Memory_AllocParams
112  */
113 typedef enum {
114     ti_sdo_ce_osal_Memory_MALLOC = 0,   /**< malloc()-based allocation
115                                          *
116                                          *  @hasShortName{Memory_MALLOC}
117                                          */
118     ti_sdo_ce_osal_Memory_SEG = 1,      /**< DSP/BIOS segment-based allocation
119                                          *
120                                          *  @hasShortName{Memory_SEG}
121                                          */
122     ti_sdo_ce_osal_Memory_CONTIGPOOL = 2, /**< Contiguous, pool-based allocation
123                                          *
124                                          *  @hasShortName{Memory_CONTIGPOOL}
125                                          */
126     ti_sdo_ce_osal_Memory_CONTIGHEAP =3 /**< Contiguous, heap-based allocation
127                                          *
128                                          *  @hasShortName{Memory_CONTIGHEAP}
129                                          */
130 } ti_sdo_ce_osal_Memory_type;
131
132 /**
133  * @brief       Parameters for ti_sdo_ce_osal_Memory_alloc() &
134  *              ti_sdo_ce_osal_Memory_free()
135  *
136  * @hasShortName{Memory_AllocParams}
137  *
138  * @sa ti_sdo_ce_osal_Memory_DEFAULTPARAMS
139  */
140 typedef struct ti_sdo_ce_osal_Memory_AllocParams {
141     ti_sdo_ce_osal_Memory_type type;    /**< Type of allocation.
142                          *
143                          *   @sa ti_sdo_ce_osal_Memory_type
144                          */
145     UInt flags;         /**< Flags affecting allocation.
146                          *
147                          *   @sa ti_sdo_ce_osal_Memory_CACHED
148                          *   @sa ti_sdo_ce_osal_Memory_NONCACHED
149                          */
150     UInt align;         /**< Alignment of allocation. */
151     UInt seg;           /**< Segment for allocation. */
152 } ti_sdo_ce_osal_Memory_AllocParams;
153
154
155 /**
156  *  @brief      Cached allocation
157  *
158  *  @hasShortName{Memory_CACHED}
159  *
160  *  @sa ti_sdo_ce_osal_Memory_AllocParams.flags
161  */
162 #define ti_sdo_ce_osal_Memory_CACHED    0x00000000
163
164 /**
165  *  @brief      Non-cached allocation
166  *
167  *  @hasShortName{Memory_NONCACHED}
168  *
169  *  @sa ti_sdo_ce_osal_Memory_AllocParams.flags
170  */
171 #define ti_sdo_ce_osal_Memory_NONCACHED 0x00000001
172
173 /**
174  *  @brief      Mask to isolate cache flag
175  *
176  *  @hasShortName{Memory_NONCACHEDMASK}
177  *
178  *  @sa ti_sdo_ce_osal_Memory_AllocParams.flags
179  */
180 #define ti_sdo_ce_osal_Memory_CACHEDMASK 0x00000001
181
182 /**
183  *  @brief   Default parameters for ti_sdo_ce_osal_Memory_alloc() &
184  *           ti_sdo_ce_osal_Memory_free()
185  *
186  *  @hasShortName{Memory_DEFAULTPARAMS}
187  *
188  *  @remarks    ti_sdo_ce_osal_Memory_DEFAULTPARAMS will be used when NULL is
189  *              passed in the ti_sdo_ce_osal_Memory_AllocParams parameter for
190  *              ti_sdo_ce_osal_Memory_alloc() & ti_sdo_ce_osal_Memory_free().
191  *              When passing a non-NULL ti_sdo_ce_osal_Memory_AllocParams
192  *              parameter, you should first copy
193  *              ti_sdo_ce_osal_Memory_DEFAULTPARAMS to your structure and then
194  *              modify individual elements as needed:
195  *
196  * @code
197  *      Memory_AllocParams  myParams;
198  *
199  *      myParams = Memory_DEFAULTPARAMS;
200  *      myParams.type = Memory_CONTIGHEAP;
201  * @endcode
202  *
203  * @sa      ti_sdo_ce_osal_Memory_alloc()
204  * @sa      ti_sdo_ce_osal_Memory_free()
205  */
206 extern ti_sdo_ce_osal_Memory_AllocParams ti_sdo_ce_osal_Memory_DEFAULTPARAMS;
207
208 /*
209  *  ======== Memory_alloc ========
210  */
211 /**
212  *  @brief      General memory allocation.
213  *
214  *  @param[in]  size    Number of bytes to allocate.
215  *  @param[in]  params  Parameters controlling the allocation.
216  *
217  *  @hasShortName{Memory_alloc}
218  *
219  *  @retval     NULL     The memory request failed.
220  *  @retval     non-NULL The pointer to a buffer containing the requested
221  *                       memory.
222  *
223  *  @sa         ti_sdo_ce_osal_Memory_free()
224  *  @sa         ti_sdo_ce_osal_Memory_contigAlloc()
225  */
226 extern Ptr ti_sdo_ce_osal_Memory_alloc(UInt size,
227         ti_sdo_ce_osal_Memory_AllocParams *params);
228
229 /*
230  *  ======== Memory_cacheInv ========
231  */
232 /**
233  *  @brief      Invalidate a range of cache.
234  *
235  *  @param[in]  addr            Address of the beginning of the buffer
236  *                               to invalidate.
237  *  @param[in]  sizeInBytes     Size of the buffer to invalidate.
238  *
239  *  @remarks    In addition to application usage, this is often called by
240  *              a skeleton implementor after it has received a shared memory
241  *              buffer from another processor, and before it invokes an
242  *              algorithm's interface which will operate on that shared
243  *              memory buffer.
244  *
245  *  @hasShortName{Memory_cacheInv}
246  *
247  *  @sa         ti_sdo_ce_osal_Memory_cacheWb()
248  *  @sa         ti_sdo_ce_osal_Memory_cacheWbInv()
249  */
250 extern Void ti_sdo_ce_osal_Memory_cacheInv(Ptr addr, Int sizeInBytes);
251
252
253 /*
254  *  ======== Memory_cacheWb ========
255  */
256 /**
257  *  @brief      Write back cache.
258  *
259  *  @param[in]  addr            Address of the beginning of the buffer
260  *                              to writeback.
261  *  @param[in]  sizeInBytes     Size of the buffer to writeback.
262  *
263  *  @hasShortName{Memory_cacheWb}
264  *
265  *  @sa         ti_sdo_ce_osal_Memory_cacheInv()
266  *  @sa         ti_sdo_ce_osal_Memory_cacheWbInv()
267  */
268 extern Void ti_sdo_ce_osal_Memory_cacheWb(Ptr addr, Int sizeInBytes);
269
270
271 /*
272  *  ======== Memory_cacheWbInv ========
273  */
274 /**
275  *  @brief      Write back and invalidate cache.
276  *
277  *  @param[in]  addr            Address of the beginning of the buffer
278  *                              to writeback and invalidate.
279  *  @param[in]  sizeInBytes     Size of the buffer to writeback invalidate.
280  *
281  *  @hasShortName{Memory_cacheWbInv}
282  *
283  *  @sa         ti_sdo_ce_osal_Memory_cacheInv()
284  *  @sa         ti_sdo_ce_osal_Memory_cacheWb()
285  */
286 extern Void ti_sdo_ce_osal_Memory_cacheWbInv(Ptr addr, Int sizeInBytes);
287
288
289 /*
290  *  ======== Memory_contigAlloc ========
291  */
292 /**
293  *  @brief      Allocate physically contiguous blocks of memory.
294  *
295  *  @deprecated This function has been superceded by
296  *              ti_sdo_ce_osal_Memory_alloc() and will be removed in a future
297  *              release.  Users are recommended to modify their applications
298  *              to use the new, more flexible
299  *              ti_sdo_ce_osal_Memory_alloc() instead.
300  *
301  *  @param[in]  size    Size of the buffer to allocate.
302  *  @param[in]  align   Alignment of the buffer; must be divisible by a power
303  *                      of two.
304  *
305  *  @pre        @c align must be divisible by a power of two.
306  *
307  *  @hasShortName{Memory_contigAlloc}
308  *
309  *  @retval     non-NULL Address of a physically contiguous buffer.
310  *  @retval     NULL    Unable to obtain the requested buffer.
311  *
312  *  @remarks    This is commonly called by an application wishing to obtain
313  *              a physically contiguous buffer which it must share with
314  *              another processor.
315  *
316  *  @remarks    For portability reasons, applications commonly use
317  *              this API even in environments which do not have virtual memory
318  *              or an MMU (e.g. a single processor, DSP/BIOS based system).
319  *              Doing so makes them portable to environments which <i>do</i>
320  *              have to provide physically contiguous memory to remote
321  *              processors.
322  *
323  *  @sa         ti_sdo_ce_osal_Memory_alloc()
324  *  @sa         ti_sdo_ce_osal_Memory_contigFree()
325  */
326 extern Ptr ti_sdo_ce_osal_Memory_contigAlloc(UInt size, UInt align);
327
328
329 /*
330  *  ======== Memory_contigFree ========
331  */
332 /**
333  *  @brief      Free memory allocated by ti_sdo_ce_osal_Memory_contigAlloc()
334  *
335  *  @param[in]  addr    Address of a buffer allocated by
336  *                      ti_sdo_ce_osal_Memory_contigAlloc()
337  *  @param[in]  size    Size of the buffer to free.
338  *
339  *  @hasShortName{Memory_contigFree}
340  *
341  *  @retval     TRUE    The buffer was freed and the memory pointed to by
342  *                      @c addr is no longer valid.
343  *  @retval     FALSE   The buffer couldn't be freed.
344  *
345  *  @pre        @c addr must be a valid address returned by
346  *              ti_sdo_ce_osal_Memory_contigAlloc()
347  *
348  *  @pre        @c size must be equivalent to the @c size passed in during the
349  *              ti_sdo_ce_osal_Memory_contigAlloc() allocation.
350  *
351  *  @sa         ti_sdo_ce_osal_Memory_contigAlloc()
352  */
353 extern Bool ti_sdo_ce_osal_Memory_contigFree(Ptr addr, UInt size);
354
355
356
357 /*
358  *  ======== Memory_free ========
359  */
360 /**
361  *  @brief      Free memory allocated with ti_sdo_ce_osal_Memory_alloc().
362  *
363  *  @param[in]  addr    Address of a buffer allocated by
364  *                      ti_sdo_ce_osal_Memory_alloc().
365  *  @param[in]  size    Size of the buffer to free.
366  *  @param[in]  params  Parameters controlling the free operation.
367  *
368  *  @hasShortName{Memory_free}
369  *
370  *  @retval     TRUE    The buffer was freed and the memory pointed to by
371  *                      @c addr is no longer valid.
372  *  @retval     FALSE   The buffer couldn't be freed.
373  *
374  *  @pre        @c addr must be a valid address returned by
375  *              ti_sdo_ce_osal_Memory_alloc().
376  *
377  *  @pre        @c size must be equivalent to the @c size passed in during the
378  *              ti_sdo_ce_osal_Memory_alloc() allocation.
379  *
380  *  @pre        @c params must be equivalent to the @c params passed in during
381  *              the ti_sdo_ce_osal_Memory_alloc() allocation.
382  *
383  *  @sa         ti_sdo_ce_osal_Memory_alloc()
384  */
385 extern Bool ti_sdo_ce_osal_Memory_free(Ptr addr, UInt size,
386         ti_sdo_ce_osal_Memory_AllocParams *params);
387
388
389 /*
390  *  ======== Memory_getBufferPhysicalAddress ========
391  */
392 /**
393  *  @brief      Converts application virtual address to a physical address.
394  *
395  *  This API also checks verifies that the buffer is really contiguous.
396  *
397  *  @param[in]  virtualAddress  Address of a buffer.
398  *  @param[in]  sizeInBytes     Size of the buffer.
399  *  @param[out] isContiguous    Optional flag indicating whether the buffer
400  *                              was physically contiguous or not.
401  *
402  *  @retval     0               Failure, the physical address could not
403  *                              be obtained.
404  *  @retval     non-zero        The physical address of the buffer.
405  *
406  *  @remarks    @c sizeInBytes must be non-zero.
407  *
408  *  @remarks    @c isContiguous is an optional parameter, and can be NULL if
409  *              the caller doesn't want the results of this check.
410  *              If @c isContiguous is NULL but the buffer is not contiguous,
411  *              error trace will be generated.
412  *
413  *  @remarks    If a physically discontiguous buffer is provided in
414  *              @c virtualAddress, zero will be returned.  And if
415  *              @c isContiguous is non-null, it will be set to FALSE.
416  *
417  *  @remarks    This is typically called by a stub implementation to
418  *              translate an application-side virtual address into a physical
419  *              address usable by a remote skeleton and algorithm.
420  *
421  *  @remarks    To enable portable code, this is safe to call on systems
422  *              without virtual memory.  In those cases, the returned
423  *              physical buffer will be the same as the provided
424  *              "virtual" buffer.
425  *
426  *  @hasShortName{Memory_getBufferPhysicalAddress}
427  *
428  *  @sa         ti_sdo_ce_osal_Memory_getBufferVirtualAddress()
429  */
430 extern UInt32 ti_sdo_ce_osal_Memory_getBufferPhysicalAddress(Ptr virtualAddress,
431     Int sizeInBytes, Bool *isContiguous);
432
433 /*
434  *  ======== Memory_getBufferVirtualAddress ========
435  */
436 /**
437  *  @brief      Obtains the virtual address of a physically contiguous
438  *              buffer.
439  *
440  *  @param[in]  physicalAddress Physical address of a buffer.
441  *  @param[in]  sizeInBytes     Size of the buffer.
442  *
443  *  @retval     NULL            Failure, the virtual address could not
444  *                              be obtained.
445  *  @retval     non-zero        The virtual address of the buffer.
446  *
447  *  @remarks    @c sizeInBytes must be non-zero.
448  *
449  *  @remarks    If @c virtualAddress, was not acquired by
450  *              ti_sdo_ce_osal_Memory_getBufferPhysicalAddress(), no attempt is
451  *              made to map the physically contiguous buffer into the
452  *              application's virtual memory space.
453  *
454  *  @remarks    This is typically called by a stub implementation to
455  *              translate a buffer provided by a remote skeleton and/or
456  *              algorithm into an application-usable, virtual address.
457  *
458  *  @remarks    On some homogenous multicore devices (e.g. C6472), this
459  *              service translates a local address to a global address
460  *              that's visible by a different processor.
461  *
462  *  @remarks    To enable portable code, this is safe to call on systems
463  *              without virtual memory.  In those cases, the returned
464  *              "virtual" buffer will be the same as the provided
465  *              physical buffer.
466  *
467  *  @hasShortName{Memory_getBufferVirtualAddress}
468  *
469  *  @sa         ti_sdo_ce_osal_Memory_getBufferPhysicalAddress()
470  */
471 extern Ptr ti_sdo_ce_osal_Memory_getBufferVirtualAddress(UInt32 physicalAddress,
472     Int sizeInBytes);
473
474 /** @cond INTERNAL */
475
476 /*
477  *  ======== Memory_init ========
478  */
479 extern Bool ti_sdo_ce_osal_Memory_init(Void);
480
481
482 /*
483  *  ======== Memory_exit ========
484  */
485 extern Void ti_sdo_ce_osal_Memory_exit(Void);
486
487 /** @endcond */
488
489
490 /** @cond INTERNAL */
491
492 /*
493  *  ======== Memory_segAlloc ========
494  */
495 /**
496  *  @brief      Allocate memory from a specific segment.
497  *
498  *  @privateFxn
499  *
500  *  @param[in]  segId   Segment ID to allocate the buffer from.
501  *  @param[in]  size    Size of the buffer to allocate.
502  *  @param[in]  align   Alignment of the buffer, must be divisible by a power
503  *                      of two.
504  *
505  *  @retval     non-NULL Address of a physically contiguous buffer.
506  *  @retval     NULL    Unable to obtain the requested buffer.
507  *
508  *  @hasShortName{Memory_segAlloc}
509  *
510  *  @sa         ti_sdo_ce_osal_Memory_segFree()
511  *  @sa         ti_sdo_ce_osal_Memory_segStat()
512  *  @sa         ti_sdo_ce_osal_Memory_alloc()
513  *  @sa         ti_sdo_ce_osal_Memory_contigAlloc()
514  */
515 extern Ptr ti_sdo_ce_osal_Memory_segAlloc(Int segId, UInt size, UInt align);
516
517
518 /*
519  *  ======== Memory_segFree ========
520  */
521 /**
522  *  @brief      Free memory allocated with ti_sdo_ce_osal_Memory_segAlloc().
523  *
524  *  @privateFxn
525  *
526  *  @param[in]  segId   Segment the buffer to free was allocated from.
527  *  @param[in]  addr    Address of a buffer allocated by
528  *                      ti_sdo_ce_osal_Memory_segAlloc().
529  *  @param[in]  size    Size of the buffer to free.
530  *
531  *  @retval     TRUE    The buffer was freed and the memory pointed to by
532  *                      @c addr is no longer valid.
533  *  @retval     FALSE   The buffer couldn't be freed.
534  *
535  *  @pre        @c segId must be equivalent to the @c segid passed in during the
536  *              ti_sdo_ce_osal_Memory_segAlloc() allocation.
537  *
538  *  @pre        @c addr must be a valid address returned by
539  *              ti_sdo_ce_osal_Memory_segAlloc().
540  *
541  *  @pre        @c size must be equivalent to the @c size passed in during the
542  *              ti_sdo_ce_osal_Memory_segAlloc() allocation.
543  *
544  *  @hasShortName{Memory_segFree}
545  *
546  *  @sa         ti_sdo_ce_osal_Memory_segAlloc()
547  *  @sa         ti_sdo_ce_osal_Memory_segStat()
548  */
549 extern Bool ti_sdo_ce_osal_Memory_segFree(Int segId, Ptr addr, UInt size);
550
551
552 /*
553  *  ======== Memory_segStat ========
554  */
555 /**
556  *  @brief      Obtain the memory usage statistics of a given memory segment
557  *              allocator.
558  *
559  *  @privateFxn
560  *
561  *  @param[in]  segId   Segment ID to obtain statistics information for.
562  *  @param[out] statbuf Buffer to fill with statistics data.
563  *
564  *  @retval     TRUE    The statistics were captured, and @c statbuf has been
565  *                      filled.
566  *  @retval     FALSE   The statistics could not be obtained.
567  *
568  *  @pre        @c statbuf must be a pointer to memory of size
569  *              <tt>sizeof(#ti_sdo_ce_osal_Memory_Stat)</tt>.
570  *
571  *  @hasShortName{Memory_setStat}
572  *
573  *  @sa         ti_sdo_ce_osal_Memory_segAlloc()
574  *  @sa         ti_sdo_ce_osal_Memory_segFree()
575  */
576 extern Bool ti_sdo_ce_osal_Memory_segStat(Int segId,
577         ti_sdo_ce_osal_Memory_Stat *statbuf);
578
579 /** @endcond */
580
581 /** @cond INTERNAL */
582
583 /*
584  * ======== PREFIX ALIASES ========
585  * Same strategy as XDC uses
586  */
587 #if !defined(__nested__) && !defined(ti_sdo_ce_osal_Memory__nolocalnames)
588
589 /* module prefix */
590 #define Memory_DEFAULTALIGNMENT ti_sdo_ce_osal_Memory_DEFAULTALIGNMENT
591 #define Memory_GTNAME ti_sdo_ce_osal_Memory_GTNAME
592 #define Memory_Stat ti_sdo_ce_osal_Memory_Stat
593 #define Memory_type ti_sdo_ce_osal_Memory_type
594 #define Memory_MALLOC ti_sdo_ce_osal_Memory_MALLOC
595 #define Memory_SEG ti_sdo_ce_osal_Memory_SEG
596 #define Memory_CONTIGPOOL ti_sdo_ce_osal_Memory_CONTIGPOOL
597 #define Memory_CONTIGHEAP ti_sdo_ce_osal_Memory_CONTIGHEAP
598 #define Memory_AllocParams ti_sdo_ce_osal_Memory_AllocParams
599 #define Memory_CACHED ti_sdo_ce_osal_Memory_CACHED
600 #define Memory_NONCACHED ti_sdo_ce_osal_Memory_NONCACHED
601 #define Memory_CACHEDMASK ti_sdo_ce_osal_Memory_CACHEDMASK
602 #define Memory_DEFAULTPARAMS ti_sdo_ce_osal_Memory_DEFAULTPARAMS
603
604 #define Memory_alloc ti_sdo_ce_osal_Memory_alloc
605 #define Memory_cacheInv ti_sdo_ce_osal_Memory_cacheInv
606 #define Memory_cacheWb ti_sdo_ce_osal_Memory_cacheWb
607 #define Memory_cacheWbInv ti_sdo_ce_osal_Memory_cacheWbInv
608 #define Memory_contigAlloc ti_sdo_ce_osal_Memory_contigAlloc
609 #define Memory_contigFree ti_sdo_ce_osal_Memory_contigFree
610 #define Memory_free ti_sdo_ce_osal_Memory_free
611 #define Memory_getBufferPhysicalAddress ti_sdo_ce_osal_Memory_getBufferPhysicalAddress
612 #define Memory_getBufferVirtualAddress ti_sdo_ce_osal_Memory_getBufferVirtualAddress
613 #define Memory_init ti_sdo_ce_osal_Memory_init
614 #define Memory_exit ti_sdo_ce_osal_Memory_exit
615 #define Memory_segAlloc ti_sdo_ce_osal_Memory_segAlloc
616 #define Memory_segFree ti_sdo_ce_osal_Memory_segFree
617 #define Memory_segStat ti_sdo_ce_osal_Memory_segStat
618 #endif
619
620 /** @endcond */
621
622 /*@}*/
623
624 #ifdef __cplusplus
625 }
626 #endif
627
628 #endif
629 /*
630  *  @(#) ti.sdo.ce.osal; 2, 0, 2,395; 7-27-2010 22:15:24; /db/atree/library/trees/ce/ce-q08x/src/
631  */
632