[adi.h] Analog to Digital Interface

Functions
static void	ADI8RegWrite (uint32_t ui32Base, uint32_t ui32Reg, uint8_t ui8Val)
	Write an 8 bit value to a register in an ADI slave. More...
static void	ADI16RegWrite (uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Val)
	Write a 16 bit value to 2 registers in the ADI slave. More...
static void	ADI32RegWrite (uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Val)
	Write a 32 bit value to 4 registers in the ADI slave. More...
static uint32_t	ADI8RegRead (uint32_t ui32Base, uint32_t ui32Reg)
	Read the value of an 8 bit register in the ADI slave. More...
static uint32_t	ADI16RegRead (uint32_t ui32Base, uint32_t ui32Reg)
	Read the value in a 16 bit register. More...
static uint32_t	ADI32RegRead (uint32_t ui32Base, uint32_t ui32Reg)
	Read the value in a 32 bit register. More...
static void	ADI8BitsSet (uint32_t ui32Base, uint32_t ui32Reg, uint8_t ui8Val)
	Set specific bits in a single 8 bit ADI register. More...
static void	ADI16BitsSet (uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Val)
	Set specific bits in 2 x 8 bit ADI slave registers. More...
static void	ADI32BitsSet (uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Val)
	Set specific bits in 4 x 8 bit ADI slave registers. More...
static void	ADI8BitsClear (uint32_t ui32Base, uint32_t ui32Reg, uint8_t ui8Val)
	Clear specific bits in an 8 bit ADI register. More...
static void	ADI16BitsClear (uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Val)
	Clear specific bits in two 8 bit ADI register. More...
static void	ADI32BitsClear (uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Val)
	Clear specific bits in four 8 bit ADI register. More...
static void	ADI4SetValBit (uint32_t ui32Base, uint32_t ui32Reg, bool bWriteHigh, uint8_t ui8Mask, uint8_t ui8Val)
	Set a value on any 4 bits inside an 8 bit register in the ADI slave. More...
static void	ADI8SetValBit (uint32_t ui32Base, uint32_t ui32Reg, uint16_t ui16Mask, uint16_t ui16Val)
	Set a value on any bits inside an 8 bit register in the ADI slave. More...
static void	ADI16SetValBit (uint32_t ui32Base, uint32_t ui32Reg, uint32_t ui32Mask, uint32_t ui32Val)
	Set a value on any bits inside an 2 x 8 bit register aligned on a half-word (byte) boundary in the ADI slave. More...
void	SafeHapiVoid (FPTR_VOID_VOID_T fPtr)
void	SafeHapiAuxAdiSelect (FPTR_VOID_UINT8_T fPtr, uint8_t ut8Signal)

Detailed Description

Introduction

API

The API functions can be grouped like this:

Write:

• Direct (all bits):
  • ADI8RegWrite()
  • ADI16RegWrite()
  • ADI32RegWrite()
• Set individual bits:
  • ADI8BitsSet()
  • ADI16BitsSet()
  • ADI32BitsSet()
• Clear individual bits:
  • ADI8BitsClear()
  • ADI16BitsClear()
  • ADI32BitsClear()
• Masked:
  • ADI4SetValBit()
  • ADI8SetValBit()
  • ADI16SetValBit()

Read:

• ADI8RegRead()
• ADI16RegRead()
• ADI32RegRead()

Function Documentation

static void ADI16BitsClear ( uint32_t  ui32Base, uint32_t  ui32Reg, uint16_t  ui16Val  )

inlinestatic

Clear specific bits in two 8 bit ADI register.

This function will clear bits in 2 registers in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned, but arranged in chunks of 32 bits. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7 etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. This function is used to clear bits in 2 consecutive 8 bit registers in the ADI slave. Only bits in the selected registers are affected by the operation.

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the base registers to clear the bits in.
ui16Val	is the 16 bit one-hot encoded value specifying which bits to clear in the registers.

Returns

None

See also

ADI8BitsClear(), ADI32BitsClear()

{
    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;
    }
}

Here is the call graph for this function:

static void ADI16BitsSet ( uint32_t  ui32Base, uint32_t  ui32Reg, uint16_t  ui16Val  )

inlinestatic

Set specific bits in 2 x 8 bit ADI slave registers.

