/*
  ******************************************************************************
  * @file    HAL_OPA.c
  * @version V1.0.0
  * @date    2020
  * @brief   OPA HAL module driver.
  *          This file provides firmware functions to manage the following
  *          functionalities of the Operational Amplifier (OPA).
  *           @ Initialization and de-initialization functions
  *           @ IO operation functions
  *           @ Peripheral Control functions
  ******************************************************************************
*/
#include "ACM32Fxx_HAL.h"

/************************************************************************
 * function   : HAL_OPA_MspInit
 * Description: OPA MCU specific initiation, such as IO share, module clock, ... 
 * input      :
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 * return: none
************************************************************************/
__weak void HAL_OPA_MspInit(OPA_HandleTypeDef* hopa)
{
    /* 
      NOTE : This function should be modified by the user.
    */
    
    /* For Example */
    GPIO_InitTypeDef GPIO_OPA; 

    /* Enable Clock */
    System_Module_Enable(EN_OPA);
        
    if(hopa->Init.OpaX == OPA1)
    {
        /* OPA1 GPIO inition VINP:PC4*/
        /* OPA1 GPIO inition VINM:PA3*/
        /* OPA1 GPIO inition OPA1_VOUT:PA2*/
        GPIO_OPA.Pin            = GPIO_PIN_2 | GPIO_PIN_3;
        GPIO_OPA.Mode           = GPIO_MODE_ANALOG;
        GPIO_OPA.Pull           = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_OPA);

        GPIO_OPA.Pin            = GPIO_PIN_4;
        GPIO_OPA.Mode           = GPIO_MODE_ANALOG;
        GPIO_OPA.Pull           = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOC, &GPIO_OPA);    
    }
    
    else if(hopa->Init.OpaX == OPA2)
    {
        /* OPA2 GPIO inition VINP:PA7*/
        /* OPA2 GPIO inition VINM:PC5*/
        /* OPA2 GPIO inition OPA2_VOUT:PA6*/
        GPIO_OPA.Pin            = GPIO_PIN_6 | GPIO_PIN_7;
        GPIO_OPA.Mode           = GPIO_MODE_ANALOG;
        GPIO_OPA.Pull           = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_OPA);
        
        GPIO_OPA.Pin            = GPIO_PIN_5;
        GPIO_OPA.Mode           = GPIO_MODE_ANALOG;
        GPIO_OPA.Pull           = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOC, &GPIO_OPA);

    }
    else if(hopa->Init.OpaX == OPA3)
    {
        /* OPA3 GPIO inition VINP:PA4*/
        /* OPA3 GPIO inition VINM:PB10*/
        /* OPA3 GPIO inition OPA2_VOUT:PB1*/
        GPIO_OPA.Pin            = GPIO_PIN_4;
        GPIO_OPA.Mode           = GPIO_MODE_ANALOG;
        GPIO_OPA.Pull           = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_OPA);
        
        GPIO_OPA.Pin            = GPIO_PIN_1 | GPIO_PIN_10;
        GPIO_OPA.Mode           = GPIO_MODE_ANALOG;
        GPIO_OPA.Pull           = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOB, &GPIO_OPA);
    }
}

/************************************************************************
 * function   : HAL_OPA_MspDeInit
 * Description: OPA MCU De-initiation, such as IO share, module clock, ... 
 * input      :
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 * return: none
************************************************************************/
__weak void HAL_OPA_MspDeInit(OPA_HandleTypeDef* hopa)
{
    /* 
      NOTE : This function should be modified by the user.
    */
    
    /* For Example */
    
    /* Reset the OPA */
    System_Module_Reset(RST_OPA);
    /* Disable Clock */
    System_Module_Disable(EN_OPA);

}

