/**
 *file    sys_gpio.c
 *brief   
 * 
 *par     Copyright (c) 2022  Unicmicro Corp., Ltd. All Rights Reserved.
 *author  James
 *date    2022-09-20
 *version 
 * 
 *history 
 *  Date        Note
 *  2018-03-20  Original Creation
 * 
 */

#include "drivers.h"
#include "libc.h"
#include "sys_gpio.h"
#include "sys_pd_hook.h"
#include  "sys_alt_control.h"



/** GPIO definitions for function 
 *
 *  UPD350 C1口             
 *               
 *  引脚    I/O 名称            描述                            有效电平
 *  GPIO0   O   VCONN2_EN                                           1
 *  GPIO1   O   VCONN1_EN                                           1
 *  GPIO2   O   USBC_ON         C口mos开关使能（单PMOS）              1
 *  GPIO3   O   8014_EN         SC8014芯片使能                       1                            
 *  GPIO4   I   NA
 *  GPIO5   O   VBAT_DIS        VBUS泄放控制                          1  
 *  GPIO6   I   VBUSC_DEF       VBUS电压监测  分压1M/100K 
 *  GPIO7       DMC             QC，FCP等功能管脚DM/UART0_TX，C口   
 *  GPIO8       DPC             QC，FCP等功能管脚DP/UART0_RX，C口   
 *  GPIO9       I2C0_SCL        控制8815A 
 *  GPIO10      I2C0_SDA        控制8815A 
 *  GPIO12      NA        	
 *  GPIO13      NA       	       
 *  GPIO21  O   8014_PSTO                                             1              
 *  CSN/CSP                       
 *                  
 *  SC8014             
 *  引脚        名称            描述  
 *
 */


