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 40 uint16 bbs_swapBytes( uint16 valA ) 41 { 42 return ( ( valA >> 8 ) & 0x00FF ) | ( ( valA << 8 ) & 0xFF00 ); 43 } 44 45 /* ------------------------------------------------------------------------- */ 46 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 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 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 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 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 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 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 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 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 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 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 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 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
