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/Functions.h"
20 #include "b_BasicEm/Context.h"
21 
22 /* ---- related objects  --------------------------------------------------- */
23 
24 /* ---- typedefs ----------------------------------------------------------- */
25 
26 /* ---- constants ---------------------------------------------------------- */
27 
28 /* ---- globals   ---------------------------------------------------------- */
29 
30 /* ------------------------------------------------------------------------- */
31 
32 /* ========================================================================= */
33 /*                                                                           */
34 /* ---- \ghd{ external functions } ----------------------------------------- */
35 /*                                                                           */
36 /* ========================================================================= */
37 
38 /* ------------------------------------------------------------------------- */
39 
bbs_swapBytes(uint16 valA)40 uint16 bbs_swapBytes( uint16 valA )
41 {
42 	return ( ( valA >> 8 ) & 0x00FF ) | ( ( valA << 8 ) & 0xFF00 );
43 }
44 
45 /* ------------------------------------------------------------------------- */
46 
bbs_memWrite32(const void * ptrA,uint16 * memPtrA)47 uint32 bbs_memWrite32( const void* ptrA,
48 					   uint16* memPtrA )
49 {
50 	uint32 valL = *( uint32* )ptrA;
51 
52 	#ifdef HW_BIG_ENDIAN
53 		*memPtrA++ = bbs_swapBytes( ( uint16 )( ( valL >> 0  ) & 0xFFFF ) );
54 		*memPtrA++ = bbs_swapBytes( ( uint16 )( ( valL >> 16 ) & 0xFFFF ) );
55 	#else
56 		*memPtrA++ = ( valL >> 0  ) & 0xFFFF;
57 		*memPtrA++ = ( valL >> 16 ) & 0xFFFF;
58 	#endif
59 
60 
61 	return bbs_SIZEOF16( uint32 );
62 }
63 
64 /* ------------------------------------------------------------------------- */
65 
bbs_memRead32(void * ptrA,const uint16 * memPtrA)66 uint32 bbs_memRead32( void* ptrA,
67 					  const uint16* memPtrA )
68 {
69 	uint32 valL = 0;
70 
71 	#ifdef HW_BIG_ENDIAN
72 		valL |= ( ( uint32 )bbs_swapBytes( *memPtrA++ ) << 0  );
73 		valL |= ( ( uint32 )bbs_swapBytes( *memPtrA++ ) << 16 );
74 	#else
75 		valL |= ( ( uint32 )*memPtrA++ << 0  );
76 		valL |= ( ( uint32 )*memPtrA++ << 16 );
77 	#endif
78 
79 	*( uint32* )ptrA = valL;
80 
81 	return bbs_SIZEOF16( uint32 );
82 }
83 
84 /* ------------------------------------------------------------------------- */
85 
bbs_memPeek32(const uint16 * memPtrA)86 uint32 bbs_memPeek32( const uint16* memPtrA )
87 {
88 	uint32 valL = 0;
89 
90 	#ifdef HW_BIG_ENDIAN
91 		valL |= ( ( uint32 )bbs_swapBytes( *memPtrA++ ) << 0  );
92 		valL |= ( ( uint32 )bbs_swapBytes( *memPtrA++ ) << 16 );
93 	#else
94 		valL |= ( ( uint32 )*memPtrA++ << 0  );
95 		valL |= ( ( uint32 )*memPtrA++ << 16 );
96 	#endif
97 
98 	return valL;
99 }
100 
101 /* ------------------------------------------------------------------------- */
102 
bbs_memWrite16(const void * ptrA,uint16 * memPtrA)103 uint32 bbs_memWrite16( const void* ptrA,
104 					   uint16* memPtrA )
105 {
106 	#ifdef HW_BIG_ENDIAN
107 		*memPtrA++ = bbs_swapBytes( *( uint16* )ptrA );
108 	#else
109 		*memPtrA++ = *( uint16* )ptrA;
110 	#endif
111 	return bbs_SIZEOF16( uint16 );
112 }
113 
114 /* ------------------------------------------------------------------------- */
115 
bbs_memRead16(void * ptrA,const uint16 * memPtrA)116 uint32 bbs_memRead16( void* ptrA,
117 					  const uint16* memPtrA )
118 {
119 	#ifdef HW_BIG_ENDIAN
120 		*( uint16* )ptrA = bbs_swapBytes( *memPtrA++ );
121 	#else
122 		*( uint16* )ptrA = *memPtrA++;
123 	#endif
124 
125 	return bbs_SIZEOF16( uint16 );
126 }
127 
128 /* ------------------------------------------------------------------------- */
129 
bbs_memWrite32Arr(struct bbs_Context * cpA,const void * ptrA,uint32 sizeA,uint16 * memPtrA)130 uint32 bbs_memWrite32Arr( struct bbs_Context* cpA,
131 						  const void* ptrA,
132 						  uint32 sizeA, uint16* memPtrA )
133 {
134 	uint32 iL;
135 	const uint32* srcL = ( uint32* )ptrA;
136 
137 	if( bbs_Context_error( cpA ) ) return 0;
138 
139 	for( iL = 0; iL < sizeA; iL++ )
140 	{
141 		memPtrA += bbs_memWrite32( srcL++, memPtrA );
142 	}
143 
144 	return sizeA * bbs_SIZEOF16( uint32 );
145 }
146 
147 /* ------------------------------------------------------------------------- */
148 
bbs_memRead32Arr(struct bbs_Context * cpA,void * ptrA,uint32 sizeA,const uint16 * memPtrA)149 uint32 bbs_memRead32Arr( struct bbs_Context* cpA,
150 						 void* ptrA,
151 						 uint32 sizeA,
152 						 const uint16* memPtrA )
153 {
154 	uint32 iL;
155 	uint32* dstL = ( uint32* )ptrA;
156 
157 	if( bbs_Context_error( cpA ) ) return 0;
158 
159 	for( iL = 0; iL < sizeA; iL++ )
160 	{
161 		memPtrA += bbs_memRead32( dstL++, memPtrA );
162 	}
163 
164 	return sizeA * bbs_SIZEOF16( uint32 );
165 }
166 
167 /* ------------------------------------------------------------------------- */
168 
bbs_memWrite16Arr(struct bbs_Context * cpA,const void * ptrA,uint32 sizeA,uint16 * memPtrA)169 uint32 bbs_memWrite16Arr( struct bbs_Context* cpA,
170 						  const void* ptrA,
171 						  uint32 sizeA,
172 						  uint16* memPtrA )
173 {
174 	uint32 iL;
175 	const uint16* srcL = ( uint16* )ptrA;
176 
177 	if( bbs_Context_error( cpA ) ) return 0;
178 
179 	for( iL = 0; iL < sizeA; iL++ )
180 	{
181 		memPtrA += bbs_memWrite16( srcL++, memPtrA );
182 	}
183 
184 	return sizeA * bbs_SIZEOF16( uint16 );
185 }
186 
187 /* ------------------------------------------------------------------------- */
188 
bbs_memRead16Arr(struct bbs_Context * cpA,void * ptrA,uint32 sizeA,const uint16 * memPtrA)189 uint32 bbs_memRead16Arr( struct bbs_Context* cpA,
190 						 void* ptrA,
191 						 uint32 sizeA,
192 						 const uint16* memPtrA )
193 {
194 	uint32 iL;
195 	uint16* dstL = ( uint16* )ptrA;
196 
197 	if( bbs_Context_error( cpA ) ) return 0;
198 
199 	for( iL = 0; iL < sizeA; iL++ )
200 	{
201 		memPtrA += bbs_memRead16( dstL++, memPtrA );
202 	}
203 
204 	return sizeA * bbs_SIZEOF16( uint16 );
205 }
206 
207 /* ------------------------------------------------------------------------- */
208 
bbs_memWriteUInt32(uint32 valA,uint16 * memPtrA)209 uint32 bbs_memWriteUInt32( uint32 valA,
210 						   uint16* memPtrA )
211 {
212 	#ifdef HW_BIG_ENDIAN
213 		*memPtrA++ = bbs_swapBytes( ( uint16 )( ( valA >> 0  ) & 0xFFFF ) );
214 		*memPtrA++ = bbs_swapBytes( ( uint16 )( ( valA >> 16 ) & 0xFFFF ) );
215 	#else
216 		*memPtrA++ = ( valA >> 0  ) & 0xFFFF;
217 		*memPtrA++ = ( valA >> 16 ) & 0xFFFF;
218 	#endif
219 
220 	return bbs_SIZEOF16( valA );
221 }
222 
223 /* ------------------------------------------------------------------------- */
224 
bbs_memWriteUInt16(uint16 valA,uint16 * memPtrA)225 uint32 bbs_memWriteUInt16( uint16 valA,
226 						   uint16* memPtrA )
227 {
228 	#ifdef HW_BIG_ENDIAN
229 		*memPtrA++ = bbs_swapBytes( valA );
230 	#else
231 		*memPtrA++ = valA;
232 	#endif
233 
234 	return bbs_SIZEOF16( valA );
235 }
236 
237 /* ------------------------------------------------------------------------- */
238 
bbs_memReadVersion32(struct bbs_Context * cpA,uint32 * versionPtrA,uint32 refVersionA,const uint16 * memPtrA)239 uint32 bbs_memReadVersion32( struct bbs_Context* cpA,
240 							 uint32* versionPtrA,
241 							 uint32 refVersionA,
242 							 const uint16* memPtrA )
243 {
244 	if( bbs_Context_error( cpA ) ) return 0;
245 
246 	bbs_memRead32( versionPtrA, memPtrA );
247 	if( *versionPtrA > refVersionA )
248 	{
249 		bbs_ERR0( bbs_ERR_WRONG_VERSION, "uint32 bbs_memReadVersion32( .... ):\n"
250 			       "Data format is newer than software or corrupt\n" );
251 	}
252 	return bbs_SIZEOF16( uint32 );
253 }
254 
255 /* ------------------------------------------------------------------------- */
256 
bbs_memCheckSum16(const uint16 * memPtrA,uint32 sizeA)257 uint16 bbs_memCheckSum16( const uint16* memPtrA, uint32 sizeA )
258 {
259 	uint32 iL;
260 	uint16 sumL = 0;
261 	for( iL = 0; iL < sizeA; iL++ )
262 	{
263 		#ifdef HW_BIG_ENDIAN
264 			sumL += bbs_swapBytes( memPtrA[ iL ] );
265 		#else
266 			sumL += memPtrA[ iL ];
267 		#endif
268 	}
269 
270 	return sumL;
271 }
272 
273 /* ------------------------------------------------------------------------- */
274 
275