/***********************************************************************************

  Filename:     hal_cc2520.c

  Description:  This file implements the CC2520 Radio HAL.

***********************************************************************************/

/***********************************************************************************
* INCLUDES
*/
#include "hal_cc2520.h"
#include "hal_mcu.h"


/***********************************************************************************
* CONSTANTS AND DEFINES
*/
#define BLOCK_SIZE  255


/***********************************************************************************
* LOCAL FUNCTIONS
*/
static uint8 GotException(uint8 index);
static uint8 waitException(uint8 exc, uint16 timeOut);
static void clearException(uint32 dwMap);
static void CC2520_INS_RD_ARRAY(uint16 count, uint8  *pData);
static uint8 CC2520_INS_MEMCP_COMMON(uint8 instr, uint8 pri, uint16 count, \
    uint16 src, uint16 dest);

static uint8 CC2520_SPI_TXRX(uint8 x)
{
    CC2520_SPI_TX(x);
    CC2520_SPI_WAIT_RXRDY();
    return CC2520_SPI_RX();
}

/***********************************************************************************
* @fn      GotException
*
* @brief   Check if exception is set
*
* @param  uint8 index
*
* @return  uint8
*/
static uint8 GotException(uint8 index)
{
    uint8 exceptions = CC2520_REGRD8(CC2520_EXCFLAG0 + (index >> 3));
    if (exceptions & BV(index & 0x07)) {
        return TRUE;
    } else {
        return FALSE;
    }
}


/***********************************************************************************
* @fn      waitException
*
* @brief   Wait for exception
*
* @param  uint8 exc
*         uint16 timeOut
*
* @return  uint8
*/
static uint8 waitException(uint8 exc, uint16 timeOut)
{
    while (--timeOut>0) {
        if (GotException(exc))
            break;
        halMcuWaitUs(10);
    }
    return timeOut>0;
}


/***********************************************************************************
* @fn      clearException
*
* @brief   Clear exception flag
*
* @param  uint32 dwMap
*
* @return  none
*/
static void clearException(uint32 dwMap)
{
    CC2520_REGWR24(CC2520_EXCFLAG0, ~dwMap);
}


/***********************************************************************************
* @fn      CC2520_INS_RD_ARRAY
*
* @brief   Read array from CC2520
*
* @param   uint16 count -
*          uint8  *pData -
*
* @return  none
*/
static void CC2520_INS_RD_ARRAY(uint16 count, uint8  *pData)
{
    while (count--) {
        CC2520_SPI_TX(0x00);
        CC2520_SPI_WAIT_RXRDY();
        *pData = CC2520_SPI_RX();
        pData++;
    }
}



/***********************************************************************************
* @fn      CC2520_INS_MEMCP_COMMON
*
* @brief   memory copy
*
* @param   uint8 instr -
*          uint8 pri -
*          uint16 count -
*          uint16 src -
*          uint16 dest -
*
* @return  uint8 - status byte
*/
static uint8 CC2520_INS_MEMCP_COMMON(uint8 instr, uint8 pri, uint16 count, \
    uint16 src, uint16 dest)
{
    uint8 s;
    CC2520_SPI_BEGIN();
    s = CC2520_SPI_TXRX(instr | pri);
    CC2520_SPI_TXRX(count);
    CC2520_SPI_TXRX((HIBYTE(src) << 4) | HIBYTE(dest));
    CC2520_SPI_TXRX(LOBYTE(src));
    CC2520_SPI_TXRX(LOBYTE(dest));
    CC2520_SPI_END();
    return s;
}


/***********************************************************************************
* GLOBAL FUNCTIONS
*/

/***********************************************************************************
* @fn      CC2520_INS_WR_ARRAY
*
* @brief   Write array to CC2520
*
* @param   uint16 count -
*          uint8  *pData -
*
* @return  none
*/
void CC2520_INS_WR_ARRAY(uint16 count, uint8  *pData)
{
    while (count--) {
        CC2520_SPI_TX(*pData);
        pData++;
        CC2520_SPI_WAIT_RXRDY();
    }
}


/***********************************************************************************
* @fn      CC2520_INS_STROBE
*
* @brief   send strobe commane
*
* @param   uint8 strobe - strobe command
*
* @return  uint8 - status byte
*/
uint8 CC2520_INS_STROBE(uint8 strobe)
{
    uint8 s;
    CC2520_SPI_BEGIN();
    s = CC2520_SPI_TXRX(strobe);
    CC2520_SPI_END();
    return s;
}