/************************************************************************
 * function   : HAL_OPA_Init
 * Description: opa initial with parameters. 
 * input : 
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 ************************************************************************/
HAL_StatusTypeDef HAL_OPA_Init(OPA_HandleTypeDef* hopa)
{            
    uint32_t u32RegTemp, u32NvrTrimValue;
    __IO uint32_t *gu32RegCrx;
    uint8_t trim_value;
    
    /* Check the OPA handle allocation */
    if (hopa == NULL)
    {
        return HAL_ERROR;
    }
    
    /* Check the parameters */
    if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
    if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
    if(!IS_OPA_ALL_HSM(hopa->Init.Hsm)) return HAL_ERROR;
    if(!IS_OPA_ALL_GAIN(hopa->Init.Gain)) return HAL_ERROR;
    if(!IS_OPA_ALL_POL(hopa->Init.PolSel)) return HAL_ERROR;
    if(!IS_OPA_ALL_MODE(hopa->Init.OpaMode)) return HAL_ERROR;
    if(!IS_OPA_ALL_VINP(hopa->Init.VinPSel)) return HAL_ERROR;
    if(!IS_OPA_ALL_OUT(hopa->Init.OutSel)) return HAL_ERROR;
    if(!IS_OPA_ALL_VINM0(hopa->Init.VinM0En)) return HAL_ERROR;
    if(!IS_OPA_ALL_TRIM(hopa->Init.TrimEn)) return HAL_ERROR;

    if(hopa->Init.OpaX == OPA1)
        gu32RegCrx = &hopa->Instance->OPA1_CSR;
    else if(hopa->Init.OpaX == OPA2)
        gu32RegCrx = &hopa->Instance->OPA2_CSR;
    else if(hopa->Init.OpaX == OPA3)
        gu32RegCrx = &hopa->Instance->OPA3_CSR;

    /* Init the low level hardware : GPIO, CLOCK */
    HAL_OPA_MspInit(hopa);
    
    if(READ_BIT(*gu32RegCrx, OPA_CSR_LOCK))
    {
        System_Module_Reset(RST_OPA);
    }
    
    u32RegTemp = *gu32RegCrx;
    
    u32RegTemp =    ((hopa->Init.Hsm << 28) & OPA_CSR_HSM) | \
                    ((hopa->Init.Gain << OPA_CSR_GAIN_SEL_POS) & OPA_CSR_GAIN_SEL_MASK) | \
                    ((hopa->Init.PolSel << OPA_CSR_POL_SEL_POS) & OPA_CSR_POL_SEL_MASK) | \
                    ((hopa->Init.VinM0En << 20) & OPA_CSR_VINM0_SEL_POS) | \
                    ((hopa->Init.OpaMode << OPA_CSR_MODE_SEL_POS) & OPA_CSR_MODE_SEL_MASK) | \
                    ((hopa->Init.VinPSel << OPA_CSR_VINP_SEL_POS) & OPA_CSR_VINP_SEL_MASK) | \
                    ((hopa->Init.OutSel << OPA_CSR_OUT_SEL_POS) & OPA_CSR_OUT_SEL_MASK);
    
    *gu32RegCrx = u32RegTemp;

    /* Enable the opa */
    SET_BIT(*gu32RegCrx, OPA_CSR_EN); 
    
    if(hopa->Init.TrimEn == OPA_CSR_TRIM_ENABLE)
    {
        /* Trim the OPA_CSR_CAL_H N channel */    
        SET_BIT(*gu32RegCrx, OPA_CSR_CAL_NEN);
        CLEAR_BIT(*gu32RegCrx, OPA_CSR_CAL_PEN);
        
        for(trim_value=0;trim_value<31;trim_value++)
        {
            MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSN_MASK,(trim_value)<<OPA_CSR_TRIM_OSN_POS);
            System_Delay(1000);
            if(READ_BIT(*gu32RegCrx,OPA_CSR_CAL_OUT)) break;
        }        
        /* Trim the OPA_CSR_CAL_L P channel */    
        SET_BIT(*gu32RegCrx, OPA_CSR_CAL_PEN);
        CLEAR_BIT(*gu32RegCrx, OPA_CSR_CAL_NEN);
        
        for(trim_value=0;trim_value<31;trim_value++)
        {
            MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSP_MASK,(trim_value)<<OPA_CSR_TRIM_OSP_POS);
            System_Delay(1000);
            if(READ_BIT(*gu32RegCrx,OPA_CSR_CAL_OUT)) break;
        }    
    }
    else
    {
        /* Use the Trim value */    
        u32NvrTrimValue = *(volatile uint32_t*)(0x0008024C+(hopa->Init.OpaX-1)*4); //Read the OPA trim value;
        if(((~(u32NvrTrimValue>>16))&0xFFFF) != (u32NvrTrimValue&0xFFFF)) return HAL_ERROR;
        
        u32NvrTrimValue = u32NvrTrimValue & 0xFFFF;
            
        MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSN_MASK,((u32NvrTrimValue&0x1F)<<OPA_CSR_TRIM_OSN_POS));
            
        MODIFY_REG(*gu32RegCrx,OPA_CSR_TRIM_OSP_MASK,(((u32NvrTrimValue>>5)&0x1F)<<OPA_CSR_TRIM_OSP_POS));    
    }
 
    /* enable the trim*/    
    SET_BIT(*gu32RegCrx, OPA_CSR_CAL_PEN);
    SET_BIT(*gu32RegCrx, OPA_CSR_CAL_NEN);

    return HAL_OK;
}

