bertos/cpu/byteorder.h

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2004 Develer S.r.l. (http://www.develer.com/)
  30  * -->
  31  *
  32  * \brief Functions to convert integers to/from host byte-order.
  33  *
  34  * \author Bernie Innocenti <bernie@codewiz.org>
  35  * \author Stefano Fedrigo <aleph@develer.com>
  36  */
  37
  38 #ifndef MWARE_BYTEORDER_H
  39 #define MWARE_BYTEORDER_H
  40
  41 #include <cfg/compiler.h>
  42 #include <cpu/attr.h>
  43
  44 /**
  45  * Swap upper and lower bytes in a 16-bit value.
  46  */
  47 INLINE uint16_t swab16(uint16_t x)
  48 {
  49         return    ((x & (uint16_t)0x00FFU) << 8)
  50                 | ((x & (uint16_t)0xFF00U) >> 8);
  51 }
  52
  53 /**
  54  * Reverse bytes in a 32-bit value (e.g.: 0x12345678 -> 0x78563412).
  55  */
  56 INLINE uint32_t swab32(uint32_t x)
  57 {
  58         return    ((x & (uint32_t)0x000000FFUL) << 24)
  59                 | ((x & (uint32_t)0x0000FF00UL) <<  8)
  60                 | ((x & (uint32_t)0x00FF0000UL) >>  8)
  61                 | ((x & (uint32_t)0xFF000000UL) >> 24);
  62 }
  63
  64 /**
  65  * Reverse bytes in a 64-bit value.
  66  */
  67 INLINE uint64_t swab64(uint64_t x)
  68 {
  69         return (uint64_t)swab32(x >> 32)
  70                 | ((uint64_t)swab32(x & 0xFFFFFFFFUL) << 32);
  71 }
  72
  73 /**
  74  * Reverse bytes in a float value.
  75  */
  76 INLINE float swab_float(float x)
  77 {
  78         /* Avoid breaking strict aliasing rules.  */
  79         char *cx = (char *)(&x);
  80         STATIC_ASSERT(sizeof(float) == 4);
  81         #define BYTEORDER_SWAP(a, b) ((a) ^= (b) ^= (a) ^= (b))
  82         BYTEORDER_SWAP(cx[0], cx[3]);
  83         BYTEORDER_SWAP(cx[1], cx[2]);
  84         #undef BYTEORDER_SWAP
  85         return x;
  86 }
  87
  88 INLINE uint16_t cpu_to_be16(uint16_t x)
  89 {
  90         return (CPU_BYTE_ORDER == CPU_LITTLE_ENDIAN) ? swab16(x) : x;
  91 }
  92
  93 INLINE uint16_t cpu_to_le16(uint16_t x)
  94 {
  95         return (CPU_BYTE_ORDER == CPU_BIG_ENDIAN) ? swab16(x) : x;
  96 }
  97
  98 INLINE uint32_t cpu_to_be32(uint32_t x)
  99 {
 100         return (CPU_BYTE_ORDER == CPU_LITTLE_ENDIAN) ? swab32(x) : x;
 101 }
 102
 103 INLINE uint32_t cpu_to_le32(uint32_t x)
 104 {
 105         return (CPU_BYTE_ORDER == CPU_BIG_ENDIAN) ? swab32(x) : x;
 106 }
 107
 108 INLINE uint64_t cpu_to_be64(uint64_t x)
 109 {
 110         return (CPU_BYTE_ORDER == CPU_LITTLE_ENDIAN) ? swab64(x) : x;
 111 }
 112
 113 INLINE uint64_t cpu_to_le64(uint64_t x)
 114 {
 115         return (CPU_BYTE_ORDER == CPU_BIG_ENDIAN) ? swab64(x) : x;
 116 }
 117
 118 INLINE float cpu_to_be_float(float x)
 119 {
 120         return (CPU_BYTE_ORDER == CPU_LITTLE_ENDIAN) ? swab_float(x) : x;
 121 }
 122
 123 INLINE float cpu_to_le_float(float x)
 124 {
 125         return (CPU_BYTE_ORDER == CPU_BIG_ENDIAN) ? swab_float(x) : x;
 126 }
 127
 128 INLINE uint16_t be16_to_cpu(uint16_t x)
 129 {
 130         return cpu_to_be16(x);
 131 }
 132
 133 INLINE uint16_t le16_to_cpu(uint16_t x)
 134 {
 135         return cpu_to_le16(x);
 136 }
 137
 138 INLINE uint32_t be32_to_cpu(uint32_t x)
 139 {
 140         return cpu_to_be32(x);
 141 }
 142
 143 INLINE uint32_t le32_to_cpu(uint32_t x)
 144 {
 145         return cpu_to_le32(x);
 146 }
 147
 148 INLINE uint64_t be64_to_cpu(uint64_t x)
 149 {
 150         return cpu_to_be64(x);
 151 }
 152
 153 INLINE uint64_t le64_to_cpu(uint64_t x)
 154 {
 155         return cpu_to_le64(x);
 156 }
 157
 158 INLINE float be_float_to_cpu(float x)
 159 {
 160         return cpu_to_be_float(x);
 161 }
 162
 163 INLINE float le_float_to_cpu(float x)
 164 {
 165         return cpu_to_le_float(x);
 166 }
 167
 168 INLINE uint16_t host_to_net16(uint16_t x)
 169 {
 170         return cpu_to_be16(x);
 171 }
 172
 173 INLINE uint16_t net_to_host16(uint16_t x)
 174 {
 175         return be16_to_cpu(x);
 176 }
 177
 178 INLINE uint32_t host_to_net32(uint32_t x)
 179 {
 180         return cpu_to_be32(x);
 181 }
 182
 183 INLINE uint32_t net_to_host32(uint32_t x)
 184 {
 185         return be32_to_cpu(x);
 186 }
 187
 188 INLINE uint64_t host_to_net64(uint64_t x)
 189 {
 190         return cpu_to_be64(x);
 191 }
 192
 193 INLINE uint64_t net_to_host64(uint64_t x)
 194 {
 195         return be64_to_cpu(x);
 196 }
 197
 198 INLINE float host_to_net_float(float x)
 199 {
 200         return cpu_to_be_float(x);
 201 }
 202
 203 INLINE float net_to_host_float(float x)
 204 {
 205         return be_float_to_cpu(x);
 206 }
 207
 208 #ifdef __cplusplus
 209
 210 /// Type generic byte swapping.
 211 template<typename T>
 212 INLINE T swab(T x);
 213
 214 template<> INLINE uint16_t swab(uint16_t x) { return swab16(x); }
 215 template<> INLINE uint32_t swab(uint32_t x) { return swab32(x); }
 216 template<> INLINE uint64_t swab(uint64_t x) { return swab64(x); }
 217 template<> INLINE int16_t  swab(int16_t x)  { return static_cast<int16_t>(swab16(static_cast<uint16_t>(x))); }
 218 template<> INLINE int32_t  swab(int32_t x)  { return static_cast<int32_t>(swab32(static_cast<uint32_t>(x))); }
 219 template<> INLINE int64_t  swab(int64_t x)  { return static_cast<int64_t>(swab64(static_cast<uint64_t>(x))); }
 220 template<> INLINE float    swab(float x)    { return swab_float(x); }
 221
 222 /// Type generic conversion from CPU byte order to big-endian byte order.
 223 template<typename T>
 224 INLINE T cpu_to_be(T x)
 225 {
 226         return (CPU_BYTE_ORDER == CPU_LITTLE_ENDIAN) ? swab(x) : x;
 227 }
 228
 229 /// Type generic conversion from CPU byte-order to little-endian.
 230 template<typename T>
 231 INLINE T cpu_to_le(T x)
 232 {
 233         return (CPU_BYTE_ORDER == CPU_BIG_ENDIAN) ? swab(x) : x;
 234 }
 235
 236 /// Type generic conversion from big endian byte-order to CPU byte order.
 237 template<typename T>
 238 INLINE T be_to_cpu(T x)
 239 {
 240         return cpu_to_be(x);
 241 }
 242
 243 /// Type generic conversion from little-endian byte order to CPU byte order.
 244 template<typename T>
 245 INLINE T le_to_cpu(T x)
 246 {
 247         return cpu_to_le(x);
 248 }
 249
 250 /// Type generic conversion from network byte order to host byte order.
 251 template<typename T>
 252 INLINE T net_to_host(T x)
 253 {
 254         return be_to_cpu(x);
 255 }
 256
 257 /// Type generic conversion from host byte order to network byte order.
 258 template<typename T>
 259 INLINE T host_to_net(T x)
 260 {
 261         return net_to_host(x);
 262 }
 263
 264 #endif /* __cplusplus */
 265
 266 #endif /* MWARE_BYTEORDER_H */