/space/home/slher/rel/Beken/v6_4_5/macsw/ip/umac/src/me/me_mic.c

Go to the documentation of this file.

/*
 * INCLUDE FILES
 ****************************************************************************************
 */

#include "me_mic.h"
#include "co_utils.h"
#include "dbg_assert.h"
#if NX_HSU
#include "hsu.h"
#endif

/*
 * DEFINES
 ****************************************************************************************
 */

#define MIC_END_SIGNATURE   (0x0000005A)

#define MIC_TID_MASK        (0x00000007)

// If NX_HSU == 2, don't include software implementation
#if NX_HSU < 2

/*
 * MACROS
 ****************************************************************************************
 */

#define ROR32(L,Q)  ( ( (uint32_t)(L) >> (Q) ) | ( (uint32_t)(L) << (32-(Q)) ) )

#define ROL32(L,Q)  ( ( (uint32_t)(L) << (Q) ) | ( (uint32_t)(L) >> (32-(Q)) ) )

#define XSWAP32(L)    ( ( ( L & 0xFF00FF00 ) >> 8 ) | \
                        ( ( L & 0x00FF00FF ) << 8 ) )

#define LEN_IN_BITS(X) ( (X) << 3 )

#define SHIFTR(X, S) (((S) == 32)? 0 : ((X) >> (S)) )

/*
 * PRIVATE FUNCTION IMPLEMENTATIONS
 ****************************************************************************************
 */

static void michael_block(struct mic_calc *mic_calc_ptr, uint32_t block)
{
    uint32_t l = mic_calc_ptr->mic_key_least;
    uint32_t r = mic_calc_ptr->mic_key_most;

    l   ^= block;
    r   ^=  ROL32(l, 17);
    l   +=  r;
    r   ^=  XSWAP32(l);
    l   +=  r;
    r   ^=  ROL32(l, 3);
    l   +=  r;
    r   ^=  ROR32(l, 2);
    l   +=  r;

    mic_calc_ptr->mic_key_most  = r;
    mic_calc_ptr->mic_key_least = l;
}

static void michael_init(struct mic_calc *mic_calc_ptr, uint32_t *mic_key_ptr,
                         uint32_t *aad)
{
    // Initialize MIC value
    mic_calc_ptr->mic_key_least = mic_key_ptr[0];
    mic_calc_ptr->mic_key_most  = mic_key_ptr[1];
    mic_calc_ptr->last_m_i      = 0;
    mic_calc_ptr->last_m_i_len  = 0;

    // Apply Michael on AAD
    michael_block(mic_calc_ptr, aad[0]);
    michael_block(mic_calc_ptr, aad[1]);
    michael_block(mic_calc_ptr, aad[2]);
    michael_block(mic_calc_ptr, aad[3]);
}

