/**
 * \file talise_jesd204.c
 * \brief Contains functions to support Talise JESD204b data interface
 *
 * Talise API version: 3.5.0.2
 *
 * Copyright 2015-2017 Analog Devices Inc.
 * Released under the AD9378-AD9379 API license, for more information see the "LICENSE.txt" file in this zip file.
 */

#include "talise_jesd204.h"
#include "talise_reg_addr_macros.h"
#include "talise_arm_macros.h"
#include "talise_hal.h"
#include "talise_user.h"
#include "talise_error.h"
#include "talise.h"

uint32_t TALISE_setupSerializers(taliseDevice_t *device, taliseInit_t *init)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t laneInvert = 0;
    uint8_t activeFramersMask = 0; /* bit per framer to for quick access of valid framers enabled. */
    uint8_t activeLanesEnabled = 0;
    uint8_t activeLanesPowerDown = 0xF;
    uint8_t enPreEmphasisMask = 0x00; /* bit per lane */
    uint8_t preEmp = 0x00; /* same value for all lanes */
    uint8_t txser_div = 0;
    uint8_t i = 0;
    uint8_t obsRxL = 0;
    uint8_t rxL = 0;
    uint32_t rxLaneRate_kHz = 0;
    uint32_t obsRxLaneRate_kHz = 0;
    uint32_t fasterLaneRate_kHz = 0;
    uint32_t slowerLaneRate_kHz = 0;
    uint8_t txser_div_reg = 0;
    uint8_t serAmplitude = 0;
    taliseJesd204bFramerConfig_t *currentFramer = NULL;

    static const uint8_t DUALBANDENABLED = 1;

    /* Determine which framer structures are valid */
    if (device->devStateInfo.profilesValid & RX_PROFILE_VALID)
    {
        switch(init->rx.framerSel)
        {
        case TAL_FRAMER_A:
            activeFramersMask |= 0x01;
            activeLanesEnabled |= init->jesd204Settings.framerA.serializerLanesEnabled;
            laneInvert |= ((init->jesd204Settings.framerA.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
            currentFramer = &init->jesd204Settings.framerA;
            break;
        case TAL_FRAMER_B:
            activeFramersMask |= 0x02;
            activeLanesEnabled |= init->jesd204Settings.framerB.serializerLanesEnabled;
            laneInvert |= ((init->jesd204Settings.framerB.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
            currentFramer = &init->jesd204Settings.framerB;
            break;
        case TAL_FRAMER_A_AND_B:
            activeFramersMask |= 0x03;
            activeLanesEnabled |= init->jesd204Settings.framerA.serializerLanesEnabled;
            activeLanesEnabled |= init->jesd204Settings.framerB.serializerLanesEnabled;
            laneInvert |= ((init->jesd204Settings.framerA.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
            laneInvert |= ((init->jesd204Settings.framerB.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
            currentFramer = &init->jesd204Settings.framerA;
            break;
        default:
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_RXFRAMER_SEL, retVal, TALACT_ERR_CHECK_PARAM);
        }

        serAmplitude = init->jesd204Settings.serAmplitude;
        preEmp = init->jesd204Settings.serPreEmphasis;
        enPreEmphasisMask |= (init->jesd204Settings.serPreEmphasis > 0) ? activeLanesEnabled : 0;

        /* TODO: Need error check to make sure that if FRAMER A and B, then make sure each framer has same number of lanes, and M matches */
        for (i = 0; i < 4; i++)
        {
            rxL += ((currentFramer->serializerLanesEnabled >> i) & 0x01);
        }

        if (rxL > 0)
        {
            rxLaneRate_kHz = currentFramer->Np * 10 * init->rx.rxProfile.rxOutputRate_kHz * currentFramer->M / (8 * rxL);
            if ((rxLaneRate_kHz != 0) && ((rxLaneRate_kHz < 768000) || (rxLaneRate_kHz > 12288000)))
            {
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_LANERATE_PARM, retVal, TALACT_ERR_CHECK_PARAM);
            }
        }

        if ((rxL != 0) &&
            (rxL != 1) &&
            (rxL != 2) &&
            (rxL != 4))
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_L_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if ((currentFramer->Np != 12) &&
            (currentFramer->Np != 16) &&
            (currentFramer->Np != 24))
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_NP_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if ((currentFramer->M == 1) && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_INT2_REALIF)
                                    && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_DEC2_REALIF)
                                    && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_FILTERONLY_REALIF)
                                    && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_BYPASS_REALIF))
        {
            return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_ZIF_TO_RIF_DATA_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if ((currentFramer->M == 8) &&
           !(device->devStateInfo.rxDualBandEnabled != DUALBANDENABLED))
        {
            return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_DUALBAND_DATA_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if ((currentFramer->M != 0) &&
            (currentFramer->M != 1) &&
            (currentFramer->M != 2) &&
            (currentFramer->M != 4))
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_M_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if (currentFramer->serializerLanesEnabled > 15)
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_LANEEN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }

    if (device->devStateInfo.profilesValid & ORX_PROFILE_VALID)
    {
        switch(init->obsRx.framerSel)
        {
            case TAL_FRAMER_A:
                activeFramersMask |= 0x01;
                activeLanesEnabled |= init->jesd204Settings.framerA.serializerLanesEnabled;
                laneInvert |= ((init->jesd204Settings.framerA.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
                currentFramer = &init->jesd204Settings.framerA;
                break;
            case TAL_FRAMER_B:
                activeFramersMask |= 0x02;
                activeLanesEnabled |= init->jesd204Settings.framerB.serializerLanesEnabled;
                laneInvert |= ((init->jesd204Settings.framerB.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
                currentFramer = &init->jesd204Settings.framerB;
                break;
            case TAL_FRAMER_A_AND_B:
                activeFramersMask |= 0x03;
                activeLanesEnabled |= init->jesd204Settings.framerA.serializerLanesEnabled;
                activeLanesEnabled |= init->jesd204Settings.framerB.serializerLanesEnabled;
                laneInvert |= ((init->jesd204Settings.framerA.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
                laneInvert |= ((init->jesd204Settings.framerB.serializerLanesEnabled) & (init->jesd204Settings.serInvertLanePolarity));
                currentFramer = &init->jesd204Settings.framerA;
                break;
            default:
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_SER_INV_ORXFRAMER_SEL, retVal, TALACT_ERR_CHECK_PARAM);
        }

        serAmplitude = init->jesd204Settings.serAmplitude;
        preEmp = init->jesd204Settings.serPreEmphasis;
        enPreEmphasisMask |= (init->jesd204Settings.serPreEmphasis > 0) ? activeLanesEnabled : 0;

        /* TODO: Need error check to make sure that if FRAMER A and B, then make sure each framer has same number of lanes, and M matches */
        for(i = 0; i < 4; i++)
        {
            obsRxL += ((currentFramer->serializerLanesEnabled >> i) & 0x01);
        }

        if (obsRxL > 0)
        {
            obsRxLaneRate_kHz = currentFramer->Np * 10 * init->obsRx.orxProfile.orxOutputRate_kHz * currentFramer->M / (8 * obsRxL);
            if ((obsRxLaneRate_kHz != 0) && ((obsRxLaneRate_kHz < 768000) || (obsRxLaneRate_kHz > 12288000)))
            {
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_SER_INV_ORX_LANERATE_PARM, retVal, TALACT_ERR_CHECK_PARAM);
            }
        }

        if ((obsRxL != 0) &&
            (obsRxL != 1) &&
            (obsRxL != 2) &&
            (obsRxL != 4))
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_INV_ORX_L_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if ((currentFramer->Np != 12) &&
            (currentFramer->Np != 16) &&
            (currentFramer->Np != 24))
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_INV_ORX_NP_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if ((currentFramer->M != 0) &&
            (currentFramer->M != 1) &&
            (currentFramer->M != 2) &&
            (currentFramer->M != 4))
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_INV_ORX_M_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if (currentFramer->serializerLanesEnabled > 15)
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_INV_ORX_LANEEN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }

    if (activeFramersMask == 0x03)
    {
        /* Verify FramerA and FramerB do not share physical lanes */
        if (init->jesd204Settings.framerA.serializerLanesEnabled &
            init->jesd204Settings.framerB.serializerLanesEnabled
           )
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_LANE_CONFLICT_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }

    if (init->jesd204Settings.serAmplitude > 15)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_SER_INV_AMP_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (init->jesd204Settings.serPreEmphasis > 4)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_SER_INV_PREEMP_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (init->jesd204Settings.serInvertLanePolarity > 15)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_SER_INV_LANEPN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Calculate needed JESD204 serializer lane rates */
    if ((rxLaneRate_kHz > 0) &&
        (obsRxLaneRate_kHz > 0))
    {
        fasterLaneRate_kHz = (rxLaneRate_kHz >= obsRxLaneRate_kHz) ? (rxLaneRate_kHz) : (obsRxLaneRate_kHz);
        slowerLaneRate_kHz = (rxLaneRate_kHz >= obsRxLaneRate_kHz) ? (obsRxLaneRate_kHz) : (rxLaneRate_kHz);

        /* Verify that lane rates are integer multiples of each other */
        if (fasterLaneRate_kHz % slowerLaneRate_kHz != 0)
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_LANE_RATE_CONFLICT_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }
    else
    {
        fasterLaneRate_kHz = (rxLaneRate_kHz >= obsRxLaneRate_kHz) ? (rxLaneRate_kHz) : (obsRxLaneRate_kHz);
    }

    /* performing integer multiple check on HS clock and lane rate clock */
    if (fasterLaneRate_kHz == 0)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_SER_LANERATE_ZERO, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((init->clocks.clkPllVcoFreq_kHz % fasterLaneRate_kHz) != 0)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_HS_AND_LANE_RATE_NOT_INTEGER_MULT, retVal, TALACT_ERR_CHECK_PARAM);
    }

    txser_div = (uint8_t)(init->clocks.clkPllVcoFreq_kHz / fasterLaneRate_kHz);

    switch(txser_div)
    {
        case 1:
            txser_div_reg = 0;
            break;
        case 2:
            txser_div_reg = 1;
            break;
        case 4:
            txser_div_reg = 2;
            break;
        case 8:
            txser_div_reg = 2;
            break;
        default:
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_SER_INV_TXSER_DIV_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Set Tx serializer divider */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_CLOCK_CONTROL_3, txser_div_reg, 0x03, 0);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Power down all lanes */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_SRST_CFG, 0xFF); /* hold framer output data in reset */
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Reset serializers */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_PD, 0x1E); /* power down all lanes */
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    activeLanesPowerDown = (~((activeLanesEnabled & 0x09) | ((activeLanesEnabled & 0x02) << 1) | ((activeLanesEnabled & 0x04) >> 1)) & 0x0F);
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_PD, (0x80 | (activeLanesPowerDown << 1))); /* power up desired lanes */
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Manual Serializer reset sequence */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_1, 0x3F);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_1, 0x2F);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_1, 0x27);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_1, 0x23);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_1, 0x21);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_1, 0x20);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* data structure encoding: 0 = PreEmp off, 1 = on with preEmp=0 */
    if (preEmp > 0)
    {
        preEmp = preEmp - 1;
    }

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PREEMPH_CTRL, ((preEmp << 4) | (preEmp)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    enPreEmphasisMask = ((enPreEmphasisMask & 0x09) | ((enPreEmphasisMask & 0x02) << 1) | ((enPreEmphasisMask & 0x04) >> 1));
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_ENABLES, (0x50 | (enPreEmphasisMask & 0x0F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_ENABLES, (0x10 | (enPreEmphasisMask & 0x0F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set serializer amplitude */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_SER_PHY_TXCTRL_0, (0x03 | ((serAmplitude & 0x0F) << 3)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Allow framer data to output to serializer (clear reset) */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_SRST_CFG, 0x0F);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* correct lane swaps and PN inverts on device laminate - swap lane 1 and 2 and invert all Framer lanes */
    laneInvert = ((laneInvert & 0x09) | ((laneInvert & 0x02) << 1) | ((laneInvert & 0x04) >> 1));
    laneInvert = ~laneInvert;
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_COMMON_CFG, laneInvert);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Toggle Serializer SRESET */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_SRST_CFG, 0xFF);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Allow framer data to output to serializer (clear reset) */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_SRST_CFG, 0x0F);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_setupDeserializers(taliseDevice_t *device, taliseInit_t *init)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t cdrDiv = 0;
    uint8_t deserializerDiv = 0;
    uint8_t laneInvert = 0;
    uint8_t lanesEnabled = 0;
    uint8_t lanesPowerDown = 0x0F;
    uint8_t halfRateMode = 0;
    uint32_t laneRate_kHz = 0;
    uint8_t totalM = 0;
    uint8_t totalNp = 0;
    uint8_t totalL = 0;
    uint8_t i = 0;
    uint8_t laneRateRatio = 0;
    uint8_t desEqSetting = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setupDeserializers()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (device->devStateInfo.profilesValid & TX_PROFILE_VALID)
    {
        if (init->tx.deframerSel == TAL_DEFRAMER_A)
        {
            lanesEnabled = init->jesd204Settings.deframerA.deserializerLanesEnabled;
            totalM = init->jesd204Settings.deframerA.M;
            totalNp = init->jesd204Settings.deframerA.Np;
        }
        else if (init->tx.deframerSel == TAL_DEFRAMER_B)
        {
            lanesEnabled = init->jesd204Settings.deframerB.deserializerLanesEnabled;
            totalM = init->jesd204Settings.deframerB.M;
            totalNp = init->jesd204Settings.deframerB.Np;
        }
        else if (init->tx.deframerSel == TAL_DEFRAMER_A_AND_B)
        {
            /* verify deframer A and deframer B do not share common physical lanes */
            if ((init->jesd204Settings.deframerA.deserializerLanesEnabled &
                init->jesd204Settings.deframerB.deserializerLanesEnabled) > 0)
            {
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_DESER_LANECONFLICT_PARM, retVal, TALACT_ERR_CHECK_PARAM);
            }

            lanesEnabled = init->jesd204Settings.deframerA.deserializerLanesEnabled |
                           init->jesd204Settings.deframerB.deserializerLanesEnabled;

            if (init->jesd204Settings.deframerA.M != init->jesd204Settings.deframerB.M)
            {
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_DESER_M_CONFLICT, retVal, TALACT_ERR_CHECK_PARAM);
            }

            if (init->jesd204Settings.deframerA.M > 2)
            {
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_DESER_INV_DEFAB_M, retVal, TALACT_ERR_CHECK_PARAM);
            }

            if (init->jesd204Settings.deframerA.Np != init->jesd204Settings.deframerB.Np)
            {
                return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_DESER_NP_CONFLICT, retVal, TALACT_ERR_CHECK_PARAM);
            }

            /* M * 2 since lane rate needs to be calculated with total M for both framers */
            totalM = init->jesd204Settings.deframerA.M * 2;
            totalNp = init->jesd204Settings.deframerA.Np;
        }
        else
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_DESER_INV_DEFRAMERSEL, retVal, TALACT_ERR_CHECK_PARAM);
        }

        if (lanesEnabled > 0x0F)
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_DESER_INV_LANEEN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
        }

        lanesPowerDown = ((~lanesEnabled) & 0x0F);
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_TXPROFILE_INV, retVal, TALACT_ERR_CHECK_PARAM);
    }

    for (i = 0; i < 4; i++)
    {
        totalL += ((lanesEnabled >> i) & 0x01);
    }

    if ((totalL == 0) ||
        (totalL == 3) ||
        (totalL > 4))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_INV_L_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((totalM != 2) &&
        (totalM != 4))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_INV_M_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((totalNp != 12) &&
        (totalNp != 16))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_INV_NP_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    laneRate_kHz = (init->tx.txProfile.txInputRate_kHz * totalM * 10 * totalNp) / (8 * totalL);

    if ((laneRate_kHz < 614400) ||
        (laneRate_kHz > 12288000))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_INV_LANERATE_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (init->clocks.clkPllVcoFreq_kHz % laneRate_kHz != 0)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESES_HS_AND_LANE_RATE_NOT_INTEGER_MULT, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((totalNp == 12) &&
        (init->clocks.clkPllVcoFreq_kHz != laneRate_kHz))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESES_INV_LANE_RATE, retVal, TALACT_ERR_CHECK_PARAM);
    }

    laneRateRatio = (uint8_t)(init->clocks.clkPllVcoFreq_kHz / laneRate_kHz);
    switch (laneRateRatio)
    {
        case 1:
            halfRateMode = 1;
            deserializerDiv = 0; /* divide by 1 */
            break;
        case 2:
            halfRateMode = 0; /* Full rate mode */
            deserializerDiv = 0; /* divide by 1 */
            break;
        case 4:
            halfRateMode = 0; /* Full rate mode */
            deserializerDiv = 1; /* divide by 2 */
            break;
        case 8:
            halfRateMode = 0; /* Full rate mode */
            deserializerDiv = 2; /* divide by 2 */
            break;
        case 16:
            halfRateMode = 0; /* Full rate mode */
            deserializerDiv = 3; /* divide by 2 */
            break;
        default:
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_DESES_INV_LANE_RATE_DIV, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }

    if ((init->jesd204Settings.desEqSetting != 0) &&
        (init->jesd204Settings.desEqSetting != 1) &&
        (init->jesd204Settings.desEqSetting != 2))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_INV_EQ_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (init->jesd204Settings.desInvertLanePolarity > 15)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DESER_INV_LANEPN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Set lane PN inverts - invert all lanes by default due to PN inverts in Talise laminate */
    laneInvert = (~(init->jesd204Settings.desInvertLanePolarity) & 0x0F);

    /* Power up deserializers */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_DES_PHY_PWR_DWN_0, 0x00);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_DES_PHY_PWR_DWN_4, 0x20);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set deserializer half rate/full rate mode and deserializer divider */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_DES_PHY_CLK_CTL_0, halfRateMode, 0x40, 6);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_DES_PHY_CLK_CTL_1, deserializerDiv);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set CDR divider - set lane clock frequency (keep lane clock in 3.072G to 6.144G range) */
    cdrDiv = 0;  /* always div 1 on CDR divider */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_CLOCK_CONTROL_3, cdrDiv, 0x0C, 2);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set lane PN inverts - invert all lanes by default due to PN inverts in Talise laminate */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_COMMON_CFG3, laneInvert, 0xF0, 4);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set CDR clock enable */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_DES_PHY_GENERAL_CTL_0, 0x90);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Release lane power downs */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_DES_PHY_PWR_DWN_4, lanesPowerDown, 0x0F, 0);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Release deserializer master power down */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_DES_PHY_PWR_DWN_4, 0, 0x20, 5);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set EQ */
    desEqSetting = (init->jesd204Settings.desEqSetting << 6) | (init->jesd204Settings.desEqSetting << 4) |
                   (init->jesd204Settings.desEqSetting << 2) | init->jesd204Settings.desEqSetting;
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_DES_PHY_EQ_CONTROL2, desEqSetting);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Enable deserializers */
    halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_DES_PHY_GENERAL_CTL_1, 1, 0x10, 4);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_setupJesd204bFramer(taliseDevice_t *device, taliseInit_t *init, taliseFramerSel_t framerSel)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    taliseJesd204bFramerConfig_t *framer = NULL;
    uint8_t i = 0;
    uint8_t L = 0;
    uint8_t CF = 0;
    uint8_t CS = 0;
    uint8_t S = 1;
    uint8_t JESDVER = 1;
    uint8_t JESDSUBCLASS = 1;
    uint32_t framerAdcXbar = 0;
    uint16_t FK = 0;
    uint8_t HD = 0;
    uint8_t framerLaneXbar = 0xE4;
    uint32_t outputRate_kHz = 0;
    uint8_t pclkDiv = 0;
    uint32_t hsDigClkDiv4or5_Hz = 0;
    uint32_t pclk_Hz = 0;
    uint16_t framerAddrOffset = 0;
    uint8_t scr = 0;

    const uint8_t DUALBANDENABLED = 1;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG,
                            TAL_ERR_OK, "TALISE_setupJesd204bFramer()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
 #endif

    if (framerSel == TAL_FRAMER_A)
    {
        framer = &init->jesd204Settings.framerA;
        framerAddrOffset = 0;
    }
    else if (framerSel == TAL_FRAMER_B)
    {
        framer = &init->jesd204Settings.framerB;
        framerAddrOffset = TALISE_JESD_FRAMERB_OFFSET;
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_FRAMERSEL_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (framer->M == 0)
    {
        /* Disable Framer link and exit Framer setup */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), 0x02);
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    }
    else if ((framer->M == 1) && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_INT2_REALIF)
                              && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_DEC2_REALIF)
                              && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_FILTERONLY_REALIF)
                              && !(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_BYPASS_REALIF))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SER_INV_ZIF_TO_RIF_DATA_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    else if ((framer->M == 8) &&
            !(device->devStateInfo.rxDualBandEnabled == DUALBANDENABLED))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_DUALBAND_DATA_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((framer->M != 1) &&
        (framer->M != 2) &&
        (framer->M != 4) &&
        (framer->M != 8))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_M_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((framer->Np != 12) &&
        (framer->Np != 16) &&
        (framer->Np != 24))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_NP_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (framer->bankId > 15)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_BANKID_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* no need to check deviceId, its range is full uint8_t range */
    if (framer->lane0Id > 31)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_LANEID_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (framer->syncbInSelect > 1)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_SYNCBIN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* count number of lanes */
    L = 0;
    for (i = 0; i < 4; i++)
    {
        L += ((framer->serializerLanesEnabled >> i) & 0x01);
    }

    if (L == 0)
    {
        /* Disable Link, and return from function */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), 0x02);
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    }
    else if ((L != 1) &&
             (L != 2) &&
             (L != 4))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_RXFRAMER_INV_L_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Check for fractional S value  - invalid settings */
    if (((framer->F * L * 8) % (framer->Np * framer->M)) > 0)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_S_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    S = (framer->F * L * 8) / (framer->Np * framer->M);
    if ((S != 1) &&
        (S != 2) &&
        (S != 4) &&
        (S != 8))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_S_PARM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    FK = ((uint16_t)(framer->K) * (uint16_t)(framer->F));

    if ((FK < 20) ||
        (FK > 1024) ||
        (FK % 4 != 0))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_RXFRAMER_INV_FK_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    HD = ((((uint16_t)(framer->F) * 8) % framer->Np) > 0) ? (1) : (0);

    if (framer->enableManualLaneXbar != 0) {
        framerLaneXbar = framer->serializerLaneCrossbar;
    }
    else
    {
        switch((framer->serializerLanesEnabled & 0x0F))
        {
            /* Lanes 1 and 2 are swapped on laminate, correct here */
            /* Set unused lanes to select value b11 */
            case 1:  framerLaneXbar = 0xFC; break;
            case 2:  framerLaneXbar = 0xCF; break;
            case 3:  framerLaneXbar = 0xDC; break;
            case 4:  framerLaneXbar = 0xF3; break;
            case 5:  framerLaneXbar = 0xF4; break;
            case 6:  framerLaneXbar = 0xC7; break;
            case 8:  framerLaneXbar = 0x3F; break;
            case 9:  framerLaneXbar = 0x7C; break;
            case 10: framerLaneXbar = 0x4F; break;
            case 12: framerLaneXbar = 0x73; break;
            case 15: framerLaneXbar = 0xD8; break;
            default: framerLaneXbar = 0xD8; break;
        }
    }

    if (framer->M == 8)
    {
        framerAdcXbar = 0x37251301;
    }
    else
    {
        framerAdcXbar = 0x00001301;
    }

    /* Determine framer PCLK frequency */
    if (device->devStateInfo.profilesValid & RX_PROFILE_VALID)
    {
        /* If Rx profile is using this framer, use the Rx IQ data rate */
        if ((init->rx.framerSel == TAL_FRAMER_A_AND_B) ||
            (init->rx.framerSel == framerSel))
        {
            outputRate_kHz = init->rx.rxProfile.rxOutputRate_kHz;
        }
    }

    if (device->devStateInfo.profilesValid & ORX_PROFILE_VALID)
    {
        /* If ORx profile is using this framer, use the ORx IQ data rate */
        if ((init->obsRx.framerSel == TAL_FRAMER_A_AND_B) || (init->obsRx.framerSel == framerSel))
        {
            outputRate_kHz = init->obsRx.orxProfile.orxOutputRate_kHz;
        }
    }

    /* If Rx and ORx share same framer - set PCLK to faster of two rates */
    if ((device->devStateInfo.profilesValid & RX_PROFILE_VALID) &&
        (device->devStateInfo.profilesValid & ORX_PROFILE_VALID) &&
        (init->rx.framerSel == init->obsRx.framerSel) &&
        (init->rx.framerSel == framerSel))
    {
        if (init->obsRx.orxProfile.orxOutputRate_kHz > init->rx.rxProfile.rxOutputRate_kHz)
        {
            outputRate_kHz =  init->obsRx.orxProfile.orxOutputRate_kHz;
        }
        else
        {
            outputRate_kHz = init->rx.rxProfile.rxOutputRate_kHz;
        }
    }

    if (outputRate_kHz == 0)
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_RXFRAMER_INV_OUTPUT_RATE, retVal, TALACT_ERR_CHECK_PARAM);
    }

    pclk_Hz = (outputRate_kHz * (uint32_t)(framer->F) * 1000) / ((uint32_t)(S) * 4);

    /* Determine PCLK divider */

    hsDigClkDiv4or5_Hz = device->devStateInfo.clocks.hsDigClkDiv4or5_Hz;

    if ((framer->F == 3) ||
        (framer->F == 6))
    {
        pclkDiv = 0;
    }
    else
    {
        for (pclkDiv = 0; pclkDiv < 8; pclkDiv++)
        {
            if ((hsDigClkDiv4or5_Hz >> pclkDiv) == pclk_Hz)
            {
                break; /* Use current pclk divider */
            }

            if (pclkDiv == 7)
            {
                return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_RXFRAMER_INV_PCLKFREQ, retVal, TALACT_ERR_CHECK_PARAM);
            }
        }
    }

    /* Disable JESD204b link enable */
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), ((framer->syncbInSelect << 5) | 0x02));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG0_0 + framerAddrOffset), framer->deviceId); /* DID */
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG1_0 + framerAddrOffset), (framer->bankId & 0x0F));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG2_0 + framerAddrOffset), (framer->lane0Id & 0x1F));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    scr = (framer->scramble == 0) ? 0x00 : 0x80;

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG3_0 + framerAddrOffset), (scr | ((L-1) & 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG4_0 + framerAddrOffset), (framer->F - 1));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG5_0 + framerAddrOffset), (framer->K - 1));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG6_0 + framerAddrOffset), (framer->M - 1));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG7_0 + framerAddrOffset), (((CS & 3) << 6) | ((framer->Np & 0x1F) - 1)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG8_0 + framerAddrOffset), (((JESDSUBCLASS & 7) << 5) | ((framer->Np & 0x1F) - 1)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG9_0 + framerAddrOffset), (((JESDVER & 7) << 5) | (S - 1)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_L0_CFG10_0 + framerAddrOffset), ((HD << 7) | (CF & 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_ILAS_MF_COUNT_0, 0x00); /* 4 multiframes in ILAS */
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Sample Crossbar */
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_01_0 + framerAddrOffset), (uint8_t)(framerAdcXbar));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_23_0 + framerAddrOffset), (uint8_t)(framerAdcXbar >> 8));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_45_0 + framerAddrOffset), (uint8_t)(framerAdcXbar >> 16));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_67_0 + framerAddrOffset), (uint8_t)(framerAdcXbar >> 24));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Framer: Set Lane Crossbar */
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_LANE_XBAR_0 + framerAddrOffset), framerLaneXbar);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* enabling the SYSREF for relink if newSysrefOnRelink is set */
    if (framer->newSysrefOnRelink > 0)
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SYSREF_CFG_0 + framerAddrOffset), 0x01, 0x02, 1);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    if (framer->lmfcOffset < framer->K)
    {
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG5_0 + framerAddrOffset), ((pclkDiv << 5) | (framer->lmfcOffset & 0x1F)));
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }
    else
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_LMFC_OFFSET_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* If 11G mode, set async PCLK bit */
    if ((framer->F == 3) ||
        (framer->F == 6))
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG4_0 + framerAddrOffset), 0x01, 0x08, 3);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    /* Enable Framer link */
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), ((framer->syncbInSelect << 5) | 0x03));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_setupJesd204bDeframer(taliseDevice_t *device, taliseInit_t *init, taliseDeframerSel_t deframerSel)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t deframerAddrOffset = 0;
    taliseJesd204bDeframerConfig_t *deframer = NULL;
    uint8_t i = 0;
    uint8_t newSysrefOnRelink = 0;
    uint8_t scr = 0;
    uint8_t L = 0;
    uint8_t F = 0;
    uint8_t S = 1;
    uint32_t pclk_kHz = 0;
    uint16_t FK = 0;
    uint8_t HD = 0;
    uint32_t hsDigClkDiv4or5_Hz = 0;
    uint8_t pclkDiv = 0;
    uint8_t pclkReg = 0;
    uint8_t extSysref = 0;
    uint8_t syncBarSel = 1;
    uint8_t deframerInput = 0;
    uint8_t lane = 0;
    uint8_t deframerlaneXbar = 0;

    static const uint8_t CS = 0;
    static const uint8_t CF = 0;
    static const uint8_t SUBCLASSV = 1;
    static const uint8_t JESDV = 1;
    static const uint8_t DFRMRCMMIRQMASK = 0x80;

    if (device->devStateInfo.profilesValid & TX_PROFILE_VALID)
    {
        if (deframerSel == TAL_DEFRAMER_A)
        {
            deframerAddrOffset = 0;
            deframer = &init->jesd204Settings.deframerA;
        }
        else if (deframerSel == TAL_DEFRAMER_B)
        {
            deframerAddrOffset = TALISE_JESD_DEFRAMERB_OFFSET;
            deframer = &init->jesd204Settings.deframerB;
        }
        else
        {
            return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_DEFRAMER_INV_DEFSEL, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }
    else
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_TXPROFILE, retVal, TALACT_ERR_CHECK_PARAM);
    }

    newSysrefOnRelink = (deframer->newSysrefOnRelink > 0) ? 1 : 0;

    scr = (deframer->scramble > 0) ? 1 : 0;

    if (deframer->deserializerLanesEnabled > 15)
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_LANESEN, retVal, TALACT_ERR_CHECK_PARAM);
    }

    for (i = 0; i < 4; i++)
    {
        L += ((deframer->deserializerLanesEnabled >> i) & 0x01);
    }

    if ((L != 1) &&
        (L != 2) &&
        (L != 4))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_L, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((deframer->M != 2) &&
        (deframer->M != 4))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_M, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((deframer->Np != 12) &&
        (deframer->Np != 16))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_NP, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Check for fractional F - invalid settings */
    if(device->devStateInfo.swTest > 0)
    {
        /*For a software test bypass bounds checking on F and assign a valid value*/
        F = 2;
    }
    else
    {
        if (((deframer->Np * deframer->M * S) % (8 * L)) > 0)
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_DEFRAMER_INV_F, retVal, TALACT_ERR_CHECK_PARAM);
        }

        F = (deframer->Np * deframer->M * S) / (8 * L);
    }

    if ((F < 1) ||
        (F > 32))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_F, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((deframer->K < 1) ||
        (deframer->K > 32))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_K, retVal, TALACT_ERR_CHECK_PARAM);
    }

    FK = (uint16_t)F * (uint16_t)deframer->K;
    if (((FK % 4) != 0) ||
         (FK < 20) ||
         (FK > 1024))
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_FK, retVal, TALACT_ERR_CHECK_PARAM);
    }

    pclk_kHz = init->tx.txProfile.txInputRate_kHz * (uint32_t)(F) / (uint32_t)(S) / 4;
    HD = ((((uint16_t)(F) * 8) % deframer->Np) > 0) ? 1 : 0;

    hsDigClkDiv4or5_Hz = device->devStateInfo.clocks.hsDigClkDiv4or5_Hz;

    if ((F == 3) ||
        (F == 6))
    {
        pclkReg = 0;
    }
    else
    {
        if (((hsDigClkDiv4or5_Hz / 1000) % pclk_kHz) != 0)
        {
            return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_DEFRAMER_INV_PCLK, retVal, TALACT_ERR_CHECK_PARAM);
        }

        pclkDiv = (uint8_t)(hsDigClkDiv4or5_Hz / 1000 / pclk_kHz);

        switch (pclkDiv)
        {
            case 1:
                pclkReg = 0; /* PCLK = HsDigClk /4 */
                break;
            case 2:
                pclkReg = 1; /* PCLK = HsDigClk /8 */
                break;
            case 4:
                pclkReg = 2; /* PCLK = HsDigClk /16 */
                break;
            case 8:
                pclkReg = 3; /* PCLK = HsDigClk /32 */
                break;
            case 16:
                pclkReg = 4; /* PCLK = HsDigClk /64 */
                break;
            case 32:
                pclkReg = 5; /* PCLK = HsDigClk /128 */
                break;
            default:
            {
                return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                        TAL_ERR_DEFRAMER_INV_PCLKDIV, retVal, TALACT_ERR_CHECK_PARAM);
            }
        }
    }

    if (deframer->bankId > 15)
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_BANKID, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (deframer->lane0Id > 31)
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_ERR_DEFRAMER_INV_LANEID, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (deframer->lmfcOffset >= deframer->K)
    {
        return (uint32_t)talApiErrHandler(device,TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFRAMER_INV_LMFC_OFFSET, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Disable deframer link */
    retVal = (talRecoveryActions_t)TALISE_enableDeframerLink(device, deframerSel, 0);
    IF_ERR_RETURN_U32(retVal);

    /* checksum mode - clear [7] for correct mode */
    halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_CFG3_0 + deframerAddrOffset), 0, 0x80, 7);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Disable Deframer CMM IRQ Interrupt */
    halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_0 + deframerAddrOffset), DFRMRCMMIRQMASK, 0x80, 0);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Set LMFC Offset */
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_CFG4_0 + deframerAddrOffset), deframer->lmfcOffset);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    extSysref = (deframer->externalSysref > 0) ? 1 : 0;
    halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG2_0 + deframerAddrOffset), extSysref, 0x20, 5);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* If no external sysref, also clear SYSREF enable bit */
    if (extSysref == 0)
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG_0 + deframerAddrOffset), 0, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG_0 + deframerAddrOffset), newSysrefOnRelink, 0x02, 1);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* set PCLK for deframers */
    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_COMMON_CFG, (0x10 | pclkReg));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* select SYNCOUTB 0 or 1 pin */
    /* TODO: Fix this SYNCB selection - can use both and they get ANDed*/

    syncBarSel = (deframer->syncbOutSelect > 0) ? 2 : 1;

    halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_CFG_0 + deframerAddrOffset), syncBarSel, 0x60, 5);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG0_0 + deframerAddrOffset), deframer->deviceId);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG1_0 + deframerAddrOffset), (deframer->bankId & 0x0F));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG2_0 + deframerAddrOffset), (deframer->lane0Id & 0x1F));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG3_0 + deframerAddrOffset), ((scr << 7) | ((L - 1) & 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG4_0 + deframerAddrOffset), (F - 1));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG5_0 + deframerAddrOffset), ((deframer->K - 1) & 0x1F));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG6_0 + deframerAddrOffset), (deframer->M - 1));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG7_0 + deframerAddrOffset), (((CS & 0x03) << 6) | ((deframer->Np - 1) & 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG8_0 + deframerAddrOffset), (((SUBCLASSV & 0x7) << 5) | ((deframer->Np - 1) & 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG9_0 + deframerAddrOffset), (((JESDV & 0x7) << 5) | ((S - 1) & 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_L0_CFG10_0 + deframerAddrOffset), ((HD << 7) | (CF * 0x1F)));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_ILAS_MF_COUNT_0 + deframerAddrOffset), 0x00);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    if (deframer->enableManualLaneXbar != 0) {
        deframerlaneXbar = deframer->deserializerLaneCrossbar;
    }
    else
    {
        /* Lane crossbar  - Allow user to reorder lanes in deframer->deserializerLaneCrossbar, but this code still */
        /* maps used lanes to deframer inputs */
        deframerInput = 0;
        for (lane = 0; lane < 4; lane++)
        {
            if ((deframer->deserializerLanesEnabled >> lane) & 1)
            {
                deframerlaneXbar |= (((deframer->deserializerLaneCrossbar >> (lane << 1)) & 3) << (deframerInput << 1));
                deframerInput += 1;
            }
        }
    }
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_LANE_XBAR_0 + deframerAddrOffset), deframerlaneXbar);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Enable deframer link */
    retVal = (talRecoveryActions_t)TALISE_enableDeframerLink(device, deframerSel, 1);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_enableFramerLink(taliseDevice_t *device, taliseFramerSel_t framerSel, uint8_t enable)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t enableLink = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_enableFramerLink()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    enableLink = (enable > 0) ? 1 : 0;

    if ((framerSel != TAL_FRAMER_A) && (framerSel != TAL_FRAMER_B) && (framerSel != TAL_FRAMER_A_AND_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_RSTFRAMER_INV_FRAMERSEL, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((framerSel == TAL_FRAMER_A) ||
        (framerSel == TAL_FRAMER_A_AND_B))
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0), enableLink, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

    }

    if ((framerSel == TAL_FRAMER_B) ||
        (framerSel == TAL_FRAMER_A_AND_B))
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + TALISE_JESD_FRAMERB_OFFSET), enableLink, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_enableDeframerLink(taliseDevice_t *device, taliseDeframerSel_t deframerSel, uint8_t enable)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t deframerOffset = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_enableDeframerLink()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (deframerSel == TAL_DEFRAMER_A)
    {
        deframerOffset = 0;
    }
    else if (deframerSel == TAL_DEFRAMER_B)
    {
        deframerOffset = TALISE_JESD_DEFRAMERB_OFFSET;
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_RSTDEFRAMER_INV_DEFSEL, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (enable > 0)
    {
        /* Enable the deframer JESD link */
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_CFG_0 + deframerOffset), 1, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }
    else
    {
        /* clear deframer link enable bit */
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_CFG_0 + deframerOffset), 0, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_enableSysrefToFramer(taliseDevice_t *device, taliseFramerSel_t framerSel, uint8_t enable)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t enableSysref = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_enableSysrefToFramer()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    enableSysref = (enable > 0) ? 1 : 0;

    if ((framerSel != TAL_FRAMER_A) &&
        (framerSel != TAL_FRAMER_B) &&
        (framerSel != TAL_FRAMER_A_AND_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_ENFRAMERSYSREF_INV_FRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((framerSel == TAL_FRAMER_A) ||
        (framerSel == TAL_FRAMER_A_AND_B))
    {
        halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_SYSREF_CFG_0, enableSysref, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    if ((framerSel == TAL_FRAMER_B) ||
        (framerSel == TAL_FRAMER_A_AND_B))
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SYSREF_CFG_0 + TALISE_JESD_FRAMERB_OFFSET), enableSysref, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_enableSysrefToDeframer(taliseDevice_t *device, taliseDeframerSel_t deframerSel, uint8_t enable)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t enableSysref = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_enableSysrefToDeframer()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    enableSysref = (enable > 0) ? 1 : 0;

    if ((deframerSel != TAL_DEFRAMER_A) &&
        (deframerSel != TAL_DEFRAMER_B) &&
        (deframerSel != TAL_DEFRAMER_A_AND_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_ENDEFSYSREF_INV_DEFRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((deframerSel == TAL_DEFRAMER_A) ||
        (deframerSel == TAL_DEFRAMER_A_AND_B))
    {
        halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG_0, enableSysref, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    if ((deframerSel == TAL_DEFRAMER_B) ||
        (deframerSel == TAL_DEFRAMER_A_AND_B))
    {
        halError = talSpiWriteField(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG_0 + TALISE_JESD_DEFRAMERB_OFFSET), enableSysref, 0x01, 0);
        retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_readFramerStatus(taliseDevice_t *device, taliseFramerSel_t framerSel, uint8_t *framerStatus)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t sysrefStatus = 0;
    uint8_t configStatus3 = 0;
    uint8_t configStatus4 = 0;
    uint8_t syncStatus = 0;
    uint16_t sysrefStatusAddr = TALISE_ADDR_JESD_FRAMER_SYSREF_CFG2_0;
    uint16_t syncStatusAddr = TALISE_ADDR_JESD_FRAMER_CFG_0;
    uint16_t configStatus3Addr = TALISE_ADDR_JESD_FRAMER_SYSREF_CFG3_0;
    uint16_t configStatus4Addr = TALISE_ADDR_JESD_FRAMER_CFG4_0;
    static const uint8_t INVALIDCFG_STS_MIN_SUPPORTED_SIREV = 0xC0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_readFramerStatus()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (framerSel == TAL_FRAMER_A)
    {
        sysrefStatusAddr = TALISE_ADDR_JESD_FRAMER_SYSREF_CFG2_0;
        syncStatusAddr = TALISE_ADDR_JESD_FRAMER_CFG_0;
        configStatus3Addr = TALISE_ADDR_JESD_FRAMER_CFG3_0;
        configStatus4Addr = TALISE_ADDR_JESD_FRAMER_CFG4_0;
    }
    else if (framerSel == TAL_FRAMER_B)
    {
        sysrefStatusAddr = TALISE_ADDR_JESD_FRAMER_SYSREF_CFG2_0 + TALISE_JESD_FRAMERB_OFFSET;
        syncStatusAddr = TALISE_ADDR_JESD_FRAMER_CFG_0 + TALISE_JESD_FRAMERB_OFFSET;
        configStatus3Addr = TALISE_ADDR_JESD_FRAMER_CFG3_0 + TALISE_JESD_FRAMERB_OFFSET;
        configStatus4Addr = TALISE_ADDR_JESD_FRAMER_CFG4_0 + TALISE_JESD_FRAMERB_OFFSET;
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                 TAL_ERR_FRAMERSTATUS_INV_FRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (framerStatus == NULL)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMERSTATUS_NULL_FRAMERSTATUS_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    halError = ADIHAL_spiReadField(device->devHalInfo, sysrefStatusAddr, &sysrefStatus, 0x03, 0);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = ADIHAL_spiReadField(device->devHalInfo, syncStatusAddr, &syncStatus, 0x30, 4);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = ADIHAL_spiReadField(device->devHalInfo, configStatus3Addr, &configStatus3, 0x01, 0);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /*Read Invalid Framer Config status only if Silicon Revision is C0 or higher, else report 0 as invalid config*/
    if(device->devStateInfo.deviceSiRev >= INVALIDCFG_STS_MIN_SUPPORTED_SIREV)
    {
        halError = ADIHAL_spiReadField(device->devHalInfo, configStatus4Addr, &configStatus4, 0x01, 0);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    *framerStatus = (configStatus4 << 6) | (configStatus3 << 5) | (syncStatus << 2) | sysrefStatus;

    return (uint32_t)retVal;
}

uint32_t TALISE_readDeframerStatus(taliseDevice_t *device, taliseDeframerSel_t deframerSel, uint16_t *deframerStatus)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t deframerOffset = 0;
    uint16_t configStatus3Addr = TALISE_ADDR_JESD_DEFRAMER_CFG3_0;
    uint8_t configStatus3 = 0;
    uint8_t eventObs = 0;
    static const uint8_t INVALIDCFG_STS_MIN_SUPPORTED_SIREV = 0xC0;

#if TALISE_VERBOSE
    talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_readDeframerStatus()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (deframerSel == TAL_DEFRAMER_A)
    {
        deframerOffset = 0;
    }
    else if (deframerSel == TAL_DEFRAMER_B)
    {
        deframerOffset = TALISE_JESD_DEFRAMERB_OFFSET;
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFSTATUS_INV_DEFRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (deframerStatus == NULL)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_DEFSTATUS_NULL_DEFRAMERSTATUS_PARAM, retVal, TALACT_ERR_CHECK_PARAM);

    }

    halError = talSpiReadByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_EVENT_OBS_0 + deframerOffset), &eventObs);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    if(device->devStateInfo.deviceSiRev >= INVALIDCFG_STS_MIN_SUPPORTED_SIREV)
    {
        halError = ADIHAL_spiReadField(device->devHalInfo, (configStatus3Addr + deframerOffset), &configStatus3, 0x01, 0);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    *deframerStatus = ((configStatus3 << 8) | eventObs);

    return (uint32_t)retVal;
}

static talRecoveryActions_t talCheckDacSampleXbarSelectEnum (taliseDevice_t *device, taliseDacSampleXbarSelect_t lane)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    if ((lane != TAL_DEFRAMERA_OUT0) && (lane != TAL_DEFRAMERA_OUT1) &&
        (lane != TAL_DEFRAMERA_OUT2) && (lane != TAL_DEFRAMERA_OUT3) &&
        (lane != TAL_DEFRAMERB_OUT0) && (lane != TAL_DEFRAMERB_OUT1) &&
        (lane != TAL_DEFRAMERB_OUT2) && (lane != TAL_DEFRAMERB_OUT3))
    {
        return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_INV_DAC_SAMP_XBAR_SELECT_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }
    return retVal;
}

uint32_t TALISE_setupDacSampleXbar(taliseDevice_t *device, taliseTxChannels_t channelSel, taliseDacSampleXbar_t dacXbar)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t channelAddr = 0;
    uint8_t xbarReg = 0;
    static const uint8_t CONV_MASK = 0x07;
    static const uint8_t CONV_POS  = 0x4;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setupDacSampleXbar()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    /* performing Tx channel selection check */
    switch (channelSel)
    {
        case TAL_TX1:
            channelAddr = TALISE_ADDR_JESD_DEFRAMER_CH1_SAMPLE_XBAR;
            break;
        case TAL_TX2:
            channelAddr = TALISE_ADDR_JESD_DEFRAMER_CH2_SAMPLE_XBAR;
            break;
        default:
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_INV_DAC_SAMP_XBAR_CHANNEL_SEL, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Check Crossbar for valid settings */
    retVal = talCheckDacSampleXbarSelectEnum (device, dacXbar.dacChanI);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckDacSampleXbarSelectEnum (device, dacXbar.dacChanQ);
    IF_ERR_RETURN_U32(retVal);

    /* setting the DAC sample crossbar */
    xbarReg = (((uint8_t)dacXbar.dacChanI) & CONV_MASK) | ((((uint8_t)dacXbar.dacChanQ) & CONV_MASK) << CONV_POS);
    halError = talSpiWriteByte(device->devHalInfo, channelAddr, xbarReg);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

static talRecoveryActions_t talCheckAdcSampleXbarSelectEnum (taliseDevice_t *device, taliseAdcSampleXbarSelect_t conv)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    if ((conv != TAL_ADC_RX1_I) &&
        (conv != TAL_ADC_RX1_Q) &&
        (conv != TAL_ADC_RX2_I) &&
        (conv != TAL_ADC_RX2_Q) &&
        (conv != TAL_ADC_DUALBAND_RX1_BAND_A_I) &&
        (conv != TAL_ADC_DUALBAND_RX1_BAND_A_Q) &&
        (conv != TAL_ADC_DUALBAND_RX2_BAND_A_I) &&
        (conv != TAL_ADC_DUALBAND_RX2_BAND_A_Q) &&
        (conv != TAL_ADC_DUALBAND_RX1_BAND_B_I) &&
        (conv != TAL_ADC_DUALBAND_RX1_BAND_B_Q) &&
        (conv != TAL_ADC_DUALBAND_RX2_BAND_B_I) &&
        (conv != TAL_ADC_DUALBAND_RX2_BAND_B_Q))
    {
        return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_INV_ADC_SAMP_XBAR_SELECT_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }
    return retVal;
}

uint32_t TALISE_setupAdcSampleXbar(taliseDevice_t *device, taliseFramerSel_t framerSel, taliseAdcSampleXbar_t adcXbar)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t framerOffset = 0;
    uint8_t xbarReg = 0;
    static const uint8_t CONV_MASK = 0x07;
    static const uint8_t CONV_POS  = 0x3;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setupAdcSampleXbar()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    switch (framerSel)
    {
        case TAL_FRAMER_A:
            framerOffset = 0;
            break;
        case TAL_FRAMER_B:
            framerOffset = TALISE_JESD_FRAMERB_OFFSET;
            break;
        default:
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                    TAL_ERR_INV_ADC_SAMP_XBAR_FRAMER_SEL, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Check Crossbar for valid settings */
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv0);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv1);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv2);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv3);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv4);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv5);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv6);
    IF_ERR_RETURN_U32(retVal);
    retVal = talCheckAdcSampleXbarSelectEnum (device, adcXbar.conv7);
    IF_ERR_RETURN_U32(retVal);

    /* writing setting to the ADC sample crossbar */
    xbarReg = (((uint8_t)adcXbar.conv0) & CONV_MASK) | ((((uint8_t)adcXbar.conv1) & CONV_MASK) << CONV_POS);
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_01_0 + framerOffset), xbarReg);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    xbarReg = (((uint8_t)adcXbar.conv2) & CONV_MASK) | ((((uint8_t)adcXbar.conv3) & CONV_MASK) << CONV_POS);
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_23_0 + framerOffset), xbarReg);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    xbarReg = (((uint8_t)adcXbar.conv4) & CONV_MASK) | ((((uint8_t)adcXbar.conv5) & CONV_MASK) << CONV_POS);
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_45_0 + framerOffset), xbarReg);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    xbarReg = (((uint8_t)adcXbar.conv6) & CONV_MASK) | ((((uint8_t)adcXbar.conv7) & CONV_MASK) << CONV_POS);
    halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_SAMPLE_XBAR_67_0 + framerOffset), xbarReg);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_enableFramerTestData(taliseDevice_t *device, taliseFramerSel_t framerSelect, taliseFramerDataSource_t testDataSource, taliseFramerInjectPoint_t injectPoint)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_enableFramerTestData()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (testDataSource > TAL_FTD_RAMP)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_TESTDATA_SOURCE_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (injectPoint > TAL_FTD_POST_LANEMAP)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_INJECTPOINT_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((framerSelect != TAL_FRAMER_A) &&
        (framerSelect != TAL_FRAMER_B) &&
        (framerSelect != TAL_FRAMER_A_AND_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_INV_FRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if ((framerSelect == TAL_FRAMER_A) ||
        (framerSelect == TAL_FRAMER_A_AND_B))
    {
        halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_FRAMER_TEST_CFG_0, (uint8_t)((injectPoint << 4) | (testDataSource)));
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    if ((framerSelect == TAL_FRAMER_B) ||
        (framerSelect == TAL_FRAMER_A_AND_B))
    {
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_TEST_CFG_0 + TALISE_JESD_FRAMERB_OFFSET), (uint8_t)((injectPoint << 4) | (testDataSource)));
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_injectFramerTestDataError(taliseDevice_t *device, taliseFramerSel_t framerSelect)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t testDataInvertAddr = TALISE_ADDR_JESD_FRAMER_TEST_CFG_0;
    uint8_t readData = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_injectFramerTestDataError()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (framerSelect == TAL_FRAMER_A)
    {
        testDataInvertAddr = TALISE_ADDR_JESD_FRAMER_TEST_CFG_0;
    }
    else if (framerSelect == TAL_FRAMER_B)
    {
        testDataInvertAddr = (TALISE_ADDR_JESD_FRAMER_TEST_CFG_0 + TALISE_JESD_FRAMERB_OFFSET);
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMER_ERRINJECT_INV_FRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* reading current PRBS control register contents */
    halError = talSpiReadByte(device->devHalInfo, testDataInvertAddr, &readData);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* invert test data, then invert back to normal */
    halError = talSpiWriteByte(device->devHalInfo, testDataInvertAddr, (readData |= 0x40));
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteByte(device->devHalInfo, testDataInvertAddr, (readData &= ~0x40));
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_enableDeframerPrbsChecker(taliseDevice_t *device, taliseDeframerPrbsOrder_t polyOrder, taliseDefPrbsCheckLoc_t checkerLocation)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    talRecoveryActions_t retValWarn = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;


#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_enableDeframerPrbsChecker()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    retValWarn = retVal;

    if ((polyOrder >= TAL_PRBS_DISABLE) &&
        (polyOrder <= TAL_PRBS31) &&
        (checkerLocation >= TAL_PRBSCHECK_LANEDATA) &&
        (checkerLocation <= TAL_PRBSCHECK_SAMPLEDATA))
    {

        retVal = (talRecoveryActions_t)TALISE_clearDeframerPrbsCounters(device);
        IF_ERR_RETURN_U32(retVal);

        halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_PRBS_CFG, (uint8_t)((polyOrder << 2) | checkerLocation));
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }
    else
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                   TAL_ERR_EN_DEFRAMER_PRBS_INV_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* If higher priority retVal has no error, allow possible lower priority warning to be returned */
    if (retVal == TALACT_NO_ACTION)
    {
        retVal = retValWarn;
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_clearDeframerPrbsCounters(taliseDevice_t *device)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_clearDeframerPrbsCounters()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_PRBS_ERROR_FLAG, 0x00);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return (uint32_t)retVal;
}

