auto import from //depot/cupcake/@135843
[android/platform/external/neven.git] / Embedded / common / src / b_BasicEm / Memory.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/Memory.h"
20 #include "b_BasicEm/Functions.h"
21 /*
22 #include <string.h>
23 */
24 /* ---- related objects  --------------------------------------------------- */
25
26 /* ---- typedefs ----------------------------------------------------------- */
27
28 /* ---- constants ---------------------------------------------------------- */
29
30 /* ------------------------------------------------------------------------- */
31
32 /* ========================================================================= */
33 /*                                                                           */
34 /* ---- \ghd{ external functions } ----------------------------------------- */
35 /*                                                                           */
36 /* ========================================================================= */
37
38 /* ------------------------------------------------------------------------- */
39 /*
40 void* bbs_memcpy( void* dstA, const void* srcA, uint32 sizeA )
41 {
42         if( sizeA & 1 )
43         {
44                 bbs_ERROR0( "bbs_memcpy( .... ): sizeA must be even" );
45                 return NULL;
46         }
47         return bbs_memcpy16( dstA, srcA, sizeA >> 1 );
48 }
49 */
50 /* ------------------------------------------------------------------------- */
51
52 void* bbs_memcpy16( void* dstA, const void* srcA, uint32 sizeA )
53 {
54 #ifdef HW_TMS320C5x
55         if( ( ( int32 ) dstA >> 16 ) == ( ( ( int32 ) dstA + sizeA ) >> 16 ) &&
56                 ( ( int32 ) srcA >> 16 ) == ( ( ( int32 ) srcA + sizeA ) >> 16 ) )
57         {
58                 /* fast version, works only if pointers do not cross page boundary. */
59                 uint16* dstL = ( uint16* )dstA;
60                 const uint16* srcL = ( uint16* )srcA;
61                 uint16 iL;
62                 for( iL = sizeA; iL--; )
63                 {
64                         *dstL++ = *srcL++;
65                 }
66         }
67         else
68         {
69                 /* safe version */
70                 uint32 iL;
71                 for( iL = 0; iL < sizeA; iL++ )
72                 {
73                         *( uint16* ) ( ( int32 ) dstA + iL ) = *( uint16* ) ( ( int32 ) srcA + iL );
74                 }
75         }
76         return dstA;
77 #else
78         uint16* dstL = ( uint16* )dstA;
79         const uint16* srcL = ( uint16* )srcA;
80
81         for( ; sizeA >= 4; sizeA -= 4 )
82         {
83                 dstL[ 0 ] = srcL[ 0 ];
84                 dstL[ 1 ] = srcL[ 1 ];
85                 dstL[ 2 ] = srcL[ 2 ];
86                 dstL[ 3 ] = srcL[ 3 ];
87                 dstL += 4;
88                 srcL += 4;
89         }
90
91         for( ; sizeA > 0; sizeA-- )
92         {
93                 *dstL++ = *srcL++;
94         }
95
96         return dstA;
97 #endif
98 }
99
100 /* ------------------------------------------------------------------------- */
101
102 void* bbs_memcpy32( void* dstA, const void* srcA, uint32 sizeA )
103 {
104 #ifdef HW_TMS320C5x
105         if( ( ( int32 ) dstA >> 16 ) == ( ( ( int32 ) dstA + ( sizeA << 1 ) ) >> 16 ) &&
106                 ( ( int32 ) srcA >> 16 ) == ( ( ( int32 ) srcA + ( sizeA << 1 ) ) >> 16 ) )
107         {
108                 /* fast version, works only if pointers do not cross page boundary. */
109                 uint32* dstL = ( uint32* )dstA;
110                 const uint32* srcL = ( uint32* )srcA;
111                 uint16 iL;
112                 for( iL = sizeA; iL--; )
113                 {
114                         *dstL++ = *srcL++;
115                 }
116         }
117         else
118         {
119                 /* safe version */
120                 uint32 iL;
121                 sizeA <<= 1;
122                 for( iL = 0; iL < sizeA; iL += 2 )
123                 {
124                         *( uint32* ) ( ( int32 ) dstA + iL ) = *( uint32* ) ( ( int32 ) srcA + iL );
125                 }
126         }
127         return dstA;
128 /*
129         uint16* dstL = ( uint16* )dstA;
130         const uint16* srcL = ( uint16* )srcA;
131
132         // copying with base object-size of 16bit 
133         // is more efficient on 16 bit architecture
134         sizeA <<= 1;
135
136         for( ; sizeA >= 4; sizeA -= 4 )
137         {
138                 dstL[ 0 ] = srcL[ 0 ];
139                 dstL[ 1 ] = srcL[ 1 ];
140                 dstL[ 2 ] = srcL[ 2 ];
141                 dstL[ 3 ] = srcL[ 3 ];
142                 dstL += 4;
143                 srcL += 4;
144         }
145
146         for( ; sizeA > 0; sizeA-- )
147         {
148                 *dstL++ = *srcL++;
149         }
150
151         return dstA;
152 */
153 #else   /* 32bit architectures */
154
155         uint32* dstL = ( uint32* )dstA;
156         const uint32* srcL = ( uint32* )srcA;
157
158         for( ; sizeA >= 4; sizeA -= 4 )
159         {
160                 dstL[ 0 ] = srcL[ 0 ];
161                 dstL[ 1 ] = srcL[ 1 ];
162                 dstL[ 2 ] = srcL[ 2 ];
163                 dstL[ 3 ] = srcL[ 3 ];
164                 dstL += 4;
165                 srcL += 4;
166         }
167
168         for( ; sizeA > 0; sizeA-- )
169         {
170                 *dstL++ = *srcL++;
171         }
172
173         return dstA;
174
175 #endif
176 }
177
178 /* ------------------------------------------------------------------------- */
179
180 void* bbs_memset16( void* dstA, uint16 valA, uint32 sizeA )
181 {
182         uint32 iL;
183         uint16* dstL = ( uint16* )dstA;
184         /* to be optimized */
185         for( iL = 0; iL < sizeA; iL++ )
186         {
187                 *dstL++ = valA;
188         }
189         return dstA;
190 }
191
192 /* ------------------------------------------------------------------------- */
193
194 void* bbs_memset32( void* dstA, uint32 valA, uint32 sizeA )
195 {
196         uint32 iL;
197         uint32* dstL = ( uint32* )dstA;
198         /* to be optimized */
199         for( iL = 0; iL < sizeA; iL++ )
200         {
201                 *dstL++ = valA;
202         }
203         return dstA;
204 }
205
206 /* ------------------------------------------------------------------------- */
207