This function will set bits in 2 registers in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned, but arranged in chunks of 32 bits. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7 etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. This function is used to set bits in 2 consecutive 8 bit registers in the ADI slave. Only bits in the selected registers are affected by the operation.

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the base register to assert the bits in.
ui16Val	is the 16 bit one-hot encoded value specifying which bits to set in the registers.

Returns

None

See also

ADI8BitsSet(), ADI32BitsSet()

{
    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;
    }
}

Here is the call graph for this function:

static uint32_t ADI16RegRead ( uint32_t  ui32Base, uint32_t  ui32Reg  )

inlinestatic

Read the value in a 16 bit register.

This function will read 2 x 8 bit registers in the analog domain and return the value as the lower 16 bits of an uint32_t. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7, etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

The byte addressing bit will be ignored, to ensure 16 bit access to the ADI slave.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the 16 bit register to read.

Returns

Returns the 16 bit value of the 2 analog register in the 2 least significant bytes of the uint32_t.

See also

ADI8RegRead(), ADI32RegRead()

{
    // 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)));
    }
}

Here is the call graph for this function:

static void ADI16RegWrite ( uint32_t  ui32Base, uint32_t  ui32Reg, uint16_t  ui16Val  )

inlinestatic

Write a 16 bit value to 2 registers in the ADI slave.

This function will write a value to 2 consecutive registers in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7, etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

The byte addressing bit will be ignored, to ensure 16 bit access to the ADI slave.

This operation is write only for the specified register. No previous value of the register will be kept (i.e. this is NOT read-modify-write on the register).

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the register to write.
ui16Val	is the 16 bit value to write to the register.

Returns

None

See also

ADI8RegWrite(), ADI32RegWrite()

{
    // 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;
    }
}

Here is the call graph for this function:

static void ADI16SetValBit ( uint32_t  ui32Base, uint32_t  ui32Reg, uint32_t  ui32Mask, uint32_t  ui32Val  )

inlinestatic

Set a value on any bits inside an 2 x 8 bit register aligned on a half-word (byte) boundary in the ADI slave.

This function allows 2 byte (16 bit) access to the ADI slave registers.

Use this function to write any value in the range 0-15 bits aligned on a half-word (byte) boundary. Fx. for writing the value 0b101 to bits 1 and 3 the ui32Val = 0x000A and the ui32Mask = 0x000E. Bits 0 and 5-15 will not be affected by the operation, as the corresponding bits are not set in the ui32Mask.

Note

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is the base address of the ADI port.
ui32Reg	is the Least Significant Register in the ADI slave that will be affected by the write operation.
ui32Mask	is the mask defining which of the 16 bit that should be overwritten. The mask must be defined in the lower half of the 32 bits.
ui32Val	is the value to write. The value must be defined in the lower half of the 32 bits.

Returns

None

See also

ADI4SetValBit(), ADI8SetValBit()

{
    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;
    }
}

Here is the call graph for this function:

static void ADI32BitsClear ( uint32_t  ui32Base, uint32_t  ui32Reg, uint32_t  ui32Val  )

inlinestatic

Clear specific bits in four 8 bit ADI register.

This function will clear bits in 4 registers in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned, but arranged in chunks of 32 bits. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7 etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. This function is used to clear bits in 4 consecutive 8 bit registers in the ADI slave. Only bits in the selected registers are affected by the operation.

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the base registers to clear the bits in.
ui32Val	is the 32 bit one-hot encoded value specifying which bits to clear in the registers.

Returns

None

See also

ADI8BitsClear(), ADI16BitsClear()

{
    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;
    }
}

Here is the call graph for this function:

static void ADI32BitsSet ( uint32_t  ui32Base, uint32_t  ui32Reg, uint32_t  ui32Val  )

inlinestatic

Set specific bits in 4 x 8 bit ADI slave registers.

This function will set bits in 4 registers in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned, but arranged in chunks of 32 bits. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7 etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. This function is used to set bits in 4 consecutive 8 bit registers in the ADI slave. Only bits in the selected registers are affected by the operation.

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the base register to assert the bits in.
ui32Val	is the 32 bit one-hot encoded value specifying which bits to set in the registers.

Returns

None

See also

ADI8BitsSet(), ADI16BitsSet()