uint32_t TALISE_readDeframerPrbsCounters(taliseDevice_t *device, uint8_t lane, uint8_t *prbsErrorCount, uint8_t *prbsInvertedStatus)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t prbsCheckLocation = 0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_readDeframerPrbsCounters()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (prbsErrorCount == NULL)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
            TAL_ERR_READDFRMPRBS_NULL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (prbsInvertedStatus == NULL)
     {
         return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
             TAL_ERR_READDFRMPRBS_NULL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
     }

    /* Read back deframer output 0 sample counter */
     halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_PRBS_CFG, &prbsCheckLocation);
     retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
     IF_ERR_RETURN_U32(retVal);

    /* Save Lane Data Inverted Status */
    *prbsInvertedStatus =  ((prbsCheckLocation & 0xF0) >> 4);

    /* Mask off the source bit */
    prbsCheckLocation = (prbsCheckLocation & 0x01);

    if (((taliseDefPrbsCheckLoc_t) prbsCheckLocation) == TAL_PRBSCHECK_SAMPLEDATA)
    {
        /* Write to update deframer output 0 sample counter */
        halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_SAMPLE_PRBS_ERROR_COUNT, 0);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        /* Read back deframer output 0 sample counter */
        halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_SAMPLE_PRBS_ERROR_COUNT, prbsErrorCount);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }
    else
    {
        /* Write PRBS error Count register to force prbs error count update for all 4 lanes */
        halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_PRBS_ERROR_COUNT0, 0);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        if (lane == 0)
        {
            halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_JESD_DEFRAMER_PRBS_ERROR_COUNT0, prbsErrorCount);
            retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
            IF_ERR_RETURN_U32(retVal);
        }
        else if (lane == 1)
        {
            halError = talSpiReadByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_PRBS_ERROR_COUNT1), prbsErrorCount);
            retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
            IF_ERR_RETURN_U32(retVal);
        }
        else if (lane == 2)
        {
            halError = talSpiReadByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_PRBS_ERROR_COUNT2), prbsErrorCount);
            retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
            IF_ERR_RETURN_U32(retVal);
        }
        else if (lane == 3)
        {
            halError = talSpiReadByte(device->devHalInfo, (TALISE_ADDR_JESD_DEFRAMER_PRBS_ERROR_COUNT3), prbsErrorCount);
            retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
            IF_ERR_RETURN_U32(retVal);
        }
        else
        {
            return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_READDFRMPRBS_INV_DEFSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
        }
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_getDfrmIlasMismatch(taliseDevice_t *device, taliseDeframerSel_t deframerSelect, uint32_t *mismatch, taliseJesd204bLane0Config_t *dfrmCfg, taliseJesd204bLane0Config_t *dfrmIlas)
{
    static const uint8_t LINK_ENABLE_MASK = 0x01;
    static const uint8_t JESD_SYNC_MASK   = 0x10;

    talRecoveryActions_t retVal = TALACT_NO_ACTION;     /* Local api error container                                             */
    adiHalErr_t halError = ADIHAL_OK;       /* Local arm error container                                             */
    uint16_t i = 0;                         /* Local loop counter                                                    */
    uint8_t ilasdata[15] = {0};             /* Local holds lane0 ilas configuration data                             */
    uint8_t cfgdata[15] = {0};              /* Local holds lane0 configuration data                                  */
    uint16_t zeroCheck = 0x0000;            /* Local used for or'ing to determine if lane configuration is all zeros */
    uint16_t ilasAddress = 0;               /* Local used to assemble ilas addresses on the fly                      */
    uint16_t cfgAddress = 0;                /* Local used to assemble cfg addresses on the fly                       */
    uint16_t syncbAddress = 0;              /* Local used to assemble syncB register addresses on the fly            */
    uint8_t syncRegister = 0;               /* Local holds contents of syncB register                                */
    uint16_t cfgAddrArray[15] = {0};        /* Local holds cfg addresses for spiReadBytes to fetch Cfg values        */
    uint16_t ilasAddrArray[15] = {0};       /* Local holds ilas addresses for spiReadBytes to fetch ILAS values      */
    taliseJesd204bLane0Config_t dfrmCfgLocal = {0}; /* Local deframer configuration settings                               */
    taliseJesd204bLane0Config_t dfrmIlasLocal = {0}; /* Local deframer Ilas settings                                       */

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getDfrmIlasMismatch()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if (mismatch == NULL)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_JESD204B_ILAS_MISMATCH_NULLPARAM, retVal, TALACT_ERR_CHECK_PARAM);        
    }

    *mismatch = 0;

    /* select the deframer to interrogate */
    if (deframerSelect == TAL_DEFRAMER_A)
    {
        ilasAddress = TALISE_ADDR_JESD_DEFRAMER_IP_OBS0_0;
        cfgAddress = TALISE_ADDR_JESD_DEFRAMER_L0_CFG0_0;
        syncbAddress = TALISE_ADDR_JESD_DEFRAMER_CFG_0;
    }
    else if (deframerSelect == TAL_DEFRAMER_B)
    {
        ilasAddress = TALISE_ADDR_JESD_DEFRAMER_IP_OBS0_1;
        cfgAddress = TALISE_ADDR_JESD_DEFRAMER_L0_CFG0_1;
        syncbAddress = TALISE_ADDR_JESD_DEFRAMER_CFG_1;
    }
    else
    {
        retVal = talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                  TAL_ERR_JESD204B_ILAS_MISMATCH_INVALID_DEFRAMER, retVal,
                                  TALACT_ERR_CHECK_PARAM);
        IF_ERR_RETURN_U32(retVal);
    }

    /* check the deframer for link enable and syncB active */
    halError = talSpiReadByte(device->devHalInfo, syncbAddress, &syncRegister);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    if ((syncRegister & LINK_ENABLE_MASK) == 0)
    {
        retVal = talApiErrHandler(device, TAL_ERRHDL_API_FAIL,
                                  TAL_ERR_JESD204B_ILAS_MISMATCH_NO_ACTIVE_LINK, retVal,
                                  TALACT_ERR_CHECK_PARAM);
        IF_ERR_RETURN_U32(retVal);
    }

    if ((syncRegister & JESD_SYNC_MASK) == 0)
    {
        retVal = talApiErrHandler(device, TAL_ERRHDL_API_FAIL,
                                  TAL_ERR_JESD204B_ILAS_MISMATCH_SYNC_NOT_DETECTED, retVal,
                                  TALACT_ERR_CHECK_PARAM);
        IF_ERR_RETURN_U32(retVal);
    }

    /* if parameter dfrmCfg is null allocation buffer */
    if (dfrmCfg == NULL)
    {
        dfrmCfg = &dfrmCfgLocal;
    }

    /* if parameter dfrmIlas is null allocation buffer */
    if (dfrmIlas == NULL)
    {
        dfrmIlas = &dfrmIlasLocal;
    }

    /* load the cfg and ilas address arrays */
    for (i = 0; i < 11; i++)
    {
        cfgAddrArray[i] = (cfgAddress + i);
        ilasAddrArray[i] = (ilasAddress + i);
    }

    cfgAddrArray[11] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS25_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS25_1;
    ilasAddrArray[11] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS13_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS13_1;

    cfgAddrArray[12] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS38_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS38_1;
    ilasAddrArray[12] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS35_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS35_1;

    cfgAddrArray[13] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS39_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS39_1;
    ilasAddrArray[13] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS36_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS36_1;

    cfgAddrArray[14] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS40_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS40_1;
    ilasAddrArray[14] = (deframerSelect == TAL_DEFRAMER_A) ? TALISE_ADDR_JESD_DEFRAMER_IP_OBS37_0 : TALISE_ADDR_JESD_DEFRAMER_IP_OBS37_1;

    for (i = 0; i < 15; i++)
    {
        /* fetch the ilas data items */
        halError = talSpiReadByte(device->devHalInfo, cfgAddrArray[i], &cfgdata[i]);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        /* fetch the cfg data items */
        halError = talSpiReadByte(device->devHalInfo, ilasAddrArray[i], &ilasdata[i]);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    /* do the zero check of ilas data items */
    zeroCheck = 0x0000;
    for (i = 0; i < 15; i++)
    {
        zeroCheck = zeroCheck | ilasdata[i];
    }

    /* If ILAS configuration is all zeros then lane0 is not running */
    if (zeroCheck == 0x0000)
    {
        retVal = talApiErrHandler(device, TAL_ERRHDL_API_FAIL,
                                  TAL_ERR_JESD204B_ILAS_MISMATCH_NO_ACTIVE_LINK, retVal,
                                  TALACT_ERR_CHECK_PARAM);
        IF_ERR_RETURN_U32(retVal);
    }

    /* loading the structures with the read values for easier reading when doing compares */
    dfrmIlas->DID = ilasdata[0];                 /* jesd_deframer_IP_obs0  */
    dfrmIlas->BID = (ilasdata[1] & 0x0F);        /* jesd_deframer_IP_obs1  */
    dfrmIlas->LID0 = (ilasdata[2] & 0x1F);       /* jesd_deframer_IP_obs2  */
    dfrmIlas->L = (ilasdata[3] & 0x1F);          /* jesd_deframer_IP_obs3  */
    dfrmIlas->SCR = ((ilasdata[3] & 0x80) >> 7); /* jesd_deframer_IP_obs3  */
    dfrmIlas->F = ilasdata[4];                   /* jesd_deframer_IP_obs4  */
    dfrmIlas->K = (ilasdata[5] & 0x1F);          /* jesd_deframer_IP_obs5  */
    dfrmIlas->M = ilasdata[6];                   /* jesd_deframer_IP_obs6  */
    dfrmIlas->N = (ilasdata[7] & 0x1F);          /* jesd_deframer_IP_obs7  */
    dfrmIlas->CS = ((ilasdata[7] & 0xC0) >> 6);  /* jesd_deframer_IP_obs7  */
    dfrmIlas->NP = (ilasdata[8] & 0x1F);         /* jesd_deframer_IP_obs8  */
    dfrmIlas->S = (ilasdata[9] & 0x1F);          /* jesd_deframer_IP_obs9  */
    dfrmIlas->CF = (ilasdata[10] & 0x1F);        /* jesd_deframer_IP_obs10 */
    dfrmIlas->HD = ((ilasdata[10] & 0x80) >> 7); /* jesd_deframer_IP_obs10 */
    dfrmIlas->FCHK0 = ilasdata[11];              /* lane0 Ilas CheckSum    */
    dfrmIlas->FCHK1 = ilasdata[12];              /* lane1 Ilas CheckSum    */
    dfrmIlas->FCHK2 = ilasdata[13];              /* lane2 Ilas CheckSum    */
    dfrmIlas->FCHK3 = ilasdata[14];              /* lane3 Ilas CheckSum    */


    dfrmCfg->DID = cfgdata[0];                  /* jesd_deframer_LO_cfg0       */
    dfrmCfg->BID = (cfgdata[1] & 0x0F);         /* jesd_deframer_LO_cfg1       */
    dfrmCfg->LID0 = (cfgdata[2] & 0x1F);        /* jesd_deframer_LO_cfg2       */
    dfrmCfg->L = (cfgdata[3] & 0x1F);           /* jesd_deframer_LO_cfg3       */
    dfrmCfg->SCR = ((cfgdata[3] & 0x80) >> 7);  /* jesd_deframer_LO_cfg3       */
    dfrmCfg->F = cfgdata[4];                    /* jesd_deframer_LO_cfg4       */
    dfrmCfg->K = (cfgdata[5] & 0x1F);           /* jesd_deframer_LO_cfg5       */
    dfrmCfg->M = cfgdata[6];                    /* jesd_deframer_LO_cfg6       */
    dfrmCfg->N = (cfgdata[7] & 0x1F);           /* jesd_deframer_LO_cfg7       */
    dfrmCfg->CS = ((cfgdata[7] & 0xC0) >> 6);   /* jesd_deframer_LO_cfg7       */
    dfrmCfg->NP = (cfgdata[8] & 0x1F);          /* jesd_deframer_LO_cfg8       */
    dfrmCfg->S = (cfgdata[9] & 0x1F);           /* jesd_deframer_LO_cfg9       */
    dfrmCfg->CF = (cfgdata[10] & 0x1F);         /* jesd_deframer_LO_cfg10      */
    dfrmCfg->HD = ((cfgdata[10] & 0x80) >> 7);  /* jesd_deframer_LO_cfg10      */
    dfrmCfg->FCHK0 = cfgdata[11];               /* lane0 Cfg Computed CheckSum */
    dfrmCfg->FCHK1 = cfgdata[12];               /* lane1 Cfg Computed CheckSum */
    dfrmCfg->FCHK2 = cfgdata[13];               /* lane2 Cfg Computed CheckSum */
    dfrmCfg->FCHK3 = cfgdata[14];               /* lane3 Cfg Computed CheckSum */


    /* performing ILAS mismatch check */
    *mismatch = 0x00000000;
    if (dfrmIlas->DID != dfrmCfg->DID)
    {
        *mismatch |= 0x00000001;
    }

    if (dfrmIlas->BID != dfrmCfg->BID)
    {
        *mismatch |= 0x00000002;
    }

    if (dfrmIlas->LID0 != dfrmCfg->LID0)
    {
        *mismatch |= 0x00000004;
    }

    if (dfrmIlas->L != dfrmCfg->L)
    {
        *mismatch |= 0x00000008;
    }

    if (dfrmIlas->SCR != dfrmCfg->SCR)
    {
        *mismatch |= 0x00000010;
    }

    if (dfrmIlas->F != dfrmCfg->F)
    {
        *mismatch |= 0x00000020;
    }

    if (dfrmIlas->K != dfrmCfg->K)
    {
        *mismatch |= 0x00000040;
    }

    if (dfrmIlas->M != dfrmCfg->M)
    {
        *mismatch |= 0x00000080;
    }

    if (dfrmIlas->N != dfrmCfg->N)
    {
        *mismatch |= 0x00000100;
    }

    if (dfrmIlas->CS != dfrmCfg->CS)
    {
        *mismatch |= 0x00000200;
    }

    if (dfrmIlas->NP != dfrmCfg->NP)
    {
        *mismatch |= 0x00000400;
    }

    if (dfrmIlas->S != dfrmCfg->S)
    {
        *mismatch |= 0x00000800;
    }

    if (dfrmIlas->CF != dfrmCfg->CF)
    {
        *mismatch |= 0x00001000;
    }

    if (dfrmIlas->HD != dfrmCfg->HD)
    {
        *mismatch |= 0x00002000;
    }

    /* verify lane ilas checksums equal lane computed checksums */
    for (i = 11; i < 15; i++)
    {
        /* if ilas checksum equal zero then the lane is inactive so suppress lane checksum mismatch flag */
        if ((ilasdata[i] != cfgdata[i]) && (ilasdata[i] != 0x00))
        {
            *mismatch |= (0x00004000 << (i - 11));

        }
    }

    return (uint32_t)retVal;
}

