adi.h

Go to the documentation of this file.

/******************************************************************************
*  Filename:       adi.h
*  Revised:        2016-08-10 11:10:10 +0200 (Wed, 10 Aug 2016)
*  Revision:       46997
*
*  Description:    Defines and prototypes for the ADI master interface.
*
*  Copyright (c) 2015 - 2016, Texas Instruments Incorporated
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions are met:
*
*  1) Redistributions of source code must retain the above copyright notice,
*     this list of conditions and the following disclaimer.
*
*  2) Redistributions in binary form must reproduce the above copyright notice,
*     this list of conditions and the following disclaimer in the documentation
*     and/or other materials provided with the distribution.
*
*  3) Neither the name of the ORGANIZATION nor the names of its contributors may
*     be used to endorse or promote products derived from this software without
*     specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
*  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
*  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
*  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
*  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
*  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
*  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
*  POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/

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

#ifndef __ADI_H__
#define __ADI_H__

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif

#include <stdbool.h>
#include <stdint.h>
#include <inc/hw_types.h>
#include <inc/hw_uart.h>
#include <inc/hw_memmap.h>
#include <inc/hw_ints.h>
#include <inc/hw_adi.h>
#include <driverlib/debug.h>
#include <driverlib/ddi.h>

//*****************************************************************************
//
// Number of registers in the ADI slave
//
//*****************************************************************************
#define ADI_SLAVE_REGS      16


//*****************************************************************************
//
// Defines that is used to control the ADI slave and master
//
//*****************************************************************************
#define ADI_PROTECT         0x00000080
#define ADI_ACK             0x00000001
#define ADI_SYNC            0x00000000

//*****************************************************************************
//
// API Functions and prototypes
//
//*****************************************************************************

#ifdef DRIVERLIB_DEBUG
//*****************************************************************************
//
//
//*****************************************************************************
static bool
ADIBaseValid(uint32_t ui32Base)
{
    return(ui32Base == ADI2_BASE || ui32Base == ADI3_BASE ||
           ui32Base == AUX_ADI4_BASE);
}
#endif





//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI8RegWrite(uint32_t ui32Base, uint32_t ui32Reg, uint8_t ui8Val)
{
    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Write the value to the register.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32Reg, ui8Val, 1);
    } else {
        HWREGB(ui32Base + ui32Reg) = ui8Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI16RegWrite(uint32_t ui32Base, uint32_t ui32Reg,
              uint16_t ui16Val)
{
    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Write the value to the register.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + (ui32Reg & 0xFE), ui16Val, 2);
    } else {
        HWREGH(ui32Base + (ui32Reg & 0xFE)) = ui16Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI32RegWrite(uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Val)
{
    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Write the value to the register.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + (ui32Reg & 0xFC), ui32Val, 4);
    } else {
        HWREG(ui32Base + (ui32Reg & 0xFC)) = ui32Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
ADI8RegRead(uint32_t ui32Base, uint32_t ui32Reg)
{
    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Read the register and return the value.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        return AuxAdiDdiSafeRead(ui32Base + ui32Reg, 1);
    } else {
        return(HWREGB(ui32Base + ui32Reg));
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
ADI16RegRead(uint32_t ui32Base, uint32_t ui32Reg)
{
    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Read the registers and return the value.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        return AuxAdiDdiSafeRead(ui32Base + (ui32Reg & 0xFE), 2);
    } else {
        return(HWREGH(ui32Base + (ui32Reg & 0xFE)));
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t
ADI32RegRead(uint32_t ui32Base, uint32_t ui32Reg)
{
    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Read the registers and return the value.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        return AuxAdiDdiSafeRead(ui32Base + (ui32Reg & 0xFC), 4);
    } else {
        return(HWREG(ui32Base + (ui32Reg & 0xFC)));
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI8BitsSet(uint32_t ui32Base, uint32_t ui32Reg, uint8_t ui8Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_SET;

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset + ui32Reg, ui8Val, 1);
    } else {
        HWREGB(ui32Base + ui32RegOffset + ui32Reg) = ui8Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI16BitsSet(uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_SET;

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset + (ui32Reg & 0xFE), ui16Val, 2);
    } else {
        HWREGH(ui32Base + ui32RegOffset + (ui32Reg & 0xFE)) = ui16Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI32BitsSet(uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_SET;

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset + (ui32Reg & 0xFC), ui32Val, 4);
    } else {
        HWREG(ui32Base + ui32RegOffset + (ui32Reg & 0xFC)) = ui32Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI8BitsClear(uint32_t ui32Base, uint32_t ui32Reg, uint8_t ui8Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_CLR;

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset + ui32Reg, ui8Val, 1);
    } else {
        HWREGB(ui32Base + ui32RegOffset + ui32Reg) = ui8Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI16BitsClear(uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_CLR;

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset + (ui32Reg & 0xFE), ui16Val, 2);
    } else {
        HWREGH(ui32Base + ui32RegOffset + (ui32Reg & 0xFE)) = ui16Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI32BitsClear(uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_CLR;

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset + (ui32Reg & 0xFC), ui32Val, 4);
    } else {
        HWREG(ui32Base + ui32RegOffset + (ui32Reg & 0xFC)) = ui32Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI4SetValBit(uint32_t ui32Base, uint32_t ui32Reg, bool bWriteHigh,
              uint8_t ui8Mask, uint8_t ui8Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);
    ASSERT(!(ui8Val & 0xF0));
    ASSERT(!(ui8Mask & 0xF0));

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_MASK4B + (ui32Reg << 1) + (bWriteHigh ? 1 : 0);

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset, (ui8Mask << 4) | ui8Val, 1);
    } else {
        HWREGB(ui32Base + ui32RegOffset) = (ui8Mask << 4) | ui8Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI8SetValBit(uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Mask,
              uint16_t ui16Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);
    ASSERT(!(ui16Val & 0xFF00));
    ASSERT(!(ui16Mask & 0xFF00));

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_MASK8B + (ui32Reg << 1);

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset, (ui16Mask << 8) | ui16Val, 2);
    } else {
        HWREGH(ui32Base + ui32RegOffset) = (ui16Mask << 8) | ui16Val;
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void
ADI16SetValBit(uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Mask,
               uint32_t ui32Val)
{
    uint32_t ui32RegOffset;

    //
    // Check the arguments.
    //
    ASSERT(ADIBaseValid(ui32Base));
    ASSERT(ui32Reg < ADI_SLAVE_REGS);
    ASSERT(!(ui32Val & 0xFFFF0000));
    ASSERT(!(ui32Mask & 0xFFFF0000));

    //
    // Get the correct address of the first register used for setting bits
    // in the ADI slave.
    //
    ui32RegOffset = ADI_O_MASK16B + ((ui32Reg << 1) & 0xFC);

    //
    // Set the selected bits.
    //
    if (ui32Base==AUX_ADI4_BASE) {
        AuxAdiDdiSafeWrite(ui32Base + ui32RegOffset, (ui32Mask << 16) | ui32Val, 4);
    } else {
        HWREG(ui32Base + ui32RegOffset) = (ui32Mask << 16) | ui32Val;
    }
}

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

#endif //  __ADI_H__

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