{
    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;
    }
}

Here is the call graph for this function:

static uint32_t ADI32RegRead ( uint32_t  ui32Base, uint32_t  ui32Reg  )

inlinestatic

Read the value in a 32 bit register.

This function will read 4 x 8 bit registers in the analog domain and return the value as an uint32_t. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7, etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

The byte and half word addressing bits will be ignored, to ensure 32 bit access to the ADI slave.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the 32 bit register to read.

Returns

Returns the 32 bit value of the 4 analog registers.

See also

ADI8RegRead(), ADI16RegRead()

{
    // 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)));
    }
}

Here is the call graph for this function:

static void ADI32RegWrite ( uint32_t  ui32Base, uint32_t  ui32Reg, uint32_t  ui32Val  )

inlinestatic

Write a 32 bit value to 4 registers in the ADI slave.

This function will write a value to 4 consecutive registers in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7, etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

The byte and half word addressing bits will be ignored, to ensure 32 bit access to the ADI slave.

This operation is write only for the specified register. No previous value of the register will be kept (i.e. this is NOT read-modify-write on the register).

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the register to write.
ui32Val	is the 32 bit value to write to the register.

Returns

None

See also

ADI8RegWrite(), ADI16RegWrite()

{
    // 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;
    }
}

Here is the call graph for this function:

static void ADI4SetValBit ( uint32_t  ui32Base, uint32_t  ui32Reg, bool  bWriteHigh, uint8_t  ui8Mask, uint8_t  ui8Val  )

inlinestatic

Set a value on any 4 bits inside an 8 bit register in the ADI slave.

This function allows halfbyte (4 bit) access to the ADI slave registers. The parameter bWriteHigh determines whether to write to the lower or higher part of the 8 bit register.

Use this function to write any value in the range 0-3 bits aligned on a half byte boundary. Fx. for writing the value 0b101 to bits 1 to 3 the ui8Val = 0xA and the ui8Mask = 0xE. Bit 0 will not be affected by the operation, as the corresponding bit is not set in the ui8Mask.

Note

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is the base address of the ADI port.
ui32Reg	is the Least Significant Register in the ADI slave that will be affected by the write operation.
bWriteHigh	defines which part of the register to write in. true: Write upper half byte of register. false: Write lower half byte of register.
ui8Mask	is the mask defining which of the 4 bits that should be overwritten. The mask must be defined in the lower half of the 8 bits of the parameter.
ui8Val	is the value to write. The value must be defined in the lower half of the 8 bits of the parameter.

Returns

None

See also

ADI8SetValBit(), ADI16SetValBit

{
    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;
    }
}

Here is the call graph for this function:

static void ADI8BitsClear ( uint32_t  ui32Base, uint32_t  ui32Reg, uint8_t  ui8Val  )

inlinestatic

Clear specific bits in an 8 bit ADI register.

This function will clear bits in a register in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned, but arranged in chunks of 32 bits. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7 etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. This function is used to clear bits in a specific 8 bit register in the ADI slave. Only bits in the selected register are affected by the operation.

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the base registers to clear the bits in.
ui8Val	is the 8 bit one-hot encoded value specifying which bits to clear in the register.

Returns

None

See also

ADI16BitsClear(), ADI32BitsClear()

Referenced by AUXADCDisable().

{
    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;
    }
}

Here is the call graph for this function:

static void ADI8BitsSet ( uint32_t  ui32Base, uint32_t  ui32Reg, uint8_t  ui8Val  )

inlinestatic

Set specific bits in a single 8 bit ADI register.

This function will set bits in a single register in the analog domain. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned, but arranged in chunks of 32 bits. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7 etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. This function is used to set bits in a specific 8 bit register in the ADI slave. Only bits in the selected register are affected by the operation.

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the base register to assert the bits in.
ui8Val	is the 8 bit one-hot encoded value specifying which bits to set in the register.

Returns

None

See also

ADI16BitsSet(), ADI32BitsSet()

Referenced by AUXADCDisableInputScaling(), AUXADCEnableAsync(), and AUXADCEnableSync().

{
    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;
    }
}

Here is the call graph for this function:

static uint32_t ADI8RegRead ( uint32_t  ui32Base, uint32_t  ui32Reg  )

inlinestatic