uint32_t TALISE_setDfrmIrqMask(taliseDevice_t *device, taliseDeframerSel_t deframerSelect, uint16_t irqMask)
{
    static const uint8_t ERROR_COUNTERS_ENABLE_MASK = 0x3F;
    static const uint8_t IRQ_BIT8_MASK = 0x80;

    uint8_t enCount = 0;
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t dataArray[2] = {0};
    uint16_t addrArray[2] = {0};

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setDfrmIrqMask()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    /* param range check */
    if ((deframerSelect != TAL_DEFRAMER_A) && (deframerSelect != TAL_DEFRAMER_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                          TAL_ERR_SETDFRMIRQMASK_INV_DEFRAMERSEL_PARAM, retVal,
                                          TALACT_ERR_CHECK_PARAM);
    }

    if (deframerSelect == TAL_DEFRAMER_A)
    {
        addrArray[0] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG2_0;
        addrArray[1] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_0;
    }
    else
    {
        addrArray[0] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG2_1;
        addrArray[1] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_1;
    }

    /* fetch the contents of the enable counters register where bit7 is IRQ[8:8] readmodifywrite operation*/
    halError = talSpiReadByte(device->devHalInfo, addrArray[1], &enCount);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    dataArray[0] = (uint8_t)irqMask;
    dataArray[1] = (enCount & ERROR_COUNTERS_ENABLE_MASK) | IRQ_BIT8_MASK; /* BIT8 CMM IRQ is disabled to correct BUG */

    halError = talSpiWriteBytes(device->devHalInfo, &addrArray[0], &dataArray[0], 2);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    return ((uint32_t)retVal);
}


