sys/contrib/ncsw/inc/endian_ext.h

   1 /* Copyright (c) 2008-2011 Freescale Semiconductor, Inc.
   2  * All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *     * Redistributions of source code must retain the above copyright
   7  *       notice, this list of conditions and the following disclaimer.
   8  *     * Redistributions in binary form must reproduce the above copyright
   9  *       notice, this list of conditions and the following disclaimer in the
  10  *       documentation and/or other materials provided with the distribution.
  11  *     * Neither the name of Freescale Semiconductor nor the
  12  *       names of its contributors may be used to endorse or promote products
  13  *       derived from this software without specific prior written permission.
  14  *
  15  *
  16  * ALTERNATIVELY, this software may be distributed under the terms of the
  17  * GNU General Public License ("GPL") as published by the Free Software
  18  * Foundation, either version 2 of that License or (at your option) any
  19  * later version.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  24  * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
  25  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  28  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  30  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 /**************************************************************************//**
  34
  35  @File          endian_ext.h
  36
  37  @Description   Big/little endian swapping routines.
  38 *//***************************************************************************/
  39
  40 #ifndef __ENDIAN_EXT_H
  41 #define __ENDIAN_EXT_H
  42
  43 #include "std_ext.h"
  44
  45
  46 /**************************************************************************//**
  47  @Group         gen_id  General Drivers Utilities
  48
  49  @Description   General usage API. This API is intended for usage by both the
  50                 internal modules and the user's application.
  51
  52  @{
  53 *//***************************************************************************/
  54
  55 /**************************************************************************//**
  56  @Group         endian_id Big/Little-Endian Conversion
  57
  58  @Description   Routines and macros for Big/Little-Endian conversion and
  59                 general byte swapping.
  60
  61                 All routines and macros are expecting unsigned values as
  62                 parameters, but will generate the correct result also for
  63                 signed values. Therefore, signed/unsigned casting is allowed.
  64  @{
  65 *//***************************************************************************/
  66
  67 /**************************************************************************//**
  68  @Collection    Byte-Swap Macros
  69
  70                 Macros for swapping byte order.
  71
  72  @Cautions      The parameters of these macros are evaluated multiple times.
  73                 For calculated expressions or expressions that contain function
  74                 calls it is recommended to use the byte-swap routines.
  75
  76  @{
  77 *//***************************************************************************/
  78
  79 /**************************************************************************//**
  80  @Description   Swaps the byte order of a given 16-bit value.
  81
  82  @Param[in]     val - The 16-bit value to swap.
  83
  84  @Return        The byte-swapped value..
  85
  86  @Cautions      The given value is evaluated multiple times by this macro.
  87                 For calculated expressions or expressions that contain function
  88                 calls it is recommended to use the SwapUint16() routine.
  89
  90  @hideinitializer
  91 *//***************************************************************************/
  92 #define SWAP_UINT16(val) \
  93     ((uint16_t)((((val) & 0x00FF) << 8) | (((val) & 0xFF00) >> 8)))
  94
  95 /**************************************************************************//**
  96  @Description   Swaps the byte order of a given 32-bit value.
  97
  98  @Param[in]     val - The 32-bit value to swap.
  99
 100  @Return        The byte-swapped value..
 101
 102  @Cautions      The given value is evaluated multiple times by this macro.
 103                 For calculated expressions or expressions that contain function
 104                 calls it is recommended to use the SwapUint32() routine.
 105
 106  @hideinitializer
 107 *//***************************************************************************/
 108 #define SWAP_UINT32(val) \
 109     ((uint32_t)((((val) & 0x000000FF) << 24) | \
 110                 (((val) & 0x0000FF00) <<  8) | \
 111                 (((val) & 0x00FF0000) >>  8) | \
 112                 (((val) & 0xFF000000) >> 24)))
 113
 114 /**************************************************************************//**
 115  @Description   Swaps the byte order of a given 64-bit value.
 116
 117  @Param[in]     val - The 64-bit value to swap.
 118
 119  @Return        The byte-swapped value..
 120
 121  @Cautions      The given value is evaluated multiple times by this macro.
 122                 For calculated expressions or expressions that contain function
 123                 calls it is recommended to use the SwapUint64() routine.
 124
 125  @hideinitializer
 126 *//***************************************************************************/
 127 #define SWAP_UINT64(val) \
 128     ((uint64_t)((((val) & 0x00000000000000FFULL) << 56) | \
 129                 (((val) & 0x000000000000FF00ULL) << 40) | \
 130                 (((val) & 0x0000000000FF0000ULL) << 24) | \
 131                 (((val) & 0x00000000FF000000ULL) <<  8) | \
 132                 (((val) & 0x000000FF00000000ULL) >>  8) | \
 133                 (((val) & 0x0000FF0000000000ULL) >> 24) | \
 134                 (((val) & 0x00FF000000000000ULL) >> 40) | \
 135                 (((val) & 0xFF00000000000000ULL) >> 56)))
 136
 137 /* @} */
 138
 139 /**************************************************************************//**
 140  @Collection    Byte-Swap Routines
 141
 142                 Routines for swapping the byte order of a given parameter and
 143                 returning the swapped value.
 144
 145                 These inline routines are safer than the byte-swap macros,
 146                 because they evaluate the parameter expression only once.
 147  @{
 148 *//***************************************************************************/
 149
 150 /**************************************************************************//**
 151  @Function      SwapUint16
 152
 153  @Description   Returns the byte-swapped value of a given 16-bit value.
 154
 155  @Param[in]     val - The 16-bit value.
 156
 157  @Return        The byte-swapped value of the parameter.
 158 *//***************************************************************************/
 159 static __inline__ uint16_t SwapUint16(uint16_t val)
 160 {
 161     return (uint16_t)(((val & 0x00FF) << 8) |
 162                       ((val & 0xFF00) >> 8));
 163 }
 164
 165 /**************************************************************************//**
 166  @Function      SwapUint32
 167
 168  @Description   Returns the byte-swapped value of a given 32-bit value.
 169
 170  @Param[in]     val - The 32-bit value.
 171
 172  @Return        The byte-swapped value of the parameter.
 173 *//***************************************************************************/
 174 static __inline__ uint32_t SwapUint32(uint32_t val)
 175 {
 176     return (uint32_t)(((val & 0x000000FF) << 24) |
 177                       ((val & 0x0000FF00) <<  8) |
 178                       ((val & 0x00FF0000) >>  8) |
 179                       ((val & 0xFF000000) >> 24));
 180 }
 181
 182 /**************************************************************************//**
 183  @Function      SwapUint64
 184
 185  @Description   Returns the byte-swapped value of a given 64-bit value.
 186
 187  @Param[in]     val - The 64-bit value.
 188
 189  @Return        The byte-swapped value of the parameter.
 190 *//***************************************************************************/
 191 static __inline__ uint64_t SwapUint64(uint64_t val)
 192 {
 193     return (uint64_t)(((val & 0x00000000000000FFULL) << 56) |
 194                       ((val & 0x000000000000FF00ULL) << 40) |
 195                       ((val & 0x0000000000FF0000ULL) << 24) |
 196                       ((val & 0x00000000FF000000ULL) <<  8) |
 197                       ((val & 0x000000FF00000000ULL) >>  8) |
 198                       ((val & 0x0000FF0000000000ULL) >> 24) |
 199                       ((val & 0x00FF000000000000ULL) >> 40) |
 200                       ((val & 0xFF00000000000000ULL) >> 56));
 201 }
 202
 203 /* @} */
 204
 205 /**************************************************************************//**
 206  @Collection    In-place Byte-Swap-And-Set Routines
 207
 208                 Routines for swapping the byte order of a given variable and
 209                 setting the swapped value back to the same variable.
 210  @{
 211 *//***************************************************************************/
 212
 213 /**************************************************************************//**
 214  @Function      SwapUint16P
 215
 216  @Description   Swaps the byte order of a given 16-bit variable.
 217
 218  @Param[in]     p_Val - Pointer to the 16-bit variable.
 219
 220  @Return        None.
 221 *//***************************************************************************/
 222 static __inline__ void SwapUint16P(uint16_t *p_Val)
 223 {
 224     *p_Val = SwapUint16(*p_Val);
 225 }
 226
 227 /**************************************************************************//**
 228  @Function      SwapUint32P
 229
 230  @Description   Swaps the byte order of a given 32-bit variable.
 231
 232  @Param[in]     p_Val - Pointer to the 32-bit variable.
 233
 234  @Return        None.
 235 *//***************************************************************************/
 236 static __inline__ void SwapUint32P(uint32_t *p_Val)
 237 {
 238     *p_Val = SwapUint32(*p_Val);
 239 }
 240
 241 /**************************************************************************//**
 242  @Function      SwapUint64P
 243
 244  @Description   Swaps the byte order of a given 64-bit variable.
 245
 246  @Param[in]     p_Val - Pointer to the 64-bit variable.
 247
 248  @Return        None.
 249 *//***************************************************************************/
 250 static __inline__ void SwapUint64P(uint64_t *p_Val)
 251 {
 252     *p_Val = SwapUint64(*p_Val);
 253 }
 254
 255 /* @} */
 256
 257
 258 /**************************************************************************//**
 259  @Collection    Little-Endian Conversion Macros
 260
 261                 These macros convert given parameters to or from Little-Endian
 262                 format. Use these macros when you want to read or write a specific
 263                 Little-Endian value in memory, without a-priori knowing the CPU
 264                 byte order.
 265
 266                 These macros use the byte-swap routines. For conversion of
 267                 constants in initialization structures, you may use the CONST
 268                 versions of these macros (see below), which are using the
 269                 byte-swap macros instead.
 270  @{
 271 *//***************************************************************************/
 272
 273 /**************************************************************************//**
 274  @Description   Converts a given 16-bit value from CPU byte order to
 275                 Little-Endian byte order.
 276
 277  @Param[in]     val - The 16-bit value to convert.
 278
 279  @Return        The converted value.
 280
 281  @hideinitializer
 282 *//***************************************************************************/
 283 #define CPU_TO_LE16(val)        SwapUint16(val)
 284
 285 /**************************************************************************//**
 286  @Description   Converts a given 32-bit value from CPU byte order to
 287                 Little-Endian byte order.
 288
 289  @Param[in]     val - The 32-bit value to convert.
 290
 291  @Return        The converted value.
 292
 293  @hideinitializer
 294 *//***************************************************************************/
 295 #define CPU_TO_LE32(val)        SwapUint32(val)
 296
 297 /**************************************************************************//**
 298  @Description   Converts a given 64-bit value from CPU byte order to
 299                 Little-Endian byte order.
 300
 301  @Param[in]     val - The 64-bit value to convert.
 302
 303  @Return        The converted value.
 304
 305  @hideinitializer
 306 *//***************************************************************************/
 307 #define CPU_TO_LE64(val)        SwapUint64(val)
 308
 309
 310 /**************************************************************************//**
 311  @Description   Converts a given 16-bit value from Little-Endian byte order to
 312                 CPU byte order.
 313
 314  @Param[in]     val - The 16-bit value to convert.
 315
 316  @Return        The converted value.
 317
 318  @hideinitializer
 319 *//***************************************************************************/
 320 #define LE16_TO_CPU(val)        CPU_TO_LE16(val)
 321
 322 /**************************************************************************//**
 323  @Description   Converts a given 32-bit value from Little-Endian byte order to
 324                 CPU byte order.
 325
 326  @Param[in]     val - The 32-bit value to convert.
 327
 328  @Return        The converted value.
 329
 330  @hideinitializer
 331 *//***************************************************************************/
 332 #define LE32_TO_CPU(val)        CPU_TO_LE32(val)
 333
 334 /**************************************************************************//**
 335  @Description   Converts a given 64-bit value from Little-Endian byte order to
 336                 CPU byte order.
 337
 338  @Param[in]     val - The 64-bit value to convert.
 339
 340  @Return        The converted value.
 341
 342  @hideinitializer
 343 *//***************************************************************************/
 344 #define LE64_TO_CPU(val)        CPU_TO_LE64(val)
 345
 346 /* @} */
 347
 348 /**************************************************************************//**
 349  @Collection    Little-Endian Constant Conversion Macros
 350
 351                 These macros convert given constants to or from Little-Endian
 352                 format. Use these macros when you want to read or write a specific
 353                 Little-Endian constant in memory, without a-priori knowing the
 354                 CPU byte order.
 355
 356                 These macros use the byte-swap macros, therefore can be used for
 357                 conversion of constants in initialization structures.
 358
 359  @Cautions      The parameters of these macros are evaluated multiple times.
 360                 For non-constant expressions, use the non-CONST macro versions.
 361
 362  @{
 363 *//***************************************************************************/
 364
 365 /**************************************************************************//**
 366  @Description   Converts a given 16-bit constant from CPU byte order to
 367                 Little-Endian byte order.
 368
 369  @Param[in]     val - The 16-bit value to convert.
 370
 371  @Return        The converted value.
 372
 373  @hideinitializer
 374 *//***************************************************************************/
 375 #define CONST_CPU_TO_LE16(val)  SWAP_UINT16(val)
 376
 377 /**************************************************************************//**
 378  @Description   Converts a given 32-bit constant from CPU byte order to
 379                 Little-Endian byte order.
 380
 381  @Param[in]     val - The 32-bit value to convert.
 382
 383  @Return        The converted value.
 384
 385  @hideinitializer
 386 *//***************************************************************************/
 387 #define CONST_CPU_TO_LE32(val)  SWAP_UINT32(val)
 388
 389 /**************************************************************************//**
 390  @Description   Converts a given 64-bit constant from CPU byte order to
 391                 Little-Endian byte order.
 392
 393  @Param[in]     val - The 64-bit value to convert.
 394
 395  @Return        The converted value.
 396
 397  @hideinitializer
 398 *//***************************************************************************/
 399 #define CONST_CPU_TO_LE64(val)  SWAP_UINT64(val)
 400
 401
 402 /**************************************************************************//**
 403  @Description   Converts a given 16-bit constant from Little-Endian byte order
 404                 to CPU byte order.
 405
 406  @Param[in]     val - The 16-bit value to convert.
 407
 408  @Return        The converted value.
 409
 410  @hideinitializer
 411 *//***************************************************************************/
 412 #define CONST_LE16_TO_CPU(val)  CONST_CPU_TO_LE16(val)
 413
 414 /**************************************************************************//**
 415  @Description   Converts a given 32-bit constant from Little-Endian byte order
 416                 to CPU byte order.
 417
 418  @Param[in]     val - The 32-bit value to convert.
 419
 420  @Return        The converted value.
 421
 422  @hideinitializer
 423 *//***************************************************************************/
 424 #define CONST_LE32_TO_CPU(val)  CONST_CPU_TO_LE32(val)
 425
 426 /**************************************************************************//**
 427  @Description   Converts a given 64-bit constant from Little-Endian byte order
 428                 to CPU byte order.
 429
 430  @Param[in]     val - The 64-bit value to convert.
 431
 432  @Return        The converted value.
 433
 434  @hideinitializer
 435 *//***************************************************************************/
 436 #define CONST_LE64_TO_CPU(val)  CONST_CPU_TO_LE64(val)
 437
 438 /* @} */
 439
 440
 441 /** @} */ /* end of endian_id group */
 442 /** @} */ /* end of gen_id group */
 443
 444
 445 #endif /* __ENDIAN_EXT_H */
 446