Read the value of an 8 bit register in the ADI slave.

This function will read an 8 bit register in the analog domain and return the value as the lower 8 bits of an uint32_t. The access to the registers in the analog domain is either 8, 16 or 32 bit aligned. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7, etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the 8 bit register to read.

Returns

Returns the 8 bit value of the analog register in the least significant byte of the uint32_t.

See also

ADI16RegRead(), ADI32RegRead()

{
    // 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));
    }
}

Here is the call graph for this function:

static void ADI8RegWrite ( uint32_t  ui32Base, uint32_t  ui32Reg, uint8_t  ui8Val  )

inlinestatic

Write an 8 bit value to a register in an ADI slave.

This function will write a value to a single register in the analog domain. The access to the registers in the analog domain is either 8, 16, or 32 bit aligned. You can only do 16 bit access on registers 0-1 / 2-3, etc. Similarly 32 bit accesses are always performed on register 0-3 / 4-7, etc. Addresses for the registers and values being written to the registers will be truncated according to this access scheme.

Note

This operation is write only for the specified register. No previous value of the register will be kept (i.e. this is NOT read-modify-write on the register).

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is ADI base address.
ui32Reg	is the register to write.
ui8Val	is the 8 bit value to write to the register.

Returns

None

See also

ADI16RegWrite(), ADI32RegWrite()

{
    // 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;
    }
}

Here is the call graph for this function:

static void ADI8SetValBit ( uint32_t  ui32Base, uint32_t  ui32Reg, uint16_t  ui16Mask, uint16_t  ui16Val  )

inlinestatic

Set a value on any bits inside an 8 bit register in the ADI slave.

This function allows byte (8 bit) access to the ADI slave registers.

Use this function to write any value in the range 0-7 bits aligned on a byte boundary. Fx. for writing the value 0b101 to bits 1 and 3 the ui16Val = 0x0A and the ui16Mask = 0x0E. Bits 0 and 5-7 will not be affected by the operation, as the corresponding bits are not set in the ui16Mask.

Note

AUX_ADI4_BASE : Both the AUX module and the clock for the AUX SMPH module must be enabled before calling this function.

Parameters

ui32Base	is the base address of the ADI port.
ui32Reg	is the Least Significant Register in the ADI slave that will be affected by the write operation.
ui16Mask	is the mask defining which of the 8 bit that should be overwritten. The mask must be defined in the lower half of the 16 bits.
ui16Val	is the value to write. The value must be defined in the lower half of the 16 bits.

Returns

None

See also

ADI4SetValBit(), ADI16SetValBit()

{
    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;
    }
}

Here is the call graph for this function:

void SafeHapiAuxAdiSelect	(	FPTR_VOID_UINT8_T	fPtr,
		uint8_t	ut8Signal
	)

{
    bool bIrqEnabled = ( ! CPUcpsid() );
    while ( ! HWREG( AUX_SMPH_BASE + AUX_SMPH_O_SMPH0 ));
    fPtr( ut8Signal );
    HWREG( AUX_SMPH_BASE + AUX_SMPH_O_SMPH0 ) = 1;
    if ( bIrqEnabled ) {
        CPUcpsie();
    }
}

void SafeHapiVoid

(

FPTR_VOID_VOID_T

fPtr

)

{
    bool bIrqEnabled = ( ! CPUcpsid() );
    while ( ! HWREG( AUX_SMPH_BASE + AUX_SMPH_O_SMPH0 ));
    fPtr();
    HWREG( AUX_SMPH_BASE + AUX_SMPH_O_SMPH0 ) = 1;
    if ( bIrqEnabled ) {
        CPUcpsie();
    }
}

Macro Definition Documentation

#define ADI_ACK   0x00000001

#define ADI_PROTECT   0x00000080

#define ADI_SLAVE_REGS   16

Referenced by ADI16BitsClear(), ADI16BitsSet(), ADI16RegRead(), ADI16RegWrite(), ADI16SetValBit(), ADI32BitsClear(), ADI32BitsSet(), ADI32RegRead(), ADI32RegWrite(), ADI4SetValBit(), ADI8BitsClear(), ADI8BitsSet(), ADI8RegRead(), ADI8RegWrite(), and ADI8SetValBit().

#define ADI_SYNC   0x00000000