cpu_endian.c

00001 /**
00002  * @file cpu_endian.c
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 //Dependencies
00028 #include "cpu_endian.h"
00029 
00030 
00031 /**
00032  * @brief Reverse the byte order of a 16-bit word
00033  * @param[in] value 16-bit value
00034  * @return 16-bit value with byte order swapped
00035  **/
00036 
00037 uint16_t swapInt16(uint16_t value)
00038 {
00039    return SWAPINT16(value);
00040 }
00041 
00042 
00043 /**
00044  * @brief Reverse the byte order of a 32-bit word
00045  * @param[in] value 32-bit value
00046  * @return 32-bit value with byte order swapped
00047  **/
00048 
00049 uint32_t swapInt32(uint32_t value)
00050 {
00051    return SWAPINT32(value);
00052 }
00053 
00054 
00055 /**
00056  * @brief Reverse the byte order of a 64-bit word
00057  * @param[in] value 64-bit value
00058  * @return 64-bit value with byte order swapped
00059  **/
00060 
00061 uint64_t swapInt64(uint64_t value)
00062 {
00063    return SWAPINT64(value);
00064 }
00065 
00066 
00067 /**
00068  * @brief Reverse bit order in a 4-bit word
00069  * @param[in] value 4-bit value
00070  * @return 4-bit value with bit order reversed
00071  **/
00072 
00073 uint8_t reverseInt4(uint8_t value)
00074 {
00075    value = ((value & 0x0C) >> 2) | ((value & 0x03) << 2);
00076    value = ((value & 0x0A) >> 1) | ((value & 0x05) << 1);
00077 
00078    return value;
00079 }
00080 
00081 
00082 /**
00083  * @brief Reverse bit order in a byte
00084  * @param[in] value 8-bit value
00085  * @return 8-bit value with bit order reversed
00086  **/
00087 
00088 uint8_t reverseInt8(uint8_t value)
00089 {
00090    value = ((value & 0xF0) >> 4) | ((value & 0x0F) << 4);
00091    value = ((value & 0xCC) >> 2) | ((value & 0x33) << 2);
00092    value = ((value & 0xAA) >> 1) | ((value & 0x55) << 1);
00093 
00094    return value;
00095 }
00096 
00097 
00098 /**
00099  * @brief Reverse bit order in a 16-bit word
00100  * @param[in] value 16-bit value
00101  * @return 16-bit value with bit order reversed
00102  **/
00103 
00104 uint16_t reverseInt16(uint16_t value)
00105 {
00106    value = ((value & 0xFF00) >> 8) | ((value & 0x00FF) << 8);
00107    value = ((value & 0xF0F0) >> 4) | ((value & 0x0F0F) << 4);
00108    value = ((value & 0xCCCC) >> 2) | ((value & 0x3333) << 2);
00109    value = ((value & 0xAAAA) >> 1) | ((value & 0x5555) << 1);
00110 
00111    return value;
00112 }
00113 
00114 
00115 /**
00116  * @brief Reverse bit order in a 32-bit word
00117  * @param[in] value 32-bit value
00118  * @return 32-bit value with bit order reversed
00119  **/
00120 
00121 uint32_t reverseInt32(uint32_t value)
00122 {
00123    value = ((value & 0xFFFF0000UL) >> 16) | ((value & 0x0000FFFFUL) << 16);
00124    value = ((value & 0xFF00FF00UL) >> 8) | ((value & 0x00FF00FFUL) << 8);
00125    value = ((value & 0xF0F0F0F0UL) >> 4) | ((value & 0x0F0F0F0FUL) << 4);
00126    value = ((value & 0xCCCCCCCCUL) >> 2) | ((value & 0x33333333UL) << 2);
00127    value = ((value & 0xAAAAAAAAUL) >> 1) | ((value & 0x55555555UL) << 1);
00128 
00129    return value;
00130 }
00131 
00132 
00133 /**
00134  * @brief Reverse bit order in a 64-bit word
00135  * @param[in] value 64-bit value
00136  * @return 64-bit value with bit order reversed
00137  **/
00138 
00139 uint64_t reverseInt64(uint64_t value)
00140 {
00141    value = ((value & 0xFFFFFFFF00000000ULL) >> 32) | ((value & 0x00000000FFFFFFFFULL) << 32);
00142    value = ((value & 0xFFFF0000FFFF0000ULL) >> 16) | ((value & 0x0000FFFF0000FFFFULL) << 16);
00143    value = ((value & 0xFF00FF00FF00FF00ULL) >> 8) | ((value & 0x00FF00FF00FF00FFULL) << 8);
00144    value = ((value & 0xF0F0F0F0F0F0F0F0ULL) >> 4) | ((value & 0x0F0F0F0F0F0F0F0FULL) << 4);
00145    value = ((value & 0xCCCCCCCCCCCCCCCCULL) >> 2) | ((value & 0x3333333333333333ULL) << 2);
00146    value = ((value & 0xAAAAAAAAAAAAAAAAULL) >> 1) | ((value & 0x5555555555555555ULL) << 1);
00147 
00148    return value;
00149 }
00150