852ba10081
This adds some support for ARM as well as 64-bit. 64-bit on PowerPC is currently not working, and ARM support has not been completed or tested on the FreeBSD side. As this was imported from a Linux tree, it includes some Linux-isms (ioread/iowrite), so compile with the LinuxKPI for now. This may change in the future.
448 lines
17 KiB
C
448 lines
17 KiB
C
/*
|
|
* Copyright 2008-2012 Freescale Semiconductor Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Freescale Semiconductor nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
*
|
|
* ALTERNATIVELY, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") as published by the Free Software
|
|
* Foundation, either version 2 of that License or (at your option) any
|
|
* later version.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
/**************************************************************************//**
|
|
|
|
@File endian_ext.h
|
|
|
|
@Description Big/little endian swapping routines.
|
|
*//***************************************************************************/
|
|
|
|
#ifndef __ENDIAN_EXT_H
|
|
#define __ENDIAN_EXT_H
|
|
|
|
#include "std_ext.h"
|
|
|
|
|
|
/**************************************************************************//**
|
|
@Group gen_id General Drivers Utilities
|
|
|
|
@Description General usage API. This API is intended for usage by both the
|
|
internal modules and the user's application.
|
|
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Group endian_id Big/Little-Endian Conversion
|
|
|
|
@Description Routines and macros for Big/Little-Endian conversion and
|
|
general byte swapping.
|
|
|
|
All routines and macros are expecting unsigned values as
|
|
parameters, but will generate the correct result also for
|
|
signed values. Therefore, signed/unsigned casting is allowed.
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Collection Byte-Swap Macros
|
|
|
|
Macros for swapping byte order.
|
|
|
|
@Cautions The parameters of these macros are evaluated multiple times.
|
|
For calculated expressions or expressions that contain function
|
|
calls it is recommended to use the byte-swap routines.
|
|
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Description Swaps the byte order of a given 16-bit value.
|
|
|
|
@Param[in] val - The 16-bit value to swap.
|
|
|
|
@Return The byte-swapped value..
|
|
|
|
@Cautions The given value is evaluated multiple times by this macro.
|
|
For calculated expressions or expressions that contain function
|
|
calls it is recommended to use the SwapUint16() routine.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define SWAP_UINT16(val) \
|
|
((uint16_t)((((val) & 0x00FF) << 8) | (((val) & 0xFF00) >> 8)))
|
|
|
|
/**************************************************************************//**
|
|
@Description Swaps the byte order of a given 32-bit value.
|
|
|
|
@Param[in] val - The 32-bit value to swap.
|
|
|
|
@Return The byte-swapped value..
|
|
|
|
@Cautions The given value is evaluated multiple times by this macro.
|
|
For calculated expressions or expressions that contain function
|
|
calls it is recommended to use the SwapUint32() routine.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define SWAP_UINT32(val) \
|
|
((uint32_t)((((val) & 0x000000FF) << 24) | \
|
|
(((val) & 0x0000FF00) << 8) | \
|
|
(((val) & 0x00FF0000) >> 8) | \
|
|
(((val) & 0xFF000000) >> 24)))
|
|
|
|
/**************************************************************************//**
|
|
@Description Swaps the byte order of a given 64-bit value.
|
|
|
|
@Param[in] val - The 64-bit value to swap.
|
|
|
|
@Return The byte-swapped value..
|
|
|
|
@Cautions The given value is evaluated multiple times by this macro.
|
|
For calculated expressions or expressions that contain function
|
|
calls it is recommended to use the SwapUint64() routine.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define SWAP_UINT64(val) \
|
|
((uint64_t)((((val) & 0x00000000000000FFULL) << 56) | \
|
|
(((val) & 0x000000000000FF00ULL) << 40) | \
|
|
(((val) & 0x0000000000FF0000ULL) << 24) | \
|
|
(((val) & 0x00000000FF000000ULL) << 8) | \
|
|
(((val) & 0x000000FF00000000ULL) >> 8) | \
|
|
(((val) & 0x0000FF0000000000ULL) >> 24) | \
|
|
(((val) & 0x00FF000000000000ULL) >> 40) | \
|
|
(((val) & 0xFF00000000000000ULL) >> 56)))
|
|
|
|
/* @} */
|
|
|
|
/**************************************************************************//**
|
|
@Collection Byte-Swap Routines
|
|
|
|
Routines for swapping the byte order of a given parameter and
|
|
returning the swapped value.
|
|
|
|
These inline routines are safer than the byte-swap macros,
|
|
because they evaluate the parameter expression only once.
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Function SwapUint16
|
|
|
|
@Description Returns the byte-swapped value of a given 16-bit value.
|
|
|
|
@Param[in] val - The 16-bit value.
|
|
|
|
@Return The byte-swapped value of the parameter.
|
|
*//***************************************************************************/
|
|
static __inline__ uint16_t SwapUint16(uint16_t val)
|
|
{
|
|
return (uint16_t)(((val & 0x00FF) << 8) |
|
|
((val & 0xFF00) >> 8));
|
|
}
|
|
|
|
/**************************************************************************//**
|
|
@Function SwapUint32
|
|
|
|
@Description Returns the byte-swapped value of a given 32-bit value.
|
|
|
|
@Param[in] val - The 32-bit value.
|
|
|
|
@Return The byte-swapped value of the parameter.
|
|
*//***************************************************************************/
|
|
static __inline__ uint32_t SwapUint32(uint32_t val)
|
|
{
|
|
return (uint32_t)(((val & 0x000000FF) << 24) |
|
|
((val & 0x0000FF00) << 8) |
|
|
((val & 0x00FF0000) >> 8) |
|
|
((val & 0xFF000000) >> 24));
|
|
}
|
|
|
|
/**************************************************************************//**
|
|
@Function SwapUint64
|
|
|
|
@Description Returns the byte-swapped value of a given 64-bit value.
|
|
|
|
@Param[in] val - The 64-bit value.
|
|
|
|
@Return The byte-swapped value of the parameter.
|
|
*//***************************************************************************/
|
|
static __inline__ uint64_t SwapUint64(uint64_t val)
|
|
{
|
|
return (uint64_t)(((val & 0x00000000000000FFULL) << 56) |
|
|
((val & 0x000000000000FF00ULL) << 40) |
|
|
((val & 0x0000000000FF0000ULL) << 24) |
|
|
((val & 0x00000000FF000000ULL) << 8) |
|
|
((val & 0x000000FF00000000ULL) >> 8) |
|
|
((val & 0x0000FF0000000000ULL) >> 24) |
|
|
((val & 0x00FF000000000000ULL) >> 40) |
|
|
((val & 0xFF00000000000000ULL) >> 56));
|
|
}
|
|
|
|
/* @} */
|
|
|
|
/**************************************************************************//**
|
|
@Collection In-place Byte-Swap-And-Set Routines
|
|
|
|
Routines for swapping the byte order of a given variable and
|
|
setting the swapped value back to the same variable.
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Function SwapUint16P
|
|
|
|
@Description Swaps the byte order of a given 16-bit variable.
|
|
|
|
@Param[in] p_Val - Pointer to the 16-bit variable.
|
|
|
|
@Return None.
|
|
*//***************************************************************************/
|
|
static __inline__ void SwapUint16P(uint16_t *p_Val)
|
|
{
|
|
*p_Val = SwapUint16(*p_Val);
|
|
}
|
|
|
|
/**************************************************************************//**
|
|
@Function SwapUint32P
|
|
|
|
@Description Swaps the byte order of a given 32-bit variable.
|
|
|
|
@Param[in] p_Val - Pointer to the 32-bit variable.
|
|
|
|
@Return None.
|
|
*//***************************************************************************/
|
|
static __inline__ void SwapUint32P(uint32_t *p_Val)
|
|
{
|
|
*p_Val = SwapUint32(*p_Val);
|
|
}
|
|
|
|
/**************************************************************************//**
|
|
@Function SwapUint64P
|
|
|
|
@Description Swaps the byte order of a given 64-bit variable.
|
|
|
|
@Param[in] p_Val - Pointer to the 64-bit variable.
|
|
|
|
@Return None.
|
|
*//***************************************************************************/
|
|
static __inline__ void SwapUint64P(uint64_t *p_Val)
|
|
{
|
|
*p_Val = SwapUint64(*p_Val);
|
|
}
|
|
|
|
/* @} */
|
|
|
|
|
|
/**************************************************************************//**
|
|
@Collection Little-Endian Conversion Macros
|
|
|
|
These macros convert given parameters to or from Little-Endian
|
|
format. Use these macros when you want to read or write a specific
|
|
Little-Endian value in memory, without a-priori knowing the CPU
|
|
byte order.
|
|
|
|
These macros use the byte-swap routines. For conversion of
|
|
constants in initialization structures, you may use the CONST
|
|
versions of these macros (see below), which are using the
|
|
byte-swap macros instead.
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 16-bit value from CPU byte order to
|
|
Little-Endian byte order.
|
|
|
|
@Param[in] val - The 16-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CPU_TO_LE16(val) SwapUint16(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 32-bit value from CPU byte order to
|
|
Little-Endian byte order.
|
|
|
|
@Param[in] val - The 32-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CPU_TO_LE32(val) SwapUint32(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 64-bit value from CPU byte order to
|
|
Little-Endian byte order.
|
|
|
|
@Param[in] val - The 64-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CPU_TO_LE64(val) SwapUint64(val)
|
|
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 16-bit value from Little-Endian byte order to
|
|
CPU byte order.
|
|
|
|
@Param[in] val - The 16-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define LE16_TO_CPU(val) CPU_TO_LE16(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 32-bit value from Little-Endian byte order to
|
|
CPU byte order.
|
|
|
|
@Param[in] val - The 32-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define LE32_TO_CPU(val) CPU_TO_LE32(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 64-bit value from Little-Endian byte order to
|
|
CPU byte order.
|
|
|
|
@Param[in] val - The 64-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define LE64_TO_CPU(val) CPU_TO_LE64(val)
|
|
|
|
/* @} */
|
|
|
|
/**************************************************************************//**
|
|
@Collection Little-Endian Constant Conversion Macros
|
|
|
|
These macros convert given constants to or from Little-Endian
|
|
format. Use these macros when you want to read or write a specific
|
|
Little-Endian constant in memory, without a-priori knowing the
|
|
CPU byte order.
|
|
|
|
These macros use the byte-swap macros, therefore can be used for
|
|
conversion of constants in initialization structures.
|
|
|
|
@Cautions The parameters of these macros are evaluated multiple times.
|
|
For non-constant expressions, use the non-CONST macro versions.
|
|
|
|
@{
|
|
*//***************************************************************************/
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 16-bit constant from CPU byte order to
|
|
Little-Endian byte order.
|
|
|
|
@Param[in] val - The 16-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CONST_CPU_TO_LE16(val) SWAP_UINT16(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 32-bit constant from CPU byte order to
|
|
Little-Endian byte order.
|
|
|
|
@Param[in] val - The 32-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CONST_CPU_TO_LE32(val) SWAP_UINT32(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 64-bit constant from CPU byte order to
|
|
Little-Endian byte order.
|
|
|
|
@Param[in] val - The 64-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CONST_CPU_TO_LE64(val) SWAP_UINT64(val)
|
|
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 16-bit constant from Little-Endian byte order
|
|
to CPU byte order.
|
|
|
|
@Param[in] val - The 16-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CONST_LE16_TO_CPU(val) CONST_CPU_TO_LE16(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 32-bit constant from Little-Endian byte order
|
|
to CPU byte order.
|
|
|
|
@Param[in] val - The 32-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CONST_LE32_TO_CPU(val) CONST_CPU_TO_LE32(val)
|
|
|
|
/**************************************************************************//**
|
|
@Description Converts a given 64-bit constant from Little-Endian byte order
|
|
to CPU byte order.
|
|
|
|
@Param[in] val - The 64-bit value to convert.
|
|
|
|
@Return The converted value.
|
|
|
|
@hideinitializer
|
|
*//***************************************************************************/
|
|
#define CONST_LE64_TO_CPU(val) CONST_CPU_TO_LE64(val)
|
|
|
|
/* @} */
|
|
|
|
|
|
/** @} */ /* end of endian_id group */
|
|
/** @} */ /* end of gen_id group */
|
|
|
|
|
|
#endif /* __ENDIAN_EXT_H */
|
|
|