uint32_t TALISE_getDfrmIrqMask(taliseDevice_t *device, taliseDeframerSel_t deframerSelect, uint16_t *irqMask)
{
    static const uint8_t IRQ_BIT8_MASK = 0x80;

    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint8_t dataArray[2] = {0};
    uint16_t addrArray[2] = {0};

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getDfrmIrqMask()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    /* param range check */
    if (irqMask == NULL)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                          TAL_ERR_GETDFRMIRQMASK_NULL_IRQMASK_PARAM, retVal,
                                          TALACT_ERR_CHECK_PARAM);
    }

    /* param range check */
    if ((deframerSelect != TAL_DEFRAMER_A) &&
        (deframerSelect != TAL_DEFRAMER_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                          TAL_ERR_GETDFRMIRQMASK_INV_DEFRAMERSELECT_PARAM, retVal,
                                          TALACT_ERR_CHECK_PARAM);
    }

    if (deframerSelect == TAL_DEFRAMER_A)
    {
        addrArray[0] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG2_0;
        addrArray[1] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_0;
    }
    else
    {
        addrArray[0] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG2_1;
        addrArray[1] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_1;
    }

    /* fetch IRQ mask low */
    halError = talSpiReadByte(device->devHalInfo, addrArray[0], &dataArray[0]);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* fetch IRQ mask high */
    halError = talSpiReadByte(device->devHalInfo, addrArray[1], &dataArray[1]);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    *irqMask = ((uint16_t)(dataArray[1] & IRQ_BIT8_MASK)) << 1 | ((uint16_t)dataArray[0]);

    return ((uint32_t)retVal);
}

