cpu_endian.h

00001 /**
00002  * @file cpu_endian.h
00003  * @brief Byte order conversion
00004  *
00005  * @section License
00006  *
00007  * Copyright (C) 2010-2017 Oryx Embedded SARL. All rights reserved.
00008  *
00009  * This program is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU General Public License
00011  * as published by the Free Software Foundation; either version 2
00012  * of the License, or (at your option) any later version.
00013  *
00014  * This program is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  * GNU General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU General Public License
00020  * along with this program; if not, write to the Free Software Foundation,
00021  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00022  *
00023  * @author Oryx Embedded SARL (www.oryx-embedded.com)
00024  * @version 1.7.6
00025  **/
00026 
00027 #ifndef _CPU_ENDIAN_H
00028 #define _CPU_ENDIAN_H
00029 
00030 //Dependencies
00031 #include "os_port.h"
00032 
00033 //Undefine conflicting definitions
00034 #ifdef HTONS
00035    #undef HTONS
00036 #endif
00037 
00038 #ifdef HTONL
00039    #undef HTONL
00040 #endif
00041 
00042 #ifdef htons
00043    #undef htons
00044 #endif
00045 
00046 #ifdef htonl
00047    #undef htonl
00048 #endif
00049 
00050 #ifdef NTOHS
00051    #undef NTOHS
00052 #endif
00053 
00054 #ifdef NTOHL
00055    #undef NTOHL
00056 #endif
00057 
00058 #ifdef ntohs
00059    #undef ntohs
00060 #endif
00061 
00062 #ifdef ntohl
00063    #undef ntohl
00064 #endif
00065 
00066 #ifdef HTOLE16
00067    #undef HTOLE16
00068 #endif
00069 
00070 #ifdef HTOLE32
00071    #undef HTOLE32
00072 #endif
00073 
00074 #ifdef HTOLE64
00075    #undef HTOLE64
00076 #endif
00077 
00078 #ifdef htole16
00079    #undef htole16
00080 #endif
00081 
00082 #ifdef htole32
00083    #undef htole32
00084 #endif
00085 
00086 #ifdef htole64
00087    #undef htole64
00088 #endif
00089 
00090 #ifdef LETOH16
00091    #undef LETOH16
00092 #endif
00093 
00094 #ifdef LETOH32
00095    #undef LETOH32
00096 #endif
00097 
00098 #ifdef LETOH64
00099    #undef LETOH64
00100 #endif
00101 
00102 #ifdef letoh16
00103    #undef letoh16
00104 #endif
00105 
00106 #ifdef letoh32
00107    #undef letoh32
00108 #endif
00109 
00110 #ifdef letoh64
00111    #undef letoh64
00112 #endif
00113 
00114 #ifdef HTOBE16
00115    #undef HTOBE16
00116 #endif
00117 
00118 #ifdef HTOBE32
00119    #undef HTOBE32
00120 #endif
00121 
00122 #ifdef HTOBE64
00123    #undef HTOBE64
00124 #endif
00125 
00126 #ifdef htobe16
00127    #undef htobe16
00128 #endif
00129 
00130 #ifdef htobe32
00131    #undef htobe32
00132 #endif
00133 
00134 #ifdef htobe64
00135    #undef htobe64
00136 #endif
00137 
00138 #ifdef BETOH16
00139    #undef BETOH16
00140 #endif
00141 
00142 #ifdef BETOH32
00143    #undef BETOH32
00144 #endif
00145 
00146 #ifdef BETOH64
00147    #undef BETOH64
00148 #endif
00149 
00150 #ifdef betoh16
00151    #undef betoh16
00152 #endif
00153 
00154 #ifdef betoh32
00155    #undef betoh32
00156 #endif
00157 
00158 #ifdef betoh64
00159    #undef betoh64
00160 #endif
00161 
00162 //Load unaligned 16-bit integer (little-endian encoding)
00163 #define LOAD16LE(p) ( \
00164    ((uint16_t)(((uint8_t *)(p))[0]) << 0) | \
00165    ((uint16_t)(((uint8_t *)(p))[1]) << 8))
00166 
00167 //Load unaligned 16-bit integer (big-endian encoding)
00168 #define LOAD16BE(p) ( \
00169    ((uint16_t)(((uint8_t *)(p))[0]) << 8) | \
00170    ((uint16_t)(((uint8_t *)(p))[1]) << 0))
00171 
00172 //Load unaligned 24-bit integer (little-endian encoding)
00173 #define LOAD24LE(p) ( \
00174    ((uint32_t)(((uint8_t *)(p))[0]) << 0)| \
00175    ((uint32_t)(((uint8_t *)(p))[1]) << 8) | \
00176    ((uint32_t)(((uint8_t *)(p))[2]) << 16))
00177 
00178 //Load unaligned 24-bit integer (big-endian encoding)
00179 #define LOAD24BE(p) ( \
00180    ((uint32_t)(((uint8_t *)(p))[0]) << 16) | \
00181    ((uint32_t)(((uint8_t *)(p))[1]) << 8) | \
00182    ((uint32_t)(((uint8_t *)(p))[2]) << 0))
00183 
00184 //Load unaligned 32-bit integer (little-endian encoding)
00185 #define LOAD32LE(p) ( \
00186    ((uint32_t)(((uint8_t *)(p))[0]) << 0) | \
00187    ((uint32_t)(((uint8_t *)(p))[1]) << 8) | \
00188    ((uint32_t)(((uint8_t *)(p))[2]) << 16) | \
00189    ((uint32_t)(((uint8_t *)(p))[3]) << 24))
00190 
00191 //Load unaligned 32-bit integer (big-endian encoding)
00192 #define LOAD32BE(p) ( \
00193    ((uint32_t)(((uint8_t *)(p))[0]) << 24) | \
00194    ((uint32_t)(((uint8_t *)(p))[1]) << 16) | \
00195    ((uint32_t)(((uint8_t *)(p))[2]) << 8) | \
00196    ((uint32_t)(((uint8_t *)(p))[3]) << 0))
00197 
00198 //Load unaligned 64-bit integer (little-endian encoding)
00199 #define LOAD64LE(p) ( \
00200    ((uint64_t)(((uint8_t *)(p))[0]) << 0) | \
00201    ((uint64_t)(((uint8_t *)(p))[1]) << 8) | \
00202    ((uint64_t)(((uint8_t *)(p))[2]) << 16) | \
00203    ((uint64_t)(((uint8_t *)(p))[3]) << 24) | \
00204    ((uint64_t)(((uint8_t *)(p))[4]) << 32) | \
00205    ((uint64_t)(((uint8_t *)(p))[5]) << 40) | \
00206    ((uint64_t)(((uint8_t *)(p))[6]) << 48) | \
00207    ((uint64_t)(((uint8_t *)(p))[7]) << 56))
00208 
00209 //Load unaligned 64-bit integer (big-endian encoding)
00210 #define LOAD64BE(p) ( \
00211    ((uint64_t)(((uint8_t *)(p))[0]) << 56) | \
00212    ((uint64_t)(((uint8_t *)(p))[1]) << 48) | \
00213    ((uint64_t)(((uint8_t *)(p))[2]) << 40) | \
00214    ((uint64_t)(((uint8_t *)(p))[3]) << 32) | \
00215    ((uint64_t)(((uint8_t *)(p))[4]) << 24) | \
00216    ((uint64_t)(((uint8_t *)(p))[5]) << 16) | \
00217    ((uint64_t)(((uint8_t *)(p))[6]) << 8) | \
00218    ((uint64_t)(((uint8_t *)(p))[7]) << 0))
00219 
00220 //Store unaligned 16-bit integer (little-endian encoding)
00221 #define STORE16LE(a, p) \
00222    ((uint8_t *)(p))[0] = ((uint16_t)(a) >> 0) & 0xFF, \
00223    ((uint8_t *)(p))[1] = ((uint16_t)(a) >> 8) & 0xFF
00224 
00225 //Store unaligned 32-bit integer (big-endian encoding)
00226 #define STORE16BE(a, p) \
00227    ((uint8_t *)(p))[0] = ((uint16_t)(a) >> 8) & 0xFF, \
00228    ((uint8_t *)(p))[1] = ((uint16_t)(a) >> 0) & 0xFF
00229 
00230 //Store unaligned 24-bit integer (little-endian encoding)
00231 #define STORE24LE(a, p) \
00232    ((uint8_t *)(p))[0] = ((uint32_t)(a) >> 0) & 0xFF, \
00233    ((uint8_t *)(p))[1] = ((uint32_t)(a) >> 8) & 0xFF, \
00234    ((uint8_t *)(p))[2] = ((uint32_t)(a) >> 16) & 0xFF
00235 
00236 //Store unaligned 24-bit integer (big-endian encoding)
00237 #define STORE24BE(a, p) \
00238    ((uint8_t *)(p))[0] = ((uint32_t)(a) >> 16) & 0xFF, \
00239    ((uint8_t *)(p))[1] = ((uint32_t)(a) >> 8) & 0xFF, \
00240    ((uint8_t *)(p))[2] = ((uint32_t)(a) >> 0) & 0xFF
00241 
00242 //Store unaligned 32-bit integer (little-endian encoding)
00243 #define STORE32LE(a, p) \
00244    ((uint8_t *)(p))[0] = ((uint32_t)(a) >> 0) & 0xFF, \
00245    ((uint8_t *)(p))[1] = ((uint32_t)(a) >> 8) & 0xFF, \
00246    ((uint8_t *)(p))[2] = ((uint32_t)(a) >> 16) & 0xFF, \
00247    ((uint8_t *)(p))[3] = ((uint32_t)(a) >> 24) & 0xFF
00248 
00249 //Store unaligned 32-bit integer (big-endian encoding)
00250 #define STORE32BE(a, p) \
00251    ((uint8_t *)(p))[0] = ((uint32_t)(a) >> 24) & 0xFF, \
00252    ((uint8_t *)(p))[1] = ((uint32_t)(a) >> 16) & 0xFF, \
00253    ((uint8_t *)(p))[2] = ((uint32_t)(a) >> 8) & 0xFF, \
00254    ((uint8_t *)(p))[3] = ((uint32_t)(a) >> 0) & 0xFF
00255 
00256 //Store unaligned 64-bit integer (little-endian encoding)
00257 #define STORE64LE(a, p) \
00258    ((uint8_t *)(p))[0] = ((uint64_t)(a) >> 0) & 0xFF, \
00259    ((uint8_t *)(p))[1] = ((uint64_t)(a) >> 8) & 0xFF, \
00260    ((uint8_t *)(p))[2] = ((uint64_t)(a) >> 16) & 0xFF, \
00261    ((uint8_t *)(p))[3] = ((uint64_t)(a) >> 24) & 0xFF, \
00262    ((uint8_t *)(p))[4] = ((uint64_t)(a) >> 32) & 0xFF, \
00263    ((uint8_t *)(p))[5] = ((uint64_t)(a) >> 40) & 0xFF, \
00264    ((uint8_t *)(p))[6] = ((uint64_t)(a) >> 48) & 0xFF, \
00265    ((uint8_t *)(p))[7] = ((uint64_t)(a) >> 56) & 0xFF
00266 
00267 //Store unaligned 64-bit integer (big-endian encoding)
00268 #define STORE64BE(a, p) \
00269    ((uint8_t *)(p))[0] = ((uint64_t)(a) >> 56) & 0xFF, \
00270    ((uint8_t *)(p))[1] = ((uint64_t)(a) >> 48) & 0xFF, \
00271    ((uint8_t *)(p))[2] = ((uint64_t)(a) >> 40) & 0xFF, \
00272    ((uint8_t *)(p))[3] = ((uint64_t)(a) >> 32) & 0xFF, \
00273    ((uint8_t *)(p))[4] = ((uint64_t)(a) >> 24) & 0xFF, \
00274    ((uint8_t *)(p))[5] = ((uint64_t)(a) >> 16) & 0xFF, \
00275    ((uint8_t *)(p))[6] = ((uint64_t)(a) >> 8) & 0xFF, \
00276    ((uint8_t *)(p))[7] = ((uint64_t)(a) >> 0) & 0xFF
00277 
00278 //Swap a 16-bit integer
00279 #define SWAPINT16(x) ( \
00280    (((x) & 0x00FF) << 8) | \
00281    (((x) & 0xFF00) >> 8))
00282 
00283 //Swap a 32-bit integer
00284 #define SWAPINT32(x) ( \
00285    (((x) & 0x000000FFUL) << 24) | \
00286    (((x) & 0x0000FF00UL) << 8) | \
00287    (((x) & 0x00FF0000UL) >> 8) | \
00288    (((x) & 0xFF000000UL) >> 24))
00289 
00290 //Swap a 64-bit integer
00291 #define SWAPINT64(x) ( \
00292    (((x) & 0x00000000000000FFULL) << 56) | \
00293    (((x) & 0x000000000000FF00ULL) << 40) | \
00294    (((x) & 0x0000000000FF0000ULL) << 24) | \
00295    (((x) & 0x00000000FF000000ULL) << 8) | \
00296    (((x) & 0x000000FF00000000ULL) >> 8) | \
00297    (((x) & 0x0000FF0000000000ULL) >> 24) | \
00298    (((x) & 0x00FF000000000000ULL) >> 40) | \
00299    (((x) & 0xFF00000000000000ULL) >> 56))
00300 
00301 //Big-endian machine?
00302 #ifdef _CPU_BIG_ENDIAN
00303 
00304 //Host byte order to network byte order
00305 #define HTONS(value) (value)
00306 #define HTONL(value) (value)
00307 #define htons(value) ((uint16_t) (value))
00308 #define htonl(value) ((uint32_t) (value))
00309 
00310 //Network byte order to host byte order
00311 #define NTOHS(value) (value)
00312 #define NTOHL(value) (value)
00313 #define ntohs(value) ((uint16_t) (value))
00314 #define ntohl(value) ((uint32_t) (value))
00315 
00316 //Host byte order to little-endian byte order
00317 #define HTOLE16(value) SWAPINT16(value)
00318 #define HTOLE32(value) SWAPINT32(value)
00319 #define HTOLE64(value) SWAPINT64(value)
00320 #define htole16(value) swapInt16((uint16_t) (value))
00321 #define htole32(value) swapInt32((uint32_t) (value))
00322 #define htole64(value) swapInt64((uint64_t) (value))
00323 
00324 //Little-endian byte order to host byte order
00325 #define LETOH16(value) SWAPINT16(value)
00326 #define LETOH32(value) SWAPINT32(value)
00327 #define LETOH64(value) SWAPINT64(value)
00328 #define letoh16(value) swapInt16((uint16_t) (value))
00329 #define letoh32(value) swapInt32((uint32_t) (value))
00330 #define letoh64(value) swapInt64((uint64_t) (value))
00331 
00332 //Host byte order to big-endian byte order
00333 #define HTOBE16(value) (value)
00334 #define HTOBE32(value) (value)
00335 #define HTOBE64(value) (value)
00336 #define htobe16(value) ((uint16_t) (value))
00337 #define htobe32(value) ((uint32_t) (value))
00338 #define htobe64(value) ((uint64_t) (value))
00339 
00340 //Big-endian byte order to host byte order
00341 #define BETOH16(value) (value)
00342 #define BETOH32(value) (value)
00343 #define BETOH64(value) (value)
00344 #define betoh16(value) ((uint16_t) (value))
00345 #define betoh32(value) ((uint32_t) (value))
00346 #define betoh64(value) ((uint64_t) (value))
00347 
00348 //Little-endian machine?
00349 #else
00350 
00351 //Host byte order to network byte order
00352 #define HTONS(value) SWAPINT16(value)
00353 #define HTONL(value) SWAPINT32(value)
00354 #define htons(value) swapInt16((uint16_t) (value))
00355 #define htonl(value) swapInt32((uint32_t) (value))
00356 
00357 //Network byte order to host byte order
00358 #define NTOHS(value) SWAPINT16(value)
00359 #define NTOHL(value) SWAPINT32(value)
00360 #define ntohs(value) swapInt16((uint16_t) (value))
00361 #define ntohl(value) swapInt32((uint32_t) (value))
00362 
00363 //Host byte order to little-endian byte order
00364 #define HTOLE16(value) (value)
00365 #define HTOLE32(value) (value)
00366 #define HTOLE64(value) (value)
00367 #define htole16(value) ((uint16_t) (value))
00368 #define htole32(value) ((uint32_t) (value))
00369 #define htole64(value) ((uint64_t) (value))
00370 
00371 //Little-endian byte order to host byte order
00372 #define LETOH16(value) (value)
00373 #define LETOH32(value) (value)
00374 #define LETOH64(value) (value)
00375 #define letoh16(value) ((uint16_t) (value))
00376 #define letoh32(value) ((uint32_t) (value))
00377 #define letoh64(value) ((uint64_t) (value))
00378 
00379 //Host byte order to big-endian byte order
00380 #define HTOBE16(value) SWAPINT16(value)
00381 #define HTOBE32(value) SWAPINT32(value)
00382 #define HTOBE64(value) SWAPINT64(value)
00383 #define htobe16(value) swapInt16((uint16_t) (value))
00384 #define htobe32(value) swapInt32((uint32_t) (value))
00385 #define htobe64(value) swapInt64((uint64_t) (value))
00386 
00387 //Big-endian byte order to host byte order
00388 #define BETOH16(value) SWAPINT16(value)
00389 #define BETOH32(value) SWAPINT32(value)
00390 #define BETOH64(value) SWAPINT64(value)
00391 #define betoh16(value) swapInt16((uint16_t) (value))
00392 #define betoh32(value) swapInt32((uint32_t) (value))
00393 #define betoh64(value) swapInt64((uint64_t) (value))
00394 
00395 #endif
00396 
00397 //Byte order conversion functions
00398 uint16_t swapInt16(uint16_t value);
00399 uint32_t swapInt32(uint32_t value);
00400 uint64_t swapInt64(uint64_t value);
00401 
00402 //Bit reversal functions
00403 uint8_t reverseInt4(uint8_t value);
00404 uint8_t reverseInt8(uint8_t value);
00405 uint16_t reverseInt16(uint16_t value);
00406 uint32_t reverseInt32(uint32_t value);
00407 uint64_t reverseInt64(uint64_t value);
00408 
00409 #endif
00410