void sys_gpio_init()
{
    // PMIC chip EN
   // drv_gpio_val_set(SYS_IO_PMIC_EN,1);
  //  drv_gpio_oe_set(SYS_IO_PMIC_EN,1);
  //  drv_gpio_en_set(SYS_IO_PMIC_EN,1);

    //PMIC chip pstop 0 effect
  //  drv_gpio_val_set(SYS_IO_PMIC_PSOTP,1);
  //  drv_gpio_oe_set(SYS_IO_PMIC_PSOTP,1);
   // drv_gpio_en_set(SYS_IO_PMIC_PSOTP,1);

    //vconn2 en
    drv_gpio_val_set(SYS_IO_VCONN2_EN,0);
    drv_gpio_oe_set(SYS_IO_VCONN2_EN,1);
    drv_gpio_en_set(SYS_IO_VCONN2_EN,1);
    
    //vconn1 en
    drv_gpio_val_set(SYS_IO_VCONN1_EN,0);
    drv_gpio_oe_set(SYS_IO_VCONN1_EN,1);
    drv_gpio_en_set(SYS_IO_VCONN1_EN,1);


    //USBC_ON
    drv_gpio_val_set(SYS_IO_USBC_ON,0);
    drv_gpio_oe_set(SYS_IO_USBC_ON,1);  
    drv_gpio_en_set(SYS_IO_USBC_ON,1);
#if 0
    //MCU IN INT
    drv_gpio_oe_set(SYS_IO_INTn,0);  
    drv_gpio_en_set(SYS_IO_INTn,1);
    drv_gpio_intr_type_set(SYS_IO_INTn,1);
    drv_gpio_intr_polar_set(SYS_IO_INTn, 0);
    //drv_gpio_intr_en_set(SYS_IO_INTn, TRUE);
#endif
    drv_chip_dp0_500kohm_pull_down_set(TRUE);
    //drv_chip_dp1_500kohm_pull_down_set(TRUE);

    // VBUS discharge
    drv_gpio_val_set(SYS_IO_VBUSC_DIS,0);
    drv_gpio_oe_set(SYS_IO_VBUSC_DIS,1);
    drv_gpio_en_set(SYS_IO_VBUSC_DIS,1);
    
    // VBUS
    drv_gpio_oe_set(SYS_IO_VBUSC_DEF,0);
    drv_gpio_en_set(SYS_IO_VBUSC_DEF,1);
    
   
    // I2C0_SCL
    drv_gpio_oe_set(SYS_IO_I2C1_SCL,0);
    drv_gpio_en_set(SYS_IO_I2C1_SCL,1);
    
    // I2C0_SDA
    drv_gpio_oe_set(SYS_IO_I2C1_SDA,0);
    drv_gpio_en_set(SYS_IO_I2C1_SDA,1);

#if 0    
    // UART1 RXD
    drv_gpio_oe_set(SYS_IO_UART_RXD,0);
    drv_gpio_en_set(SYS_IO_UART_RXD,1);

    // UART1 TXD
    drv_gpio_oe_set(SYS_IO_UART_TXD,0);
    drv_gpio_en_set(SYS_IO_UART_TXD,1);

    // I2C1_SCL
    drv_gpio_oe_set(SYS_IO_I2C1_SCL,0);
    drv_gpio_en_set(SYS_IO_I2C1_SCL,1);
    
    // I2C1_SDA
    drv_gpio_oe_set(SYS_IO_I2C1_SDA,0);
    drv_gpio_en_set(SYS_IO_I2C1_SDA,1);

     // KEY
    drv_gpio_oe_set(SYS_IO_KEY,0);
    drv_gpio_en_set(SYS_IO_KEY,1);
    drv_gpio_pu_set(SYS_IO_KEY,1);
#endif
    

    // no use
#if ((SYS_LED_ENABLED)&&(!SYS_SMG_DISPLAY_ENABLED))
    // led1
    drv_gpio_val_set(SYS_IO_LED1,0);
    drv_gpio_oe_set(SYS_IO_LED1,1);
    drv_gpio_en_set(SYS_IO_LED1,1);

    //led2
    drv_gpio_val_set(SYS_IO_LED2,0);
    drv_gpio_oe_set(SYS_IO_LED2,1);
    drv_gpio_en_set(SYS_IO_LED2,1);

    //led3
    drv_gpio_val_set(SYS_IO_LED3,0);
    drv_gpio_oe_set(SYS_IO_LED3,1);
    drv_gpio_en_set(SYS_IO_LED3,1);

    //led4
    drv_gpio_val_set(SYS_IO_LED4,0);
    drv_gpio_oe_set(SYS_IO_LED4,1);
    drv_gpio_en_set(SYS_IO_LED4,1);
#if ( SYS_LED_NUM == 5)
    //led5
    drv_gpio_val_set(SYS_IO_LED5,0);
    drv_gpio_oe_set(SYS_IO_LED5,1);
    drv_gpio_en_set(SYS_IO_LED5,1);
#endif

#endif










}

void sys_gpio_uart0_enable_set(bool_t en)
{
    bool_t old = drv_gpio_en_get(UART_RXD) ? FALSE : TRUE;
    if (old != en)
    {
        if (en)
        {
            drv_gpio_en_set(UART_TXD,FALSE);
            drv_gpio_pd_set(UART_TXD,FALSE);
            drv_gpio_pu_set(UART_TXD,FALSE);

            drv_gpio_en_set(UART_RXD,FALSE);
            drv_gpio_pd_set(UART_RXD,FALSE);
            drv_gpio_pu_set(UART_RXD,FALSE);

#if SYS_QUICK_CHARGE_ENABLED
            if (!usbpd_cfg_port_quick_charge_en_get())
            {
                drv_chip_dp0_dm0_short_set(FALSE);
            }
#else
          //  drv_chip_dp0_dm0_short_set(FALSE);
#endif /* SYS_QUICK_CHARGE_ENABLED */
        }
        else {
            drv_gpio_en_set(UART_TXD,TRUE);
            drv_gpio_oe_set(UART_TXD,FALSE);
            
            drv_gpio_en_set(UART_RXD,TRUE);
            drv_gpio_oe_set(UART_RXD,FALSE);

#if SYS_QUICK_CHARGE_ENABLED
            if (!usbpd_cfg_port_quick_charge_en_get())
            {
                //drv_chip_dp0_dm0_short_set(TRUE);
            }
#else
           // drv_chip_dp0_dm0_short_set(TRUE);
#endif /* SYS_QUICK_CHARGE_ENABLED */
        }
    }
}

void sys_gpio_uart0_disable(void)
{
    // UART0 PINs
    if((dpm_vbus_volt_get() > 2500U)&&
        (drv_flash_firmware_is_unbroken()))
    {
        
        drv_gpio_en_set(UART_TXD,TRUE);
        drv_gpio_pd_set(UART_TXD,FALSE);
        drv_gpio_oe_set(UART_TXD,FALSE);
    
        drv_gpio_en_set(UART_RXD,TRUE);
        drv_gpio_pd_set(UART_RXD,FALSE);
        drv_gpio_oe_set(UART_RXD,FALSE);
        drv_chip_dp0_dm0_short_set(TRUE);

    }
}

void sys_gpio_uart0_enable(void)
{
    drv_gpio_en_set(UART_TXD,FALSE);
    drv_gpio_pd_set(UART_TXD,FALSE);
    drv_gpio_pu_set(UART_TXD,FALSE);

    drv_gpio_en_set(UART_RXD,FALSE);
    drv_gpio_pd_set(UART_RXD,FALSE);
    drv_gpio_pu_set(UART_RXD,FALSE);
    drv_chip_dp0_dm0_short_set(FALSE);
}

void sys_gpio_uart1_enable_set(bool_t en)
{
    bool_t old = drv_gpio_en_get(SEC_UART_RXD) ? FALSE : TRUE;
    if (old != en)
    {
        if (en)
        {
            drv_gpio_en_set(SEC_UART_TXD,FALSE);
            drv_gpio_pd_set(SEC_UART_TXD,FALSE);
            drv_gpio_pu_set(SEC_UART_TXD,FALSE);

            drv_gpio_en_set(SEC_UART_RXD,FALSE);
            drv_gpio_pd_set(SEC_UART_RXD,FALSE);
            drv_gpio_pu_set(SEC_UART_RXD,FALSE);
        }
        else {
            drv_gpio_en_set(SEC_UART_TXD,TRUE);
            drv_gpio_oe_set(SEC_UART_TXD,FALSE);

            drv_gpio_en_set(SEC_UART_RXD,TRUE);
            drv_gpio_oe_set(SEC_UART_RXD,FALSE);
        }
    }
}

#if ((SYS_LED_ENABLED)&&(!SYS_SMG_DISPLAY_ENABLED))

// IO map for battery capacity LEDs
const u8_t bat_cap_led_iomap[SYS_LED_NUM] = {SYS_IO_LED1,SYS_IO_LED2,SYS_IO_LED3,SYS_IO_LED4,SYS_IO_LED5};

void sys_gpio_bat_cap_led_control(u32_t bitmap)
{
#if 1  /* modified by James Gan - 2019-07-09, for out of sequence */
    if (SAL_IS_BIT_SET(bitmap,SYS_GPIO_BAT_CAP_LED_1))
    {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_1],TRUE);
    }
    else {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_1],FALSE);
    }

    if (SAL_IS_BIT_SET(bitmap,SYS_GPIO_BAT_CAP_LED_2))
    {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_2],TRUE);
    }
    else {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_2],FALSE);
    }

    if (SAL_IS_BIT_SET(bitmap,SYS_GPIO_BAT_CAP_LED_3))
    {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_3],TRUE);
    }
    else {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_3],FALSE);
    }

    if (SAL_IS_BIT_SET(bitmap,SYS_GPIO_BAT_CAP_LED_4))
    {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_4],TRUE);
    }
    else {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_4],FALSE);
    }

#if (5==SYS_LED_NUM)
    if (SAL_IS_BIT_SET(bitmap,SYS_GPIO_BAT_CAP_LED_5))
    {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_5],TRUE);
    }
    else {
        drv_gpio_val_set(bat_cap_led_iomap[SYS_GPIO_BAT_CAP_LED_5],FALSE);
    }
#endif /* (5==SYS_LED_NUM) */
#else
    
#endif /* #if 1 */
}


#endif