uint32_t TALISE_getDfrmIrqSource(taliseDevice_t *device, taliseDeframerSel_t deframerSelect, uint16_t *irqSourceValue)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t irqVector[8] = {0};
    uint8_t dataArray[8] = {0};

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getDfrmIrqSource()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    /* param range check */
    if (irqSourceValue == NULL)
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                 TAL_ERR_GETDFRMIRQSRC_NULL_STATUS_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* param range check */
    if ((deframerSelect != TAL_DEFRAMER_A) &&
        (deframerSelect != TAL_DEFRAMER_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                   TAL_ERR_GETDFRMIRQSRC_INV_DEFRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    if (deframerSelect == TAL_DEFRAMER_A)
    {
        irqVector[0] = TALISE_ADDR_JESD_DEFRAMER_IP_OBS14_0;
        irqVector[1] = TALISE_ADDR_JESD_DEFRAMER_IP_OBS15_0;
        irqVector[2] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_DET_LAT_BUF_0;
        irqVector[3] = TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG2_0;
        irqVector[4] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE0;
        irqVector[5] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE1;
        irqVector[6] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE2;
        irqVector[7] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE3;
    }
    else
    {
        irqVector[0] = TALISE_ADDR_JESD_DEFRAMER_IP_OBS14_1;
        irqVector[1] = TALISE_ADDR_JESD_DEFRAMER_IP_OBS15_1;
        irqVector[2] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_DET_LAT_BUF_1;
        irqVector[3] = TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG2_1;
        irqVector[4] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE0;
        irqVector[5] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE1;
        irqVector[6] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE2;
        irqVector[7] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE3;
    }

    /* fetch IRQ sources */
    halError = talSpiReadBytes(device->devHalInfo, &irqVector[0], &dataArray[0], 8);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    *irqSourceValue = ((uint16_t)(dataArray[7] & 0x01) << 14) | (((uint16_t)(dataArray[6] & 0x01) << 13) |
                     (((uint16_t)(dataArray[5] & 0x01) << 12) | (((uint16_t)(dataArray[4] & 0x01) << 11) |
                     (((uint16_t)(dataArray[3] & 0x02) << 9) | (((uint16_t)(dataArray[2] & 0x01) << 9) |
                     (((uint16_t)(dataArray[1] & 0x01) << 8) | dataArray[0]))))));

    return((uint32_t)retVal);
}

uint32_t TALISE_clearDfrmIrq(taliseDevice_t *device, taliseDeframerSel_t deframerSelect)
{
    static const uint8_t IRQ_BIT8_MASK = 0x80;

    uint8_t enCount = 0;
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    talRecoveryActions_t retValWarn = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t irqVector[8] = {0};
    uint8_t dataArray[8] = {0};
    uint16_t irqMask = 0;
    int16_t i = 0;
    uint8_t irqSource = 0;
    uint16_t irqSourceAddr = TALISE_ADDR_JESD_DEFRAMER_IP_OBS14_0;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_clearDfrmIrq()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    retValWarn = retVal;

    /* param range check */
    if ((deframerSelect != TAL_DEFRAMER_A) &&
        (deframerSelect != TAL_DEFRAMER_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                          TAL_ERR_CLRDFRMIRQ_INV_DEFRAMERSEL_PARAM, retVal,
                                          TALACT_ERR_CHECK_PARAM);
    }

    if (deframerSelect == TAL_DEFRAMER_A)
    {
        irqVector[0] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG2_0;
        irqVector[1] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_0;
        irqVector[2] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_DET_LAT_BUF_0;
        irqVector[3] = TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG2_0;
        irqVector[4] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE0;
        irqVector[5] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE1;
        irqVector[6] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE2;
        irqVector[7] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE3;

        irqSourceAddr = TALISE_ADDR_JESD_DEFRAMER_IP_OBS14_0;
    }
    else
    {
        irqVector[0] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG2_1;
        irqVector[1] = TALISE_ADDR_JESD_DEFRAMER_IP_CFG3_1;
        irqVector[2] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_DET_LAT_BUF_1;
        irqVector[3] = TALISE_ADDR_JESD_DEFRAMER_SYSREF_CFG2_1;
        irqVector[4] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE0;
        irqVector[5] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE1;
        irqVector[6] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE2;
        irqVector[7] = TALISE_ADDR_JESD_DEFRAMER_PTR_DBG_LANE3;

        irqSourceAddr = TALISE_ADDR_JESD_DEFRAMER_IP_OBS14_1;
    }

    retVal = (talRecoveryActions_t)TALISE_getDfrmIrqMask(device, deframerSelect, &irqMask);
    IF_ERR_RETURN_U32(retVal);

    /* fetch the contents of the deframer IRQ source */
    halError = talSpiReadByte(device->devHalInfo, irqSourceAddr, &irqSource);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* fetch the contents of the enable counters register where bit7 is IRQ[8:8] readmodifywrite operation*/
    halError = talSpiReadByte(device->devHalInfo, irqVector[1], &enCount);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    dataArray[0] = ((~irqSource) & 0xFF);
    dataArray[1] = (enCount | IRQ_BIT8_MASK);

    /* Clear the IRQ[7:0] and IRQ[8:8] */
    halError = talSpiWriteBytes(device->devHalInfo, &irqVector[0], &dataArray[0], 2);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    halError = talSpiWriteField(device->devHalInfo, irqVector[3], dataArray[3], 0x02, 1);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* Clear the remain static IRQs */
    for (i = 4; i <= 7; i++)
    {
        if (dataArray[i] > 0)
        {
            halError = talSpiWriteByte(device->devHalInfo, irqVector[i], 0x00);
            retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
            IF_ERR_RETURN_U32(retVal);
        }
    }

    /* restore orignal irqmask */
    halError = talSpiWriteByte(device->devHalInfo, irqVector[0], (uint8_t)(irqMask & 0x00FF));
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* disable CMM IRQ */
    halError = talSpiWriteField(device->devHalInfo, irqVector[1], 1, IRQ_BIT8_MASK, 7);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN_U32(retVal);

    /* If higher priority retVal has no error, allow possible lower priority warning to be returned */
    if (retVal == TALACT_NO_ACTION)
    {
        retVal = retValWarn;
    }

    return ((uint32_t)retVal);
}

talRecoveryActions_t talFindDfrmrLaneCntErr(taliseDevice_t *device,  taliseDeframerSel_t deframer, int32_t *deframerInputsMask)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;

    uint8_t msByte = 0;
    uint8_t lsByte = 0;
    uint8_t cntrResetMask = 0;
    uint16_t deframerTcrAddress0 = 0;
    uint16_t deframerTcrAddress1 = 0;
    uint16_t deframerEcntRstAddress0 = 0;
    uint16_t deframerEcntRstAddress1 = 0;

    static const uint16_t ECNT_TCH_LANE0_MASK = 0x0007;
    static const uint16_t ECNT_TCH_LANE1_MASK = 0x0038;
    static const uint16_t ECNT_TCH_LANE2_MASK = 0x0007;
    static const uint16_t ECNT_TCH_LANE3_MASK = 0x0038;

    if (deframer == TAL_DEFRAMER_A)
    {
        deframerEcntRstAddress0 = TALISE_ADDR_JESD_DEFRAMER_IP_CFG5_0;
        deframerEcntRstAddress1 = TALISE_ADDR_JESD_DEFRAMER_IP_CFG6_0;
        deframerTcrAddress0 = TALISE_ADDR_JESD_DEFRAMER_IP_OBS23_0;
        deframerTcrAddress1 = TALISE_ADDR_JESD_DEFRAMER_IP_OBS24_0;

    }
    else if (deframer == TAL_DEFRAMER_B)
    {
        deframerEcntRstAddress0 = TALISE_ADDR_JESD_DEFRAMER_IP_CFG5_1;
        deframerEcntRstAddress1 = TALISE_ADDR_JESD_DEFRAMER_IP_CFG6_1;
        deframerTcrAddress0 = TALISE_ADDR_JESD_DEFRAMER_IP_OBS23_1;
        deframerTcrAddress1 = TALISE_ADDR_JESD_DEFRAMER_IP_OBS24_1;
    }
    else
    {
        return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                TAL_ERR_TALFINDDFRMRLANECNTERROR_INV_DEFRAMERSEL_PARAM, retVal,
                                TALACT_ERR_CHECK_PARAM);
    }

    if (deframerInputsMask == NULL)
    {
        return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                TAL_ERR_TALFINDDFRMRLANECNTERROR_NULL_PARAM, retVal,
                                TALACT_ERR_CHECK_PARAM);
    }

    /* Read the TCR registers */
    halError = talSpiReadByte(device->devHalInfo, deframerTcrAddress1, &msByte);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN(retVal);

    halError = talSpiReadByte(device->devHalInfo, deframerTcrAddress0, &lsByte);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN(retVal);

    /* Deframer input 0 */
    *deframerInputsMask = 0;
    cntrResetMask = (lsByte & ECNT_TCH_LANE0_MASK);
    if (cntrResetMask > 0)
    {
        *deframerInputsMask |= 0x01;
    }

    /* Deframer input 1 */
    cntrResetMask = (lsByte & ECNT_TCH_LANE1_MASK);
    if (cntrResetMask > 0)
    {
        *deframerInputsMask |= 0x02;
    }

    /* Deframer input 2 */
    cntrResetMask = (msByte & ECNT_TCH_LANE2_MASK);
    if (cntrResetMask > 0)
    {
        *deframerInputsMask |= 0x04;
    }

    /* Deframer input 3 */
    cntrResetMask = (msByte & ECNT_TCH_LANE3_MASK);
    if (cntrResetMask > 0)
    {
        *deframerInputsMask |= 0x08;
    }

    /* clear the error counter */
    halError = talSpiWriteByte(device->devHalInfo, deframerEcntRstAddress0, 0x00);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN(retVal);

    /* clear the error counter */
    halError = talSpiWriteByte(device->devHalInfo, deframerEcntRstAddress1, 0x00);
    retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN(retVal);

    return (retVal);
}

talRecoveryActions_t talFindDfrmrLaneErr(taliseDevice_t *device,  uint32_t dfrmErrAddress, uint8_t nibbleToUse, int32_t *deframerInputsMask)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;

    uint8_t dfrmErrMask = 0; /* 4 bits in either upper /lower nibble that describe the lanes an error occurred on */

    static const uint8_t HIGH = 1;

    if (deframerInputsMask == NULL)
    {
        return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                                TAL_ERR_TALFINDDFRMRLANEERROR_NULL_PARAM, retVal,
                                TALACT_ERR_CHECK_PARAM);
    }

    /* Read error flags from requested deframer register address */
    halError = talSpiReadByte(device->devHalInfo, dfrmErrAddress, &dfrmErrMask);
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
    IF_ERR_RETURN(retVal);

    if (nibbleToUse >= HIGH)
    {
        /* Grab lane error mask from upper 4 bits in each register */
        *deframerInputsMask = ((dfrmErrMask >> 4) & 0x0F);
    }
    else
    {
        /* Grab lane error mask from lower 4 bits in each register */
        *deframerInputsMask = (dfrmErrMask & 0x0F);
    }

    return (retVal);
}

uint32_t TALISE_framerSyncbToggle(taliseDevice_t *device, taliseFramerSel_t framerSel)
{
    talRecoveryActions_t retVal = TALACT_NO_ACTION;
    talRecoveryActions_t retValWarn = TALACT_NO_ACTION;
    adiHalErr_t halError = ADIHAL_OK;
    uint16_t framerAddrOffset = 0;
    uint8_t framerCfg0Value = 0;

    static const uint8_t FORCE_SYNCB_HIGH = 0x0C;
    static const uint8_t FORCE_SYNCB_LOW = 0x04;
    static const uint8_t FORCE_SYNCB_CLEAR_BITMASK = 0xF3;

#if TALISE_VERBOSE
    halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_framerSyncbToggle()\n");
    retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
#endif

    if ((framerSel != TAL_FRAMER_A) &&
        (framerSel != TAL_FRAMER_B) &&
        (framerSel != TAL_FRAMER_A_AND_B))
    {
        return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
                TAL_ERR_FRAMERSYSREFTOGGLE_INV_FRAMERSEL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
    }

    /* Save possible warning from logging until end of function */
    retValWarn = retVal;

    if ((framerSel == TAL_FRAMER_A) ||
        (framerSel == TAL_FRAMER_A_AND_B))
    {
        framerAddrOffset = 0;

        /* Perform Read/modify/write to prevent changing other bits in the register */
        halError = talSpiReadByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), &framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        framerCfg0Value &= FORCE_SYNCB_CLEAR_BITMASK; /* Clear bits [3:2] */
        framerCfg0Value |= FORCE_SYNCB_HIGH; /* Set reg [3:2] = b11 - force SYNCB high */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        framerCfg0Value &= FORCE_SYNCB_CLEAR_BITMASK; /* Clear bits [3:2] */
        framerCfg0Value |= FORCE_SYNCB_LOW; /* Set reg [3:2] = b01 - force SYNCB low */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        framerCfg0Value &= FORCE_SYNCB_CLEAR_BITMASK; /* Clear bits [3:2], Set reg [3:2] = b00 - disable force of SYNCB */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    if ((framerSel == TAL_FRAMER_B) ||
        (framerSel == TAL_FRAMER_A_AND_B))
    {
        framerAddrOffset = TALISE_JESD_FRAMERB_OFFSET;

        /* Perform Read/modify/write to prevent changing other bits in the register */
        halError = talSpiReadByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), &framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        framerCfg0Value &= FORCE_SYNCB_CLEAR_BITMASK; /* Clear bits [3:2] */
        framerCfg0Value |= FORCE_SYNCB_HIGH; /* Set reg [3:2] = b11 - force SYNCB high */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        framerCfg0Value &= FORCE_SYNCB_CLEAR_BITMASK; /* Clear bits [3:2] */
        framerCfg0Value |= FORCE_SYNCB_LOW; /* Set reg [3:2] = b01 - force SYNCB low */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);

        framerCfg0Value &= FORCE_SYNCB_CLEAR_BITMASK; /* Clear bits [3:2], Set reg [3:2] = b00 - disable force of SYNCB */
        halError = talSpiWriteByte(device->devHalInfo, (TALISE_ADDR_JESD_FRAMER_CFG_0 + framerAddrOffset), framerCfg0Value);
        retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
        IF_ERR_RETURN_U32(retVal);
    }

    /* If higher priority retVal has no error, allow possible lower priority warning to be returned */
    if (retVal == TALACT_NO_ACTION)
    {
        retVal = retValWarn;
    }

    return (uint32_t)retVal;
}