/************************************************************************
 * function   : HAL_OPA_DeInit
 * Description: opa De-initial with parameters. 
 * input : 
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 ************************************************************************/
HAL_StatusTypeDef HAL_OPA_DeInit(OPA_HandleTypeDef* hopa)
{                
    /* Check the OPA handle allocation */
    if (hopa == NULL)
    {
        return HAL_ERROR;
    }
    
    HAL_OPA_MspDeInit(hopa);
    
    memset(&hopa->Init, 0, sizeof(hopa->Init));
    
    return HAL_OK;
}
/************************************************************************
 * function   : HAL_OPA_Enable
 * Description: opa enable. 
 * input : 
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 ************************************************************************/
HAL_StatusTypeDef HAL_OPA_Enable(OPA_HandleTypeDef* hopa)
{    
    uint32_t u32RegTemp;
    __IO uint32_t *gu32RegCrx;
    
    /* Check the OPA handle allocation */
    if (hopa == NULL)
    {
        return HAL_ERROR;
    }
    
    /* Check the parameters */
    if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
    if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
    
    if(hopa->Init.OpaX == OPA1)
        gu32RegCrx = &hopa->Instance->OPA1_CSR;
    else if(hopa->Init.OpaX == OPA2)
        gu32RegCrx = &hopa->Instance->OPA2_CSR;
    else if(hopa->Init.OpaX == OPA3)
        gu32RegCrx = &hopa->Instance->OPA3_CSR;
        
    /* Enable the opa */
    SET_BIT(*gu32RegCrx, OPA_CSR_EN); 
    
    return HAL_OK;
}

/************************************************************************
 * function   : HAL_OPA_Disable
 * Description: opa disable. 
 * input : 
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 ************************************************************************/
HAL_StatusTypeDef HAL_OPA_Disable(OPA_HandleTypeDef* hopa)
{        
    uint32_t u32RegTemp;
    __IO uint32_t *gu32RegCrx;
    
    /* Check the OPA handle allocation */
    if (hopa == NULL)
    {
        return HAL_ERROR;
    }
    
    /* Check the parameters */
    if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
    if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
    
    if(hopa->Init.OpaX == OPA1)
        gu32RegCrx = &hopa->Instance->OPA1_CSR;
    else if(hopa->Init.OpaX == OPA2)
        gu32RegCrx = &hopa->Instance->OPA2_CSR;
    else if(hopa->Init.OpaX == OPA3)
        gu32RegCrx = &hopa->Instance->OPA3_CSR;
            
    /* Disable the opa */
    CLEAR_BIT(*gu32RegCrx, OPA_CSR_EN); 
    
    return HAL_OK;
}

/************************************************************************
 * function   : HAL_OPA_Lock
 * Description: opa lock. 
 * input : 
 *         OPA_HandleTypeDef *hopa: pointer to opa handle structure
 ************************************************************************/
HAL_StatusTypeDef HAL_OPA_Lock(OPA_HandleTypeDef* hopa)
{        
    uint32_t u32RegTemp;
    __IO uint32_t *gu32RegCrx;
    
    /* Check the OPA handle allocation */
    if (hopa == NULL)
    {
        return HAL_ERROR;
    }
    
    /* Check the parameters */
    if(!IS_OPA_ALL_INSTANCE(hopa->Instance)) return HAL_ERROR;
    if(!IS_OPA_ALL_OPAX(hopa->Init.OpaX)) return HAL_ERROR;
    
    if(hopa->Init.OpaX == OPA1)
        gu32RegCrx = &hopa->Instance->OPA1_CSR;
    else if(hopa->Init.OpaX == OPA2)
        gu32RegCrx = &hopa->Instance->OPA2_CSR;
    else if(hopa->Init.OpaX == OPA3)
        gu32RegCrx = &hopa->Instance->OPA3_CSR;
            
    /* Lock the opa */
    SET_BIT(*gu32RegCrx, OPA_CSR_LOCK); 
    
    return HAL_OK;
}