/space/home/slher/rel/Beken/v6_4_5/macsw/modules/common/src/co_utils.h

Go to the documentation of this file.

#ifndef _CO_UTILS_H_
#define _CO_UTILS_H_

/*
 * INCLUDE FILES
 ****************************************************************************************
 */
#include "compiler.h"
#include <limits.h>
#include "co_math.h"

/*
 * MACROS
 ****************************************************************************************
 */
#define CO_STAIDX_TO_AID(sta_idx) ((sta_idx) + 1)

#define CO_GET_INDEX(__element_ptr, __array_ptr) ((__element_ptr) - (__array_ptr))

#define CO_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

#define CHAR_LEN    (CHAR_BIT/8)

#define CPU2HW(ptr) (((uint32_t)(ptr)) * CHAR_LEN)

#define HW2CPU(ptr) ((void *)(((uint32_t)(ptr)) / CHAR_LEN))

#define sizeof_b(a) (sizeof(a) * CHAR_LEN)

#define offsetof_b(a, b)  (offsetof(a, b) * CHAR_LEN)

/*
 * FUNCTION DECLARATIONS
 ****************************************************************************************
 */
__INLINE uint16_t co_read16(void const *ptr16)
{
    return *((uint16_t*)ptr16);
}

__INLINE void co_write16(void const *ptr16, uint32_t value)
{
    *(uint16_t*)ptr16 = value;
}

__INLINE uint32_t co_read32(void const *ptr32)
{
    return *((uint32_t*)ptr32);
}

__INLINE void co_write32(void const *ptr32, uint32_t value)
{
    *(uint32_t*)ptr32 = value;
}

__INLINE void co_copy32(uint32_t *dst, uint32_t *src, uint32_t len)
{
    len = CO_ALIGN4_HI(len)/4;
    while (len--)
    {
        *dst++ = *src++;
    }
}

__INLINE uint8_t co_read8p(uint32_t addr)
{
    #ifdef CFG_RWTL
    int shift = (addr & 0x1) * 8;
    uint16_t *ptr = (uint16_t *)(addr / 2);
    return ((uint8_t)((*ptr >> shift) & 0xFF));
    #else
    return (*(uint8_t *)addr);
    #endif
}

__INLINE void co_write8p(uint32_t addr, uint8_t value)
{
    #ifdef CFG_RWTL
    int shift = (addr & 0x1) * 8;
    uint16_t *ptr = (uint16_t *)(addr / 2);
    *ptr =  (*ptr & ~(0xFF << shift)) | ((value & 0xFF) << shift);
    #else
    *(uint8_t *)addr = value;
    #endif
}


__INLINE uint16_t co_read16p(uint32_t addr)
{
    #ifdef CFG_RWTL
    return ((((uint16_t)co_read8p(addr + 1)) << 8) | co_read8p(addr));
    #else
    struct co_read16_struct
    {
        uint16_t val __PACKED16;
    } *ptr = (struct co_read16_struct*)addr;
    return ptr->val;
    #endif
}

__INLINE void co_write16p(uint32_t addr, uint32_t value)
{
    #ifdef CFG_RWTL
    co_write8p(addr, value & 0xFF);
    co_write8p(addr + 1, ((value >> 8) & 0xFF));
    #else
    struct co_read16_struct
    {
        uint16_t val __PACKED16;
    } *ptr = (struct co_read16_struct*) addr;

    ptr->val = value;
    #endif
}

__INLINE uint32_t co_read24p(uint32_t addr)
{
    return ((((uint32_t)co_read16p(addr + 1)) << 8) | co_read8p(addr));
}

__INLINE void co_write24p(uint32_t addr, uint32_t value)
{
    co_write8p(addr, value & 0xFF);
    co_write16p(addr + 1, ((value >> 8) & 0xFFFF));
}

__INLINE uint32_t co_read32p(uint32_t addr)
{
    #ifdef CFG_RWTL
    return ((((uint32_t)co_read16p(addr + 2)) << 16) | co_read16p(addr));
    #else
    struct co_read32_struct
    {
        uint32_t val __PACKED;
    } *ptr = (struct co_read32_struct*) addr;
    return ptr->val;
    #endif
}

