dac/v0/dac.h

Go to the documentation of this file.

/*
 * Copyright (C) 2021 Texas Instruments Incorporated
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 *   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.
 *
 *   Neither the name of Texas Instruments Incorporated 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
 * OWNER 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 DAC_V0_H_
#define DAC_V0_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 <drivers/hw_include/hw_types.h>
#include <drivers/hw_include/cslr_soc.h>
#include <kernel/dpl/DebugP.h>
#include <drivers/hw_include/cslr_dac.h>
 
//*****************************************************************************
//
// The following are defines for the reg parameter of the
// DAC_lockRegister() and DAC_isRegisterLocked() functions.
//
//*****************************************************************************
#define DAC_LOCK_CONTROL  (0x1U)  
#define DAC_LOCK_SHADOW  (0x2U)  
#define DAC_LOCK_OUTPUT  (0x4U)  
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    DAC_REF_VREF = 0,  
    DAC_REF_VDDA = 1  
}DAC_ReferenceVoltage;
 
//*****************************************************************************
//
//
//*****************************************************************************
typedef enum
{
    DAC_LOAD_SYSCLK = 0,  
    DAC_LOAD_PWMSYNC = 4  
}DAC_LoadMode;
 
//*****************************************************************************
//
// Defines used by the driver
//
//*****************************************************************************
#define DAC_REG_BYTE_MASK  (0xFFU)  
#define DAC_LOCK_KEY  (0xA000U)  
 
//*****************************************************************************
//
// Prototypes for the APIs.
//
//*****************************************************************************
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
DAC_getRevision(uint32_t base)
{
    //
    // Get the revision value.
    //
    return(HW_RD_REG16(base + CSL_DAC_DACREV) & CSL_DAC_DACREV_REV_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_setReferenceVoltage(uint32_t base, DAC_ReferenceVoltage source)
{
    //
    // Set the reference  voltage
    //
    HW_WR_REG16(base + CSL_DAC_DACCTL,
        ((HW_RD_REG16(base + CSL_DAC_DACCTL) &
        ~CSL_DAC_DACCTL_DACREFSEL_MASK) | (uint16_t)source));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_setLoadMode(uint32_t base, DAC_LoadMode mode)
{
    //
    // Set the load mode
    //
    HW_WR_REG16(base + CSL_DAC_DACCTL,
        ((HW_RD_REG16(base + CSL_DAC_DACCTL) &
        ~CSL_DAC_DACCTL_LOADMODE_MASK) | (uint16_t)mode));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_setPWMSyncSignal(uint32_t base, uint16_t signal)
{
    //
    // Check the arguments.
    //
    DebugP_assert((signal > 0U) && (signal < 33U));
 
    //
    // Set the PWM sync signal
    //
    HW_WR_REG16(base + CSL_DAC_DACCTL,
        ((HW_RD_REG16(base + CSL_DAC_DACCTL) &
        ~CSL_DAC_DACCTL_SYNCSEL_MASK) |
        ((uint16_t)(signal - 1U) << CSL_DAC_DACCTL_SYNCSEL_SHIFT)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
DAC_getActiveValue(uint32_t base)
{
    //
    // Get the active value
    //
    return(HW_RD_REG16(base + CSL_DAC_DACVALA) & CSL_DAC_DACVALA_DACVALA_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_setShadowValue(uint32_t base, uint16_t value)
{
    //
    // Check the arguments.
    //
    DebugP_assert(value <= CSL_DAC_DACVALS_DACVALS_MASK);
 
    //
    // Set the shadow value
    //
    HW_WR_REG16(base + CSL_DAC_DACVALS,
        ((HW_RD_REG16(base + CSL_DAC_DACVALS) &
        ~CSL_DAC_DACVALS_DACVALS_MASK) |
        (uint16_t)(value & CSL_DAC_DACVALS_DACVALS_MASK)));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline uint16_t
DAC_getShadowValue(uint32_t base)
{
    //
    // Get the shadow value
    //
    return(HW_RD_REG16(base + CSL_DAC_DACVALS) & CSL_DAC_DACVALS_DACVALS_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_enableOutput(uint32_t base)
{
    //
    // Enable the output
    //
    HW_WR_REG16(base + CSL_DAC_DACOUTEN,
        HW_RD_REG16(base + CSL_DAC_DACOUTEN) | CSL_DAC_DACOUTEN_DACOUTEN_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_disableOutput(uint32_t base)
{
    //
    // Disable the output
    //
    HW_WR_REG16(base + CSL_DAC_DACOUTEN,
        HW_RD_REG16(base + CSL_DAC_DACOUTEN) &
        ~CSL_DAC_DACOUTEN_DACOUTEN_MASK);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_setOffsetTrim(uint32_t base, int16_t offset)
{
    //
    // Check the arguments.
    //
    DebugP_assert((offset > -129) && (offset < 128));
 
    //
    // Set the offset trim value
    //
    HW_WR_REG16(base + CSL_DAC_DACTRIM,
        ((HW_RD_REG16(base + CSL_DAC_DACTRIM) &
        ~CSL_DAC_DACTRIM_OFFSET_TRIM_MASK) | (int16_t)offset));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline int16_t
DAC_getOffsetTrim(uint32_t base)
{
    uint16_t value;
 
    //
    // Get the sign-extended offset trim value
    //
    value = (HW_RD_REG16(base + CSL_DAC_DACTRIM) &
        CSL_DAC_DACTRIM_OFFSET_TRIM_MASK);
    value = ((value & (uint16_t)DAC_REG_BYTE_MASK) ^ (uint16_t)0x80) -
            (uint16_t)0x80;
 
    return((int16_t)value);
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline void
DAC_lockRegister(uint32_t base, uint16_t reg)
{
    //
    // Check the arguments.
    //
    DebugP_assert((reg & ~(DAC_LOCK_CONTROL | DAC_LOCK_SHADOW |
                    DAC_LOCK_OUTPUT)) == 0U);
 
    //
    // Lock the specified registers
    //
    HW_WR_REG16(base + CSL_DAC_DACLOCK,
        HW_RD_REG16(base + CSL_DAC_DACLOCK) |
        (CSL_DAC_DACLOCK_KEY_MASK | reg));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
static inline bool
DAC_isRegisterLocked(uint32_t base, uint16_t reg)
{
    //
    // Check the arguments.
    //
    DebugP_assert((reg & ~(DAC_LOCK_CONTROL | DAC_LOCK_SHADOW |
                    DAC_LOCK_OUTPUT)) == 0U);
 
    //
    // Return the lock status on the specified registers
    //
    return(((HW_RD_REG16(base + CSL_DAC_DACLOCK) & reg) != 0U));
}
 
//*****************************************************************************
//
//
//*****************************************************************************
extern void
DAC_tuneOffsetTrim(uint32_t base, Float32 referenceVoltage);
 
//*****************************************************************************
//
// Close the Doxygen group.
//
//*****************************************************************************
 
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif
 
#endif // DAC_V0_H_