/***********************************************************************************
* @fn      CC2520_SNOP
*
* @brief   SNOP instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SNOP(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SNOP);
}


/***********************************************************************************
* @fn      CC2520_SIBUFEX
*
* @brief   SIBUFEX instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SIBUFEX(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SIBUFEX);
}


/***********************************************************************************
* @fn      CC2520_SSAMPLECCA
*
* @brief   Sample CCA instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SSAMPLECCA(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SSAMPLECCA);
}


/***********************************************************************************
* @fn      CC2520_SXOSCON
*
* @brief   SXOSCON instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SXOSCON(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SXOSCON);
}


/***********************************************************************************
* @fn      CC2520_STXCAL
*
* @brief   STXCAL instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_STXCAL(void)
{
    return CC2520_INS_STROBE(CC2520_INS_STXCAL);
}


/***********************************************************************************
* @fn      CC2520_SRXON
*
* @brief   SRXON instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SRXON(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SRXON);
}


/***********************************************************************************
* @fn      CC2520_STXON
*
* @brief   STXON instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_STXON(void)
{
    return CC2520_INS_STROBE(CC2520_INS_STXON);
}


/***********************************************************************************
* @fn      CC2520_STXONCCA
*
* @brief   STXONCCA instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_STXONCCA(void)
{
    return CC2520_INS_STROBE(CC2520_INS_STXONCCA);
}


/***********************************************************************************
* @fn      CC2520_SRFOFF
*
* @brief   SRFOFF instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SRFOFF(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SRFOFF);
}


/***********************************************************************************
* @fn      CC2520_SXOSCOFF
*
* @brief   SXOSCOFF instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SXOSCOFF(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SXOSCOFF);
}


/***********************************************************************************
* @fn      CC2520_SFLUSHRX
*
* @brief   SFLUSHRX instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SFLUSHRX(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SFLUSHRX);
}


/***********************************************************************************
* @fn      CC2520_SFLUSHTX
*
* @brief   SFLUSHTX instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SFLUSHTX(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SFLUSHTX);
}


/***********************************************************************************
* @fn      CC2520_SACK
*
* @brief   SACK instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SACK(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SACK);
}


/***********************************************************************************
* @fn      CC2520_SACKPEND
*
* @brief   SACKPEND instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SACKPEND(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SACKPEND);
}


/***********************************************************************************
* @fn      CC2520_SNACK
*
* @brief   SNACK instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SNACK(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SNACK);
}


/***********************************************************************************
* @fn      CC2520_SRXMASKBITSET
*
* @brief   SRXMASKBITSET instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SRXMASKBITSET(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SRXMASKBITSET);
}


/***********************************************************************************
* @fn      CC2520_SRXMASKBITCLR
*
* @brief   SRXMASKBITCLR instruction strobe
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SRXMASKBITCLR(void)
{
    return CC2520_INS_STROBE(CC2520_INS_SRXMASKBITCLR);
}


/***********************************************************************************
* @fn      CC2520_IBUFLD
*
* @brief   IBUFLD - load instruction to instruction buffer
*
* @param   uint8 i -
*
* @return  uint8 - status byte
*/
uint8 CC2520_IBUFLD(uint8 i)
{
    uint8 s;
    CC2520_SPI_BEGIN();
    s = CC2520_SPI_TXRX(CC2520_INS_IBUFLD);
    CC2520_SPI_TXRX(i);
    CC2520_SPI_END();
    return s;
}


/***********************************************************************************
* @fn      CC2520_SRES
*
* @brief   SRES - Reset device except SPI interface
*
* @param   none
*
* @return  uint8 - status byte
*/
uint8 CC2520_SRES(void)
{
    uint8 s;
    CC2520_SPI_BEGIN();
    s = CC2520_SPI_TXRX(CC2520_INS_SRES);
    CC2520_SPI_TXRX(0x00);
    CC2520_SPI_END();
    return s;
}


/***********************************************************************************
* @fn      CC2520_MEMRD
*
* @brief   Read memory
*
* @param   uint16 addr
*          uint16 count
*          uint8  *pData
*
* @return  uint8 - status byte
*/
uint8 CC2520_MEMRD(uint16 addr, uint16 count, uint8  *pData)
{
    uint8 s;
    CC2520_SPI_BEGIN();
    s = CC2520_SPI_TXRX(CC2520_INS_MEMRD | HIBYTE(addr));
    CC2520_SPI_TXRX(LOBYTE(addr));
    CC2520_INS_RD_ARRAY(count, pData);
    CC2520_SPI_END();
    return s;
}


/***********************************************************************************
* @fn      CC2520_MEMRD8
*
* @brief   Read memory 8 bits
*
* @param   uint16 addr
*
* @return  uint8 - result
*/
uint8 CC2520_MEMRD8(uint16 addr)
{
    uint8 value;
    CC2520_SPI_BEGIN();
    CC2520_SPI_TXRX(CC2520_INS_MEMRD | HIBYTE(addr));
    CC2520_SPI_TXRX(LOBYTE(addr));
    value = CC2520_SPI_TXRX(0x00);
    CC2520_SPI_END();
    return value;
}


/***********************************************************************************
* @fn      CC2520_MEMRD16
*
* @brief   Read memory 16 bits
*
* @param   uint16 addr
*
* @return  uint16 - result
*/
uint16 CC2520_MEMRD16(uint16 addr)
{
    EWORD value;
    CC2520_SPI_BEGIN();
    CC2520_SPI_TXRX(CC2520_INS_MEMRD | HIBYTE(addr));
    CC2520_SPI_TXRX(LOBYTE(addr));
    value.b.b0 = CC2520_SPI_TXRX(0x00);
    value.b.b1 = CC2520_SPI_TXRX(0x00);
    CC2520_SPI_END();
    return value.w;