static void michael_calc(struct mic_calc *mic_calc_ptr, uint32_t start_ptr,
                         uint32_t data_len)
{
    // M(i) block
    uint32_t m_i;
    // Remaining length to proceed
    uint32_t rem_len = data_len;
    // Number of 32-bit blocks
    uint32_t nb_blocks;
    // Pointer to the payload
    uint32_t *u32_ptr = HW2CPU(start_ptr & ~0x03);
    uint32_t val = *u32_ptr++;
    uint8_t cut = start_ptr & 0x03;
    uint8_t valid = 4 - cut;
    uint32_t last_m_i_len = mic_calc_ptr->last_m_i_len;
    uint32_t last_m_i = mic_calc_ptr->last_m_i;

    val >>= LEN_IN_BITS(cut);
    if (data_len < valid)
    {
        val &= 0xFFFFFFFF >> LEN_IN_BITS(4 - data_len);
        valid = data_len;
        rem_len = 0;
    }
    else
    {
        rem_len -= valid;
    }

    if ((last_m_i_len + valid) < 4)
    {
        last_m_i |= val << LEN_IN_BITS(last_m_i_len);
        last_m_i_len += valid;
    }
    else
    {
        m_i = last_m_i | (val << LEN_IN_BITS(last_m_i_len));

        last_m_i = SHIFTR(val, LEN_IN_BITS(4 - last_m_i_len));
        last_m_i_len += valid - 4;

        // Apply Michael block function
        michael_block(mic_calc_ptr, m_i);
    }

    // Compute the number of remaining blocks
    nb_blocks = (rem_len >> 2);

    for (uint32_t block_cnt = 0; block_cnt < nb_blocks; block_cnt++)
    {
        // Read memory
        val = *u32_ptr++;

        // Extract the block value
        m_i = last_m_i | (val << LEN_IN_BITS(last_m_i_len));

        // Save last MI
        last_m_i = SHIFTR(val, LEN_IN_BITS(4 - last_m_i_len));

        // Apply Michael block function
        michael_block(mic_calc_ptr, m_i);
    }

    // If pending bytes store them inside the mic_calc structure
    if (rem_len > (nb_blocks << 2))
    {
        uint32_t add_bytes = rem_len - (nb_blocks << 2);

        val = (*u32_ptr) & (SHIFTR(0xFFFFFFFF, LEN_IN_BITS(4 - add_bytes)));
        if ((last_m_i_len + add_bytes) > 3)
        {
            // Extract the block value
            m_i = last_m_i | (val << LEN_IN_BITS(last_m_i_len));

            // Save last MI
            last_m_i = SHIFTR(val, LEN_IN_BITS(4 - last_m_i_len));
            last_m_i_len += add_bytes - 4;

            // Apply Michael block function
            michael_block(mic_calc_ptr, m_i);
        }
        else
        {
            last_m_i |= val << LEN_IN_BITS(last_m_i_len);
            last_m_i_len += add_bytes;
        }
    }

    mic_calc_ptr->last_m_i     = last_m_i;
    mic_calc_ptr->last_m_i_len = last_m_i_len;
}

static void michael_end(struct mic_calc *mic_calc_ptr)
{
    // M(n-2) block
    uint32_t m_n_2 = mic_calc_ptr->last_m_i;

    ASSERT_ERR(mic_calc_ptr->last_m_i_len < 4);

    m_n_2 |= (MIC_END_SIGNATURE << LEN_IN_BITS(mic_calc_ptr->last_m_i_len));

    // Apply Michael block function to the last 2 blocks
    michael_block(mic_calc_ptr, m_n_2);
    // M(n-1) = 0 by construction
    michael_block(mic_calc_ptr, 0);
}
#endif /* NX_HSU < 2 */

/*
 * PUBLIC FUNCTION IMPLEMENTATIONS
 ******************************************************************************
 */

#if NX_HSU
uint32_t mic_aad[4] __SHAREDRAM;
#endif

void me_mic_init(struct mic_calc *mic_calc_ptr, uint32_t *mic_key_ptr,
                 struct mac_addr *da, struct mac_addr *sa, uint8_t tid)
{
    #if !NX_HSU
    uint32_t mic_aad[4];
    #endif

    /* prepare AAD vector = DA SA Prio Padding */
    mic_aad[0] = (uint32_t)da->array[0] | (((uint32_t)da->array[1]) << 16);
    mic_aad[1] = (uint32_t)da->array[2] | (((uint32_t)sa->array[0]) << 16);
    mic_aad[2] = (uint32_t)sa->array[1] | (((uint32_t)sa->array[2]) << 16);
    if (tid == 0xFF)
        mic_aad[3] = 0;
    else
        mic_aad[3] = (uint32_t)tid & MIC_TID_MASK;

    #if NX_HSU
    if (hsu_michael_init(mic_calc_ptr, mic_key_ptr, mic_aad))
        return;
    #endif

    #if NX_HSU < 2
    michael_init(mic_calc_ptr, mic_key_ptr, mic_aad);
    #endif
}

void me_mic_calc(struct mic_calc *mic_calc_ptr, uint32_t start_ptr,
                 uint32_t data_len)
{
    #if NX_HSU
    if (hsu_michael_calc(mic_calc_ptr, start_ptr, data_len))
        return;
    #endif

    #if NX_HSU < 2
    michael_calc(mic_calc_ptr, start_ptr, data_len);
    #endif
}

void me_mic_end(struct mic_calc *mic_calc_ptr)
{
    #if NX_HSU
    if (hsu_michael_end(mic_calc_ptr))
        return;
    #endif

    #if NX_HSU < 2
    michael_end(mic_calc_ptr);
    #endif
}

---