release/src-rt/include/bcmendian.h

   1 /*
   2  * Byte order utilities
   3  *
   4  * Copyright (C) 2010, Broadcom Corporation. All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  13  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  15  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  16  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  *
  18  *  $Id: bcmendian.h,v 1.36 2009-11-09 05:29:43 Exp $
  19  *
  20  * This file by default provides proper behavior on little-endian architectures.
  21  * On big-endian architectures, IL_BIGENDIAN should be defined.
  22  */
  23
  24 #ifndef _BCMENDIAN_H_
  25 #define _BCMENDIAN_H_
  26
  27 #include <typedefs.h>
  28
  29 /* Reverse the bytes in a 16-bit value */
  30 #define BCMSWAP16(val) \
  31         ((uint16)((((uint16)(val) & (uint16)0x00ffU) << 8) | \
  32                   (((uint16)(val) & (uint16)0xff00U) >> 8)))
  33
  34 /* Reverse the bytes in a 32-bit value */
  35 #define BCMSWAP32(val) \
  36         ((uint32)((((uint32)(val) & (uint32)0x000000ffU) << 24) | \
  37                   (((uint32)(val) & (uint32)0x0000ff00U) <<  8) | \
  38                   (((uint32)(val) & (uint32)0x00ff0000U) >>  8) | \
  39                   (((uint32)(val) & (uint32)0xff000000U) >> 24)))
  40
  41 /* Reverse the two 16-bit halves of a 32-bit value */
  42 #define BCMSWAP32BY16(val) \
  43         ((uint32)((((uint32)(val) & (uint32)0x0000ffffU) << 16) | \
  44                   (((uint32)(val) & (uint32)0xffff0000U) >> 16)))
  45
  46 /* Byte swapping macros
  47  *    Host <=> Network (Big Endian) for 16- and 32-bit values
  48  *    Host <=> Little-Endian for 16- and 32-bit values
  49  */
  50 #ifndef hton16
  51 #ifndef IL_BIGENDIAN
  52 #define HTON16(i) BCMSWAP16(i)
  53 #define hton16(i) bcmswap16(i)
  54 #define HTON32(i) BCMSWAP32(i)
  55 #define hton32(i) bcmswap32(i)
  56 #define NTOH16(i) BCMSWAP16(i)
  57 #define ntoh16(i) bcmswap16(i)
  58 #define NTOH32(i) BCMSWAP32(i)
  59 #define ntoh32(i) bcmswap32(i)
  60 #define LTOH16(i) (i)
  61 #define ltoh16(i) (i)
  62 #define LTOH32(i) (i)
  63 #define ltoh32(i) (i)
  64 #define HTOL16(i) (i)
  65 #define htol16(i) (i)
  66 #define HTOL32(i) (i)
  67 #define htol32(i) (i)
  68 #else /* IL_BIGENDIAN */
  69 #define HTON16(i) (i)
  70 #define hton16(i) (i)
  71 #define HTON32(i) (i)
  72 #define hton32(i) (i)
  73 #define NTOH16(i) (i)
  74 #define ntoh16(i) (i)
  75 #define NTOH32(i) (i)
  76 #define ntoh32(i) (i)
  77 #define LTOH16(i) BCMSWAP16(i)
  78 #define ltoh16(i) bcmswap16(i)
  79 #define LTOH32(i) BCMSWAP32(i)
  80 #define ltoh32(i) bcmswap32(i)
  81 #define HTOL16(i) BCMSWAP16(i)
  82 #define htol16(i) bcmswap16(i)
  83 #define HTOL32(i) BCMSWAP32(i)
  84 #define htol32(i) bcmswap32(i)
  85 #endif /* IL_BIGENDIAN */
  86 #endif /* hton16 */
  87
  88 #ifndef IL_BIGENDIAN
  89 #define ltoh16_buf(buf, i)
  90 #define htol16_buf(buf, i)
  91 #else
  92 #define ltoh16_buf(buf, i) bcmswap16_buf((uint16 *)(buf), (i))
  93 #define htol16_buf(buf, i) bcmswap16_buf((uint16 *)(buf), (i))
  94 #endif /* IL_BIGENDIAN */
  95
  96 /* Unaligned loads and stores in host byte order */
  97 #ifndef IL_BIGENDIAN
  98 #define load32_ua(a)            ltoh32_ua(a)
  99 #define store32_ua(a, v)        htol32_ua_store(v, a)
 100 #define load16_ua(a)            ltoh16_ua(a)
 101 #define store16_ua(a, v)        htol16_ua_store(v, a)
 102 #else
 103 #define load32_ua(a)            ntoh32_ua(a)
 104 #define store32_ua(a, v)        hton32_ua_store(v, a)
 105 #define load16_ua(a)            ntoh16_ua(a)
 106 #define store16_ua(a, v)        hton16_ua_store(v, a)
 107 #endif /* IL_BIGENDIAN */
 108
 109 #define _LTOH16_UA(cp)  ((cp)[0] | ((cp)[1] << 8))
 110 #define _LTOH32_UA(cp)  ((cp)[0] | ((cp)[1] << 8) | ((cp)[2] << 16) | ((cp)[3] << 24))
 111 #define _NTOH16_UA(cp)  (((cp)[0] << 8) | (cp)[1])
 112 #define _NTOH32_UA(cp)  (((cp)[0] << 24) | ((cp)[1] << 16) | ((cp)[2] << 8) | (cp)[3])
 113
 114 #define ltoh_ua(ptr) \
 115         (sizeof(*(ptr)) == sizeof(uint8) ? *(const uint8 *)(ptr) : \
 116          sizeof(*(ptr)) == sizeof(uint16) ? _LTOH16_UA((const uint8 *)(ptr)) : \
 117          sizeof(*(ptr)) == sizeof(uint32) ? _LTOH32_UA((const uint8 *)(ptr)) : \
 118          *(uint8 *)0)
 119
 120 #define ntoh_ua(ptr) \
 121         (sizeof(*(ptr)) == sizeof(uint8) ? *(const uint8 *)(ptr) : \
 122          sizeof(*(ptr)) == sizeof(uint16) ? _NTOH16_UA((const uint8 *)(ptr)) : \
 123          sizeof(*(ptr)) == sizeof(uint32) ? _NTOH32_UA((const uint8 *)(ptr)) : \
 124          *(uint8 *)0)
 125
 126 #ifdef __GNUC__
 127
 128 /* GNU macro versions avoid referencing the argument multiple times, while also
 129  * avoiding the -fno-inline used in ROM builds.
 130  */
 131
 132 #define bcmswap16(val) ({ \
 133         uint16 _val = (val); \
 134         BCMSWAP16(_val); \
 135 })
 136
 137 #define bcmswap32(val) ({ \
 138         uint32 _val = (val); \
 139         BCMSWAP32(_val); \
 140 })
 141
 142 #define bcmswap32by16(val) ({ \
 143         uint32 _val = (val); \
 144         BCMSWAP32BY16(_val); \
 145 })
 146
 147 #define bcmswap16_buf(buf, len) ({ \
 148         uint16 *_buf = (uint16 *)(buf); \
 149         uint _wds = (len) / 2; \
 150         while (_wds--) { \
 151                 *_buf = bcmswap16(*_buf); \
 152                 _buf++; \
 153         } \
 154 })
 155
 156 #define htol16_ua_store(val, bytes) ({ \
 157         uint16 _val = (val); \
 158         uint8 *_bytes = (uint8 *)(bytes); \
 159         _bytes[0] = _val & 0xff; \
 160         _bytes[1] = _val >> 8; \
 161 })
 162
 163 #define htol32_ua_store(val, bytes) ({ \
 164         uint32 _val = (val); \
 165         uint8 *_bytes = (uint8 *)(bytes); \
 166         _bytes[0] = _val & 0xff; \
 167         _bytes[1] = (_val >> 8) & 0xff; \
 168         _bytes[2] = (_val >> 16) & 0xff; \
 169         _bytes[3] = _val >> 24; \
 170 })
 171
 172 #define hton16_ua_store(val, bytes) ({ \
 173         uint16 _val = (val); \
 174         uint8 *_bytes = (uint8 *)(bytes); \
 175         _bytes[0] = _val >> 8; \
 176         _bytes[1] = _val & 0xff; \
 177 })
 178
 179 #define hton32_ua_store(val, bytes) ({ \
 180         uint32 _val = (val); \
 181         uint8 *_bytes = (uint8 *)(bytes); \
 182         _bytes[0] = _val >> 24; \
 183         _bytes[1] = (_val >> 16) & 0xff; \
 184         _bytes[2] = (_val >> 8) & 0xff; \
 185         _bytes[3] = _val & 0xff; \
 186 })
 187
 188 #define ltoh16_ua(bytes) ({ \
 189         const uint8 *_bytes = (const uint8 *)(bytes); \
 190         _LTOH16_UA(_bytes); \
 191 })
 192
 193 #define ltoh32_ua(bytes) ({ \
 194         const uint8 *_bytes = (const uint8 *)(bytes); \
 195         _LTOH32_UA(_bytes); \
 196 })
 197
 198 #define ntoh16_ua(bytes) ({ \
 199         const uint8 *_bytes = (const uint8 *)(bytes); \
 200         _NTOH16_UA(_bytes); \
 201 })
 202
 203 #define ntoh32_ua(bytes) ({ \
 204         const uint8 *_bytes = (const uint8 *)(bytes); \
 205         _NTOH32_UA(_bytes); \
 206 })
 207
 208 #else /* !__GNUC__ */
 209
 210 /* Inline versions avoid referencing the argument multiple times */
 211 static INLINE uint16
 212 bcmswap16(uint16 val)
 213 {
 214         return BCMSWAP16(val);
 215 }
 216
 217 static INLINE uint32
 218 bcmswap32(uint32 val)
 219 {
 220         return BCMSWAP32(val);
 221 }
 222
 223 static INLINE uint32
 224 bcmswap32by16(uint32 val)
 225 {
 226         return BCMSWAP32BY16(val);
 227 }
 228
 229 /* Reverse pairs of bytes in a buffer (not for high-performance use) */
 230 /* buf  - start of buffer of shorts to swap */
 231 /* len  - byte length of buffer */
 232 static INLINE void
 233 bcmswap16_buf(uint16 *buf, uint len)
 234 {
 235         len = len / 2;
 236
 237         while (len--) {
 238                 *buf = bcmswap16(*buf);
 239                 buf++;
 240         }
 241 }
 242
 243 /*
 244  * Store 16-bit value to unaligned little-endian byte array.
 245  */
 246 static INLINE void
 247 htol16_ua_store(uint16 val, uint8 *bytes)
 248 {
 249         bytes[0] = val & 0xff;
 250         bytes[1] = val >> 8;
 251 }
 252
 253 /*
 254  * Store 32-bit value to unaligned little-endian byte array.
 255  */
 256 static INLINE void
 257 htol32_ua_store(uint32 val, uint8 *bytes)
 258 {
 259         bytes[0] = val & 0xff;
 260         bytes[1] = (val >> 8) & 0xff;
 261         bytes[2] = (val >> 16) & 0xff;
 262         bytes[3] = val >> 24;
 263 }
 264
 265 /*
 266  * Store 16-bit value to unaligned network-(big-)endian byte array.
 267  */
 268 static INLINE void
 269 hton16_ua_store(uint16 val, uint8 *bytes)
 270 {
 271         bytes[0] = val >> 8;
 272         bytes[1] = val & 0xff;
 273 }
 274
 275 /*
 276  * Store 32-bit value to unaligned network-(big-)endian byte array.
 277  */
 278 static INLINE void
 279 hton32_ua_store(uint32 val, uint8 *bytes)
 280 {
 281         bytes[0] = val >> 24;
 282         bytes[1] = (val >> 16) & 0xff;
 283         bytes[2] = (val >> 8) & 0xff;
 284         bytes[3] = val & 0xff;
 285 }
 286
 287 /*
 288  * Load 16-bit value from unaligned little-endian byte array.
 289  */
 290 static INLINE uint16
 291 ltoh16_ua(const void *bytes)
 292 {
 293         return _LTOH16_UA((const uint8 *)bytes);
 294 }
 295
 296 /*
 297  * Load 32-bit value from unaligned little-endian byte array.
 298  */
 299 static INLINE uint32
 300 ltoh32_ua(const void *bytes)
 301 {
 302         return _LTOH32_UA((const uint8 *)bytes);
 303 }
 304
 305 /*
 306  * Load 16-bit value from unaligned big-(network-)endian byte array.
 307  */
 308 static INLINE uint16
 309 ntoh16_ua(const void *bytes)
 310 {
 311         return _NTOH16_UA((const uint8 *)bytes);
 312 }
 313
 314 /*
 315  * Load 32-bit value from unaligned big-(network-)endian byte array.
 316  */
 317 static INLINE uint32
 318 ntoh32_ua(const void *bytes)
 319 {
 320         return _NTOH32_UA((const uint8 *)bytes);
 321 }
 322
 323 #endif /* !__GNUC__ */
 324 #endif /* !_BCMENDIAN_H_ */