__INLINE void co_write32p(uint32_t addr, uint32_t value)
{
    #ifdef CFG_RWTL
    co_write16p(addr, value & 0xFFFF);
    co_write16p(addr + 2, ((value >> 16) & 0xFFFF));
    #else
    struct co_read32_struct
    {
        uint32_t val __PACKED;
    } *ptr = (struct co_read32_struct*) addr;
    ptr->val = value;
    #endif
}

__INLINE uint64_t co_read64p(uint32_t addr)
{
    #ifdef CFG_RWTL
    return ((((uint64_t)co_read32p(addr + 4)) << 32) | co_read32p(addr));
    #else
    struct co_read64_struct
    {
        uint64_t val __PACKED;
    } *ptr = (struct co_read64_struct*) addr;
    return ptr->val;
    #endif
}

__INLINE bool co_cmp8p(uint32_t pkd, uint8_t const *ptr, uint32_t len)
{
    while (len--)
    {
        if (co_read8p(pkd++) != (*ptr++ & 0xFF))
            return false;
    }
    return true;
}

__INLINE void co_pack8p(uint32_t dst, uint8_t const *src, uint32_t len)
{
    while (len--)
    {
        co_write8p(dst++, *src++);
    }
}

__INLINE void co_unpack8p(uint8_t *dst, uint32_t src, uint32_t len)
{
    while (len--)
    {
        *dst++ = co_read8p(src++);
    }
}

__INLINE void co_copy8p(uint32_t dst, uint32_t src, uint32_t len)
{
    while (len--)
    {
        co_write8p(dst++, co_read8p(src++));
    }
}

__INLINE uint8_t co_val_get(uint8_t const array[], int lsb, int width)
{
    int msb = lsb + width - 1;
    int l_byte_idx = lsb/8;
    int m_byte_idx = msb/8;
    uint8_t val;

    if (m_byte_idx == l_byte_idx)
    {
        uint8_t mask = CO_BIT(width) - 1;
        int shift = lsb % 8;
        val = (array[l_byte_idx] >> shift) & mask;
    }
    else
    {
        uint8_t l_bits_cnt = m_byte_idx * 8 - lsb;
        uint8_t l_mask = CO_BIT(l_bits_cnt) - 1;
        uint8_t m_mask = CO_BIT(width - l_bits_cnt) - 1;
        int l_shift = lsb % 8;
        val = (array[l_byte_idx] >> l_shift) & l_mask;
        val |= (array[m_byte_idx] & m_mask) << l_bits_cnt;
    }
    return (val);
}

__INLINE void co_val_set(uint8_t array[], int lsb, int width, uint8_t val)
{
    int msb = lsb + width - 1;
    int l_byte_idx = lsb/8;
    int m_byte_idx = msb/8;

    if (m_byte_idx == l_byte_idx)
    {
        uint8_t mask = CO_BIT(width) - 1;
        int shift = lsb % 8;
        array[l_byte_idx] &= ~(mask << shift);
        array[l_byte_idx] |= (val & mask) << shift;
    }
    else
    {
        uint8_t l_bits_cnt = m_byte_idx * 8 - lsb;
        uint8_t l_mask = CO_BIT(l_bits_cnt) - 1;
        uint8_t m_mask = CO_BIT(width - l_bits_cnt) - 1;
        int l_shift = lsb % 8;
        array[l_byte_idx] &= ~(l_mask << l_shift);
        array[m_byte_idx] &= ~m_mask;
        array[l_byte_idx] |= (val & l_mask) << l_shift;
        array[m_byte_idx] |= (val >> l_bits_cnt) & m_mask;
    }
}

__INLINE bool co_bit_is_set(uint8_t const array[], int pos)
{
    return ((array[pos / 8] & CO_BIT(pos % 8)) != 0);
}

__INLINE void co_bit_set(uint8_t array[], uint8_t pos)
{
    array[pos / 8] |= CO_BIT(pos % 8);
}

__INLINE void co_bit_clr(uint8_t array[], uint8_t pos)
{
    array[pos / 8] &= ~CO_BIT(pos % 8);
}



#endif // _CO_UTILS_H_

---