4224 lines
117 KiB
C
4224 lines
117 KiB
C
/***************************************************************************
|
|
*
|
|
* Copyright 2015-2019 BES.
|
|
* All rights reserved. All unpublished rights reserved.
|
|
*
|
|
* No part of this work may be used or reproduced in any form or by any
|
|
* means, or stored in a database or retrieval system, without prior written
|
|
* permission of BES.
|
|
*
|
|
* Use of this work is governed by a license granted by BES.
|
|
* This work contains confidential and proprietary information of
|
|
* BES. which is protected by copyright, trade secret,
|
|
* trademark and other intellectual property rights.
|
|
*
|
|
****************************************************************************/
|
|
#include "analog.h"
|
|
#include "cmsis.h"
|
|
#include "cmsis_nvic.h"
|
|
#include "hal_aud.h"
|
|
#include "hal_cache.h"
|
|
#include "hal_chipid.h"
|
|
#include "hal_cmu.h"
|
|
#include "hal_location.h"
|
|
#include "hal_psc.h"
|
|
#include "hal_sysfreq.h"
|
|
#include "hal_timer.h"
|
|
#include "hal_trace.h"
|
|
#include "pmu.h"
|
|
#include "tgt_hardware.h"
|
|
#include "usbphy.h"
|
|
|
|
#define PMU_LED_VIA_PWM
|
|
#define DCDC_ULP_LP_ON
|
|
|
|
// LDO soft start interval is about 1000 us
|
|
#define PMU_LDO_PU_STABLE_TIME_US 1800
|
|
#define PMU_DCDC_PU_STABLE_TIME_US 100
|
|
#define PMU_VANA_STABLE_TIME_US 10
|
|
#define PMU_VCORE_STABLE_TIME_US 10
|
|
|
|
#ifdef __PMU_VIO_DYNAMIC_CTRL_MODE__
|
|
#define IO_VOLT_ACTIVE_NORMAL PMU_IO_2_6V
|
|
#else
|
|
#define IO_VOLT_ACTIVE_NORMAL PMU_IO_2_6V
|
|
#endif
|
|
#ifdef DIGMIC_HIGH_VOLT
|
|
#define IO_VOLT_ACTIVE_RISE PMU_IO_3_0V
|
|
#else
|
|
#define IO_VOLT_ACTIVE_RISE PMU_IO_2_8V
|
|
#endif
|
|
#define IO_VOLT_SLEEP PMU_IO_2_6V
|
|
|
|
#define HPPA_RAMP_UP_VOLT_MV 1950
|
|
|
|
#define PMU_DCDC_ANA_2_1V 0xF0
|
|
#define PMU_DCDC_ANA_2_0V 0xE0
|
|
#define PMU_DCDC_ANA_1_9V 0xD0
|
|
#define PMU_DCDC_ANA_1_8V 0xC0
|
|
#define PMU_DCDC_ANA_1_7V 0xB0
|
|
#define PMU_DCDC_ANA_1_6V 0xA0
|
|
#define PMU_DCDC_ANA_1_5V 0x90
|
|
#define PMU_DCDC_ANA_1_4V 0x80
|
|
#define PMU_DCDC_ANA_1_35V 0x77
|
|
#define PMU_DCDC_ANA_1_3V 0x70
|
|
#define PMU_DCDC_ANA_1_2V 0x60
|
|
#define PMU_DCDC_ANA_1_1V 0x50
|
|
#define PMU_DCDC_ANA_1_0V 0x40
|
|
|
|
#define PMU_DCDC_ANA_SLEEP_1_3V PMU_DCDC_ANA_1_3V
|
|
#define PMU_DCDC_ANA_SLEEP_1_2V PMU_DCDC_ANA_1_2V
|
|
#define PMU_DCDC_ANA_SLEEP_1_1V PMU_DCDC_ANA_1_1V
|
|
#define PMU_DCDC_ANA_SLEEP_1_0V PMU_DCDC_ANA_1_0V
|
|
|
|
#define PMU_VBUCK2ANA_1_5V 0x30
|
|
#define PMU_VBUCK2ANA_1_4V 0x2C
|
|
#define PMU_VBUCK2ANA_1_3V 0x28
|
|
#define PMU_VBUCK2ANA_1_2V 0x24
|
|
#define PMU_VBUCK2ANA_1_1V 0x20
|
|
#define PMU_VBUCK2ANA_1_0V 0x1C
|
|
|
|
#define PMU_DCDC_DIG_1_1V 0xFF
|
|
#define PMU_DCDC_DIG_1_05V 0xF0
|
|
#define PMU_DCDC_DIG_1_0V 0xE0
|
|
#define PMU_DCDC_DIG_0_95V 0xD0
|
|
#define PMU_DCDC_DIG_0_9V 0xC0
|
|
#define PMU_DCDC_DIG_0_85V 0xB0
|
|
#define PMU_DCDC_DIG_0_8V 0xA0
|
|
#define PMU_DCDC_DIG_0_75V 0x90
|
|
#define PMU_DCDC_DIG_0_7V 0x80
|
|
#define PMU_DCDC_DIG_0_65V 0x70
|
|
#define PMU_DCDC_DIG_0_6V 0x60
|
|
#define PMU_DCDC_DIG_0_55V 0x50
|
|
#define PMU_DCDC_DIG_0_5V 0x40
|
|
#define PMU_DCDC_DIG_0_45V 0x30
|
|
#define PMU_DCDC_DIG_0_4V 0x20
|
|
|
|
#define PMU_VDIG_1_2V 0x24
|
|
#define PMU_VDIG_1_1V 0x20
|
|
#define PMU_VDIG_1_05V 0x1E
|
|
#define PMU_VDIG_1_0V 0x1C
|
|
#define PMU_VDIG_0_95V 0x1A
|
|
#define PMU_VDIG_0_9V 0x18
|
|
#define PMU_VDIG_0_85V 0x16
|
|
#define PMU_VDIG_0_8V 0x14
|
|
#define PMU_VDIG_0_75V 0x12
|
|
#define PMU_VDIG_0_7V 0x10
|
|
#define PMU_VDIG_0_65V 0x0E
|
|
#define PMU_VDIG_0_6V 0x0C
|
|
#define PMU_VDIG_0_55V 0x0A
|
|
#define PMU_VDIG_0_5V 0x08
|
|
#define PMU_VDIG_0_45V 0x06
|
|
#define PMU_VDIG_0_4V 0x04
|
|
#define PMU_VDIG_MAX PMU_VDIG_1_2V
|
|
|
|
#define PMU_IO_3_3V 0x15
|
|
#define PMU_IO_3_2V 0x14
|
|
#define PMU_IO_3_1V 0x13
|
|
#define PMU_IO_3_0V 0x12
|
|
#define PMU_IO_2_9V 0x11
|
|
#define PMU_IO_2_8V 0x10
|
|
#define PMU_IO_2_7V 0xF
|
|
#define PMU_IO_2_6V 0xE
|
|
#define PMU_IO_2_5V 0xD
|
|
#define PMU_IO_2_4V 0xC
|
|
#define PMU_IO_2_3V 0xB
|
|
#define PMU_IO_2_2V 0xA
|
|
#define PMU_IO_2_1V 0x9
|
|
#define PMU_IO_2_0V 0x8
|
|
#define PMU_IO_1_9V 0x7
|
|
#define PMU_IO_1_8V 0x6
|
|
#define PMU_IO_1_7V 0x5
|
|
|
|
#define PMU_VMEM_2_8V 0x10
|
|
#define PMU_VMEM_2_0V 0x8
|
|
#define PMU_VMEM_1_9V 0x7
|
|
#define PMU_VMEM_1_8V 0x6
|
|
#define PMU_VMEM_1_7V 0x5
|
|
#define PMU_VMEM_1_6V 0x4
|
|
|
|
#define PMU_CODEC_2_7V 0xF
|
|
#define PMU_CODEC_2_6V 0xE
|
|
#define PMU_CODEC_2_5V 0xD
|
|
#define PMU_CODEC_2_4V 0xC
|
|
#define PMU_CODEC_2_3V 0xB
|
|
#define PMU_CODEC_2_2V 0xA
|
|
#define PMU_CODEC_2_1V 0x9
|
|
#define PMU_CODEC_2_0V 0x8
|
|
#define PMU_CODEC_1_9V 0x7
|
|
#define PMU_CODEC_1_8V 0x6
|
|
#define PMU_CODEC_1_7V 0x5
|
|
#define PMU_CODEC_1_6V 0x4
|
|
#define PMU_CODEC_1_5V 0x3
|
|
|
|
#define PMU_HPPA2CODEC_2_3V 0x1C
|
|
#define PMU_HPPA2CODEC_2_2V 0x18
|
|
#define PMU_HPPA2CODEC_2_1V 0x14
|
|
#define PMU_HPPA2CODEC_2_0V 0x10
|
|
#define PMU_HPPA2CODEC_1_95V 0xE
|
|
#define PMU_HPPA2CODEC_1_9V 0xC
|
|
#define PMU_HPPA2CODEC_1_8V 0x8
|
|
#define PMU_HPPA2CODEC_1_7V 0x4
|
|
#define PMU_HPPA2CODEC_1_6V 0x0
|
|
|
|
#define PMU_USB_3_4V 0xA
|
|
#define PMU_USB_3_3V 0x9
|
|
#define PMU_USB_3_2V 0x8
|
|
#define PMU_USB_3_1V 0x7
|
|
#define PMU_USB_3_0V 0x6
|
|
#define PMU_USB_2_9V 0x5
|
|
#define PMU_USB_2_8V 0x4
|
|
#define PMU_USB_2_7V 0x3
|
|
#define PMU_USB_2_6V 0x2
|
|
|
|
#define PMU_VHPPA_2_0V 0x8
|
|
#define PMU_VHPPA_1_9V 0x7
|
|
#define PMU_VHPPA_1_8V 0x6
|
|
#define PMU_VHPPA_1_7V 0x5
|
|
#define PMU_VHPPA_1_6V 0x4
|
|
#define PMU_VHPPA_1_5V 0x3
|
|
|
|
#define PMU_DCDC_HPPA_2_1V 0xF0
|
|
#define PMU_DCDC_HPPA_2_0V 0xE0
|
|
#define PMU_DCDC_HPPA_1_95V 0xD8
|
|
#define PMU_DCDC_HPPA_1_9V 0xD0
|
|
#define PMU_DCDC_HPPA_1_8V 0xC0
|
|
#define PMU_DCDC_HPPA_1_7V 0xB0
|
|
#define PMU_DCDC_HPPA_1_6V 0xA0
|
|
#define PMU_DCDC_HPPA_1_5V 0x90
|
|
#define PMU_DCDC_HPPA_1_4V 0x80
|
|
#define PMU_DCDC_HPPA_1_3V 0x70
|
|
#define PMU_DCDC_HPPA_1_2V 0x60
|
|
|
|
#define PMU_VMIC_3_3V 0x14
|
|
#define PMU_VMIC_3_2V 0x13
|
|
#define PMU_VMIC_3_1V 0x12
|
|
#define PMU_VMIC_3_0V 0x11
|
|
#define PMU_VMIC_2_9V 0x10
|
|
#define PMU_VMIC_2_8V 0xF
|
|
#define PMU_VMIC_2_7V 0xF
|
|
#define PMU_VMIC_2_6V 0xE
|
|
#define PMU_VMIC_2_5V 0xD
|
|
#define PMU_VMIC_2_4V 0xC
|
|
#define PMU_VMIC_2_3V 0xB
|
|
#define PMU_VMIC_2_2V 0xA
|
|
#define PMU_VMIC_2_1V 0x9
|
|
#define PMU_VMIC_2_0V 0x8
|
|
#define PMU_VMIC_1_9V 0x7
|
|
#define PMU_VMIC_1_8V 0x6
|
|
#define PMU_VMIC_1_7V 0x5
|
|
#define PMU_VMIC_1_6V 0x4
|
|
|
|
#define PMU_VMIC_RES_3_3V 0xF
|
|
#define PMU_VMIC_RES_2_8V 0xA
|
|
#define PMU_VMIC_RES_2_2V 0x4
|
|
|
|
// 00 PMU_REG_METAL_ID
|
|
#define PMU_METAL_ID_SHIFT 0
|
|
#define PMU_METAL_ID_MASK (0xF << PMU_METAL_ID_SHIFT)
|
|
#define PMU_METAL_ID(n) (((n)&0xF) << PMU_METAL_ID_SHIFT)
|
|
|
|
// 02 PMU_REG_POWER_KEY_CFG
|
|
#define REG_PU_VBAT_DIV (1 << 15)
|
|
#define PU_LPO_DR (1 << 14)
|
|
#define PU_LPO_REG (1 << 13)
|
|
#define POWERKEY_WAKEUP_OSC_EN (1 << 12)
|
|
#define RTC_POWER_ON_EN (1 << 11)
|
|
#define PU_ALL_REG (1 << 10)
|
|
#define CLK_32K_SEL_SHIFT 8
|
|
#define CLK_32K_SEL_MASK (0x3 << CLK_32K_SEL_SHIFT)
|
|
#define CLK_32K_SEL(n) BITFIELD_VAL(CLK_32K_SEL, n)
|
|
#define DEEPSLEEP_MODE_DIGI_DR (1 << 7)
|
|
#define DEEPSLEEP_MODE_DIGI_REG (1 << 6)
|
|
#define REG_VCORE_SSTIME_MODE_SHIFT 4
|
|
#define REG_VCORE_SSTIME_MODE_MASK (0x3 << REG_VCORE_SSTIME_MODE_SHIFT)
|
|
#define REG_VCORE_SSTIME_MODE(n) BITFIELD_VAL(REG_VCORE_SSTIME_MODE, n)
|
|
#define REG_LDO_SS_BIAS_EN_DR (1 << 3)
|
|
#define REG_LDO_SS_BIAS_EN (1 << 2)
|
|
#define REG_LP_EN_VHPPA_DSLEEP (1 << 1)
|
|
#define REG_LP_EN_VHPPA_NORMAL (1 << 0)
|
|
|
|
// 03 PMU_REG_BIAS_CFG
|
|
#define REG_VSENSE_SEL_VMEM (1 << 15)
|
|
#define PU_LP_BIAS_LDO_DSLEEP (1 << 14)
|
|
#define PU_LP_BIAS_LDO_DR (1 << 13)
|
|
#define PU_LP_BIAS_LDO_REG (1 << 12)
|
|
#define PU_BIAS_LDO_DR (1 << 11)
|
|
#define PU_BIAS_LDO_REG (1 << 10)
|
|
#define BG_VBG_SEL_DR (1 << 9)
|
|
#define BG_VBG_SEL_REG (1 << 8)
|
|
#define BG_CONSTANT_GM_BIAS_DR (1 << 7)
|
|
#define BG_CONSTANT_GM_BIAS_REG (1 << 6)
|
|
#define BG_CORE_EN_DR (1 << 5)
|
|
#define BG_CORE_EN_REG (1 << 4)
|
|
#define REG_PU_LDO_VANA_DR (1 << 3)
|
|
#define REG_PU_LDO_VANA (1 << 2)
|
|
#define BG_NOTCH_EN_DR (1 << 1)
|
|
#define BG_NOTCH_EN_REG (1 << 0)
|
|
|
|
#define REG_PU_LDO_VANA_REG REG_PU_LDO_VANA
|
|
|
|
// 05 PMU_REG_CHARGER_CFG
|
|
#define REG_PU_LDO_VRTC_RF_DSLEEP (1 << 15)
|
|
#define REG_PU_LDO_VRTC_RF_DR (1 << 14)
|
|
#define REG_PU_LDO_VRTC_RF_REG (1 << 13)
|
|
#define REG_CHARGE_OUT_INTR_MSK (1 << 12)
|
|
#define REG_CHARGE_IN_INTR_MSK (1 << 11)
|
|
#define REG_AC_ON_OUT_EN (1 << 10)
|
|
#define REG_AC_ON_IN_EN (1 << 9)
|
|
#define REG_CHARGE_INTR_EN (1 << 8)
|
|
#define REG_AC_ON_DB_VALUE_SHIFT 0
|
|
#define REG_AC_ON_DB_VALUE_MASK (0xFF << REG_AC_ON_DB_VALUE_SHIFT)
|
|
#define REG_AC_ON_DB_VALUE(n) BITFIELD_VAL(REG_AC_ON_DB_VALUE, n)
|
|
|
|
// 07 PMU_REG_ANA_CFG
|
|
#define REG_LIGHT_LOAD_VANA_BUCK_LDO (1 << 15)
|
|
#define REG_PULLDOWN_VANA_LDO (1 << 14)
|
|
#define LP_EN_VANA_LDO_DSLEEP (1 << 13)
|
|
#define LP_EN_VANA_LDO_DR (1 << 12)
|
|
#define LP_EN_VANA_LDO_REG (1 << 11)
|
|
#define REG_PU_LDO_VANA_DSLEEP (1 << 10)
|
|
#define LDO_ANA_VBIT_DSLEEP_SHIFT 5
|
|
#define LDO_ANA_VBIT_DSLEEP_MASK (0x1F << LDO_ANA_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_ANA_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_ANA_VBIT_DSLEEP, n)
|
|
#define LDO_ANA_VBIT_NORMAL_SHIFT 0
|
|
#define LDO_ANA_VBIT_NORMAL_MASK (0x1F << LDO_ANA_VBIT_NORMAL_SHIFT)
|
|
#define LDO_ANA_VBIT_NORMAL(n) BITFIELD_VAL(LDO_ANA_VBIT_NORMAL, n)
|
|
|
|
#define LDO_VANA_VBIT_DSLEEP_SHIFT LDO_ANA_VBIT_DSLEEP_SHIFT
|
|
#define LDO_VANA_VBIT_DSLEEP_MASK LDO_ANA_VBIT_DSLEEP_MASK
|
|
#define LDO_VANA_VBIT_NORMAL_SHIFT LDO_ANA_VBIT_NORMAL_SHIFT
|
|
#define LDO_VANA_VBIT_NORMAL_MASK LDO_ANA_VBIT_NORMAL_MASK
|
|
|
|
// 08 PMU_REG_DIG_CFG
|
|
#define REG_DCDC_CLK_SE_EN (1 << 15)
|
|
#define LP_EN_VCORE_LDO_DSLEEP (1 << 14)
|
|
#define LP_EN_VCORE_LDO_DR (1 << 13)
|
|
#define LP_EN_VCORE_LDO_REG (1 << 12)
|
|
#define LDO_DIG_VBIT_DSLEEP_SHIFT 6
|
|
#define LDO_DIG_VBIT_DSLEEP_MASK (0x3F << LDO_DIG_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_DIG_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_DIG_VBIT_DSLEEP, n)
|
|
#define LDO_DIG_VBIT_NORMAL_SHIFT 0
|
|
#define LDO_DIG_VBIT_NORMAL_MASK (0x3F << LDO_DIG_VBIT_NORMAL_SHIFT)
|
|
#define LDO_DIG_VBIT_NORMAL(n) BITFIELD_VAL(LDO_DIG_VBIT_NORMAL, n)
|
|
|
|
#define LDO_VCORE_VBIT_DSLEEP_SHIFT LDO_DIG_VBIT_DSLEEP_SHIFT
|
|
#define LDO_VCORE_VBIT_DSLEEP_MASK LDO_DIG_VBIT_DSLEEP_MASK
|
|
#define LDO_VCORE_VBIT_NORMAL_SHIFT LDO_DIG_VBIT_NORMAL_SHIFT
|
|
#define LDO_VCORE_VBIT_NORMAL_MASK LDO_DIG_VBIT_NORMAL_MASK
|
|
|
|
// Real bit is in REG_101 -- but we never change the default value
|
|
#define REG_PU_LDO_VCORE_DSLEEP 0
|
|
|
|
// 09 PMU_REG_IO_CFG
|
|
#define LP_EN_VIO_LDO_DSLEEP (1 << 15)
|
|
#define LP_EN_VIO_LDO_DR (1 << 14)
|
|
#define LP_EN_VIO_LDO_REG (1 << 13)
|
|
#define REG_PU_LDO_VIO_DSLEEP (1 << 12)
|
|
#define REG_PU_LDO_VIO_DR (1 << 11)
|
|
#define REG_PU_LDO_VIO (1 << 10)
|
|
#define LDO_VIO_VBIT_NORMAL_SHIFT 5
|
|
#define LDO_VIO_VBIT_NORMAL_MASK (0x1F << LDO_VIO_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VIO_VBIT_NORMAL(n) BITFIELD_VAL(LDO_VIO_VBIT_NORMAL, n)
|
|
#define LDO_VIO_VBIT_DSLEEP_SHIFT 0
|
|
#define LDO_VIO_VBIT_DSLEEP_MASK (0x1F << LDO_VIO_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VIO_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_VIO_VBIT_DSLEEP, n)
|
|
|
|
#define REG_PU_LDO_VIO_REG REG_PU_LDO_VIO
|
|
|
|
// 0A PMU_REG_MEM_CFG
|
|
#define LP_EN_VMEM_LDO_DSLEEP (1 << 15)
|
|
#define LP_EN_VMEM_LDO_DR (1 << 14)
|
|
#define LP_EN_VMEM_LDO_REG (1 << 13)
|
|
#define REG_PU_LDO_VMEM_DSLEEP (1 << 12)
|
|
#define REG_PU_LDO_VMEM_DR (1 << 11)
|
|
#define REG_PU_LDO_VMEM_REG (1 << 10)
|
|
#define LDO_VMEM_VBIT_NORMAL_SHIFT 5
|
|
#define LDO_VMEM_VBIT_NORMAL_MASK (0x1F << LDO_VMEM_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VMEM_VBIT_NORMAL(n) BITFIELD_VAL(LDO_VMEM_VBIT_NORMAL, n)
|
|
#define LDO_VMEM_VBIT_DSLEEP_SHIFT 0
|
|
#define LDO_VMEM_VBIT_DSLEEP_MASK (0x1F << LDO_VMEM_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VMEM_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_VMEM_VBIT_DSLEEP, n)
|
|
|
|
// 0B PMU_REG_GP_CFG
|
|
#define LP_EN_VGP_LDO_DSLEEP (1 << 15)
|
|
#define LP_EN_VGP_LDO_DR (1 << 14)
|
|
#define LP_EN_VGP_LDO_REG (1 << 13)
|
|
#define REG_PU_LDO_VGP_DSLEEP (1 << 12)
|
|
#define REG_PU_LDO_VGP_DR (1 << 11)
|
|
#define REG_PU_LDO_VGP_REG (1 << 10)
|
|
#define LDO_VGP_VBIT_NORMAL_SHIFT 5
|
|
#define LDO_VGP_VBIT_NORMAL_MASK (0x1F << LDO_VGP_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VGP_VBIT_NORMAL(n) BITFIELD_VAL(LDO_VGP_VBIT_NORMAL, n)
|
|
#define LDO_VGP_VBIT_DSLEEP_SHIFT 0
|
|
#define LDO_VGP_VBIT_DSLEEP_MASK (0x1F << LDO_VGP_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VGP_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_VGP_VBIT_DSLEEP, n)
|
|
|
|
// 0C PMU_REG_USB_CFG
|
|
#define REG_LDO_VANA_LV_MODE (1 << 15)
|
|
#define REG_PULLDOWN_VUSB (1 << 14)
|
|
#define LP_EN_VUSB_LDO_DSLEEP (1 << 13)
|
|
#define LP_EN_VUSB_LDO_DR (1 << 12)
|
|
#define LP_EN_VUSB_LDO_REG (1 << 11)
|
|
#define PU_LDO_VUSB_DSLEEP (1 << 10)
|
|
#define PU_LDO_VUSB_DR (1 << 9)
|
|
#define PU_LDO_VUSB_REG (1 << 8)
|
|
#define LDO_VUSB_VBIT_NORMAL_SHIFT 4
|
|
#define LDO_VUSB_VBIT_NORMAL_MASK (0xF << LDO_VUSB_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VUSB_VBIT_NORMAL(n) BITFIELD_VAL(LDO_VUSB_VBIT_NORMAL, n)
|
|
#define LDO_VUSB_VBIT_DSLEEP_SHIFT 0
|
|
#define LDO_VUSB_VBIT_DSLEEP_MASK (0xF << LDO_VUSB_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VUSB_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_VUSB_VBIT_DSLEEP, n)
|
|
|
|
#define REG_PU_LDO_VUSB_DSLEEP PU_LDO_VUSB_DSLEEP
|
|
#define REG_PU_LDO_VUSB_DR PU_LDO_VUSB_DR
|
|
#define REG_PU_LDO_VUSB_REG PU_LDO_VUSB_REG
|
|
|
|
// 0D PMU_REG_BAT2DIG_CFG
|
|
#define LP_EN_VBAT2VCORE_LDO_DR (1 << 15)
|
|
#define LP_EN_VBAT2VCORE_LDO (1 << 14)
|
|
#define REG_PU_VBAT2VCORE_LDO_DR (1 << 13)
|
|
#define REG_PU_VBAT2VCORE_LDO (1 << 12)
|
|
#define LDO_VBAT2VCORE_VBIT_DSLEEP_SHIFT 6
|
|
#define LDO_VBAT2VCORE_VBIT_DSLEEP_MASK \
|
|
(0x3F << LDO_VBAT2VCORE_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VBAT2VCORE_VBIT_DSLEEP(n) \
|
|
BITFIELD_VAL(LDO_VBAT2VCORE_VBIT_DSLEEP, n)
|
|
#define LDO_VBAT2VCORE_VBIT_NORMAL_SHIFT 0
|
|
#define LDO_VBAT2VCORE_VBIT_NORMAL_MASK \
|
|
(0x3F << LDO_VBAT2VCORE_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VBAT2VCORE_VBIT_NORMAL(n) \
|
|
BITFIELD_VAL(LDO_VBAT2VCORE_VBIT_NORMAL, n)
|
|
|
|
#define LP_EN_VBAT2VCORE_LDO_REG LP_EN_VBAT2VCORE_LDO
|
|
#define REG_PU_LDO_VBAT2VCORE_DR REG_PU_VBAT2VCORE_LDO_DR
|
|
#define REG_PU_LDO_VBAT2VCORE_REG REG_PU_VBAT2VCORE_LDO
|
|
// Real bit is in REG_101 -- but we never change the default value
|
|
#define REG_PU_LDO_VBAT2VCORE_DSLEEP 0
|
|
|
|
// 0E PMU_REG_HPPA_LDO_EN
|
|
#define REG_PULL_DOWN_VHPPA (1 << 15)
|
|
#define REG_PU_LDO_VHPPA_DSLEEP (1 << 14)
|
|
#define REG_PU_LDO_VHPPA_EN (1 << 13)
|
|
#define REG_RES_SEL_VHPPA_SHIFT 8
|
|
#define REG_RES_SEL_VHPPA_MASK (0x1F << REG_RES_SEL_VHPPA_SHIFT)
|
|
#define REG_RES_SEL_VHPPA(n) BITFIELD_VAL(REG_RES_SEL_VHPPA, n)
|
|
#define REG_LP_BIAS_SEL_LDO_SHIFT 6
|
|
#define REG_LP_BIAS_SEL_LDO_MASK (0x3 << REG_LP_BIAS_SEL_LDO_SHIFT)
|
|
#define REG_LP_BIAS_SEL_LDO(n) BITFIELD_VAL(REG_LP_BIAS_SEL_LDO, n)
|
|
#define REG_BYPASS_VBUCK2ANA (1 << 5)
|
|
#define REG_PULLDOWN_VBUCK2ANA (1 << 4)
|
|
#define REG_PULLDOWN_VIO (1 << 3)
|
|
#define REG_PULLDOWN_VMEM (1 << 2)
|
|
#define REG_PULLDOWN_VCORE (1 << 1)
|
|
#define REG_PULLDOWN_VHPPA2VCODEC (1 << 0)
|
|
|
|
// 0F PMU_REG_HPPA2CODEC_CFG
|
|
#define PU_LDO_VCODEC_DSLEEP (1 << 15)
|
|
#define REG_BYPASS_VCORE (1 << 14)
|
|
#define REG_PU_LDO_VHPPA2VCODEC_DR (1 << 13)
|
|
#define REG_PU_LDO_VHPPA2VCODEC (1 << 12)
|
|
#define LP_EN_VHPPA2VCODEC_LDO_DR (1 << 11)
|
|
#define LP_EN_VHPPA2VCODEC_LDO (1 << 10)
|
|
#define LDO_VHPPA2VCODEC_VBIT_DSLEEP_SHIFT 5
|
|
#define LDO_VHPPA2VCODEC_VBIT_DSLEEP_MASK \
|
|
(0x1F << LDO_VHPPA2VCODEC_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VHPPA2VCODEC_VBIT_DSLEEP(n) \
|
|
BITFIELD_VAL(LDO_VHPPA2VCODEC_VBIT_DSLEEP, n)
|
|
#define LDO_VHPPA2VCODEC_VBIT_NORMAL_SHIFT 0
|
|
#define LDO_VHPPA2VCODEC_VBIT_NORMAL_MASK \
|
|
(0x1F << LDO_VHPPA2VCODEC_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VHPPA2VCODEC_VBIT_NORMAL(n) \
|
|
BITFIELD_VAL(LDO_VHPPA2VCODEC_VBIT_NORMAL, n)
|
|
|
|
#define REG_PU_LDO_VHPPA2VCODEC_REG REG_PU_LDO_VHPPA2VCODEC
|
|
#define LP_EN_VHPPA2VCODEC_LDO_REG LP_EN_VHPPA2VCODEC_LDO
|
|
#define REG_PU_LDO_VCODEC_DSLEEP PU_LDO_VCODEC_DSLEEP
|
|
|
|
// 10 PMU_REG_CODEC_CFG
|
|
#define PU_LDO_VCODEC_DR (1 << 15)
|
|
#define PU_LDO_VCODEC_REG (1 << 14)
|
|
#define LP_EN_VCODEC_LDO_DSLEEP (1 << 13)
|
|
#define LP_EN_VCODEC_LDO_DR (1 << 12)
|
|
#define LP_EN_VCODEC_LDO_REG (1 << 11)
|
|
#define REG_PULLDOWN_VCODEC (1 << 10)
|
|
#define LDO_VCODEC_VBIT_NORMAL_SHIFT 5
|
|
#define LDO_VCODEC_VBIT_NORMAL_MASK (0x1F << LDO_VCODEC_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VCODEC_VBIT_NORMAL(n) BITFIELD_VAL(LDO_VCODEC_VBIT_NORMAL, n)
|
|
#define LDO_VCODEC_VBIT_DSLEEP_SHIFT 0
|
|
#define LDO_VCODEC_VBIT_DSLEEP_MASK (0x1F << LDO_VCODEC_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VCODEC_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_VCODEC_VBIT_DSLEEP, n)
|
|
|
|
#define REG_PU_LDO_VCODEC_DR PU_LDO_VCODEC_DR
|
|
#define REG_PU_LDO_VCODEC_REG PU_LDO_VCODEC_REG
|
|
|
|
// 15 PMU_REG_DCDC_DIG_EN
|
|
#define REG_UVLO_SEL_SHIFT 14
|
|
#define REG_UVLO_SEL_MASK (0x3 << REG_UVLO_SEL_SHIFT)
|
|
#define REG_UVLO_SEL(n) BITFIELD_VAL(REG_UVLO_SEL, n)
|
|
#define REG_PU_LDO_DIG_DR (1 << 13)
|
|
#define REG_PU_LDO_DIG_REG (1 << 12)
|
|
#define REG_DCDC1_PFM_SEL_DSLEEP (1 << 11)
|
|
#define REG_DCDC1_PFM_SEL_NORMAL (1 << 10)
|
|
#define REG_DCDC1_ULP_MODE_DSLEEP (1 << 9)
|
|
#define REG_DCDC1_ULP_MODE_NORMAL (1 << 8)
|
|
#define REG_DCDC1_BURST_MODE_SEL_DSLEEP (1 << 7)
|
|
#define REG_DCDC1_BURST_MODE_SEL_NORMAL (1 << 6)
|
|
#define REG_DCDC1_VREF_SEL_DSLEEP_SHIFT 4
|
|
#define REG_DCDC1_VREF_SEL_DSLEEP_MASK (0x3 << REG_DCDC1_VREF_SEL_DSLEEP_SHIFT)
|
|
#define REG_DCDC1_VREF_SEL_DSLEEP(n) BITFIELD_VAL(REG_DCDC1_VREF_SEL_DSLEEP, n)
|
|
#define REG_DCDC1_VREF_SEL_NORMAL_SHIFT 2
|
|
#define REG_DCDC1_VREF_SEL_NORMAL_MASK (0x3 << REG_DCDC1_VREF_SEL_NORMAL_SHIFT)
|
|
#define REG_DCDC1_VREF_SEL_NORMAL(n) BITFIELD_VAL(REG_DCDC1_VREF_SEL_NORMAL, n)
|
|
#define REG_PU_DCDC1_DR (1 << 1)
|
|
#define REG_PU_DCDC1 (1 << 0)
|
|
|
|
#define REG_PU_LDO_VCORE_DR REG_PU_LDO_DIG_DR
|
|
#define REG_PU_LDO_VCORE_REG REG_PU_LDO_DIG_REG
|
|
|
|
// 19 PMU_REG_DCDC_ANA_CFG_19
|
|
#define DCDC2_IX2_ERR (1 << 15)
|
|
#define DCDC2_IX2_IRCOMP (1 << 14)
|
|
#define DCDC2_LP_ERR (1 << 13)
|
|
#define DCDC2_LP_VCOMP (1 << 12)
|
|
#define DCDC2_PULLDOWN_EN (1 << 11)
|
|
#define DCDC2_SLOPE_DOUBLE (1 << 10)
|
|
#define DCDC2_SLOPE_EN_BURST (1 << 9)
|
|
#define DCDC2_SOFT_START_EN (1 << 8)
|
|
#define DCDC2_SS_TIME_SEL (1 << 7)
|
|
#define DCDC2_SYNC_DISABLE (1 << 6)
|
|
#define DCDC2_TEST_MODE_EN (1 << 5)
|
|
#define DCDC2_ZCD_CAL_BIT_SHIFT 1
|
|
#define DCDC2_ZCD_CAL_BIT_MASK (0xF << DCDC2_ZCD_CAL_BIT_SHIFT)
|
|
#define DCDC2_ZCD_CAL_BIT(n) BITFIELD_VAL(DCDC2_ZCD_CAL_BIT, n)
|
|
#define DCDC2_REG_BYPASS (1 << 0)
|
|
|
|
// 1D PMU_REG_DCDC_HPPA_CFG_1D
|
|
#define DCDC3_IX2_ERR (1 << 15)
|
|
#define DCDC3_IX2_IRCOMP (1 << 14)
|
|
#define DCDC3_LP_ERR (1 << 13)
|
|
#define DCDC3_LP_VCOMP (1 << 12)
|
|
#define DCDC3_PULLDOWN_EN (1 << 11)
|
|
#define DCDC3_SLOPE_DOUBLE (1 << 10)
|
|
#define DCDC3_SLOPE_EN_BURST (1 << 9)
|
|
#define DCDC3_SOFT_START_EN (1 << 8)
|
|
#define DCDC3_SS_TIME_SEL (1 << 7)
|
|
#define DCDC3_SYNC_DISABLE (1 << 6)
|
|
#define DCDC3_TEST_MODE_EN (1 << 5)
|
|
#define DCDC3_ZCD_CAL_BIT_SHIFT 1
|
|
#define DCDC3_ZCD_CAL_BIT_MASK (0xF << DCDC3_ZCD_CAL_BIT_SHIFT)
|
|
#define DCDC3_ZCD_CAL_BIT(n) BITFIELD_VAL(DCDC3_ZCD_CAL_BIT, n)
|
|
#define DCDC3_REG_BYPASS (1 << 0)
|
|
|
|
// 21 PMU_REG_PWR_SEL
|
|
#define REG_PMU_VSEL1_SHIFT 13
|
|
#define REG_PMU_VSEL1_MASK (0x7 << REG_PMU_VSEL1_SHIFT)
|
|
#define REG_PMU_VSEL1(n) BITFIELD_VAL(REG_PMU_VSEL1, n)
|
|
#define REG_POWER_SEL_CNT_SHIFT 8
|
|
#define REG_POWER_SEL_CNT_MASK (0x1F << REG_POWER_SEL_CNT_SHIFT)
|
|
#define REG_POWER_SEL_CNT(n) BITFIELD_VAL(REG_POWER_SEL_CNT, n)
|
|
#define REG_PWR_SEL_DR (1 << 7)
|
|
#define REG_PWR_SEL (1 << 6)
|
|
#define CLK_BG_EN (1 << 5)
|
|
#define CLK_BG_DIV_VALUE_SHIFT 0
|
|
#define CLK_BG_DIV_VALUE_MASK (0x1F << CLK_BG_DIV_VALUE_SHIFT)
|
|
#define CLK_BG_DIV_VALUE(n) BITFIELD_VAL(CLK_BG_DIV_VALUE, n)
|
|
|
|
// 26 PMU_REG_INT_MASK
|
|
#define RESET_EN_VCORE_LOW (1 << 15)
|
|
#define RTC_INT1_MSK (1 << 14)
|
|
#define RTC_INT0_MSK (1 << 13)
|
|
#define KEY_ERR1_INTR_MSK (1 << 12)
|
|
#define KEY_ERR0_INTR_MSK (1 << 11)
|
|
#define KEY_PRESS_INTR_MSK (1 << 10)
|
|
#define KEY_RELEASE_INTR_MSK (1 << 9)
|
|
#define SAMPLE_DONE_INTR_MSK (1 << 8)
|
|
#define CHAN_DATA_INTR_MSK_SHIFT 0
|
|
#define CHAN_DATA_INTR_MSK_MASK (0xFF << CHAN_DATA_INTR_MSK_SHIFT)
|
|
#define CHAN_DATA_INTR_MSK(n) BITFIELD_VAL(CHAN_DATA_INTR_MSK, n)
|
|
|
|
// 27 PMU_REG_INT_EN
|
|
#define REG_BG_SLEEP_MSK (1 << 15)
|
|
#define RTC_INT_EN_1 (1 << 14)
|
|
#define RTC_INT_EN_0 (1 << 13)
|
|
#define KEY_ERR1_INTR_EN (1 << 12)
|
|
#define KEY_ERR0_INTR_EN (1 << 11)
|
|
#define KEY_PRESS_INTR_EN (1 << 10)
|
|
#define KEY_RELEASE_INTR_EN (1 << 9)
|
|
#define SAMPLE_DONE_INTR_EN (1 << 8)
|
|
#define CHAN_DATA_INTR_EN_SHIFT 0
|
|
#define CHAN_DATA_INTR_EN_MASK (0xFF << CHAN_DATA_INTR_EN_SHIFT)
|
|
#define CHAN_DATA_INTR_EN(n) BITFIELD_VAL(CHAN_DATA_INTR_EN, n)
|
|
|
|
// 36 PMU_REG_DCDC_DIG_CFG_36
|
|
#define DCDC1_IX2_ERR (1 << 15)
|
|
#define DCDC1_IX2_IRCOMP (1 << 14)
|
|
#define DCDC1_LP_ERR (1 << 13)
|
|
#define DCDC1_LP_VCOMP (1 << 12)
|
|
#define DCDC1_PULLDOWN_EN (1 << 11)
|
|
#define DCDC1_SLOPE_DOUBLE (1 << 10)
|
|
#define DCDC1_SLOPE_EN_BURST (1 << 9)
|
|
#define DCDC1_SOFT_START_EN (1 << 8)
|
|
#define DCDC1_SS_TIME_SEL (1 << 7)
|
|
#define DCDC1_SYNC_DISABLE (1 << 6)
|
|
#define DCDC1_TEST_MODE_EN (1 << 5)
|
|
#define DCDC1_ZCD_CAL_BIT_SHIFT 1
|
|
#define DCDC1_ZCD_CAL_BIT_MASK (0xF << DCDC1_ZCD_CAL_BIT_SHIFT)
|
|
#define DCDC1_ZCD_CAL_BIT(n) BITFIELD_VAL(DCDC1_ZCD_CAL_BIT, n)
|
|
#define DCDC1_REG_BYPASS (1 << 0)
|
|
|
|
// 38 PMU_REG_MIC_BIAS_E
|
|
#define REG_MIC_BIASE_CHANSEL_SHIFT 14
|
|
#define REG_MIC_BIASE_CHANSEL_MASK (0x3 << REG_MIC_BIASE_CHANSEL_SHIFT)
|
|
#define REG_MIC_BIASE_CHANSEL(n) BITFIELD_VAL(REG_MIC_BIASE_CHANSEL, n)
|
|
#define REG_MIC_BIASE_EN (1 << 13)
|
|
#define REG_MIC_BIASE_ENLPF (1 << 12)
|
|
#define REG_MIC_BIASE_LPFSEL_SHIFT 10
|
|
#define REG_MIC_BIASE_LPFSEL_MASK (0x3 << REG_MIC_BIASE_LPFSEL_SHIFT)
|
|
#define REG_MIC_BIASE_LPFSEL(n) BITFIELD_VAL(REG_MIC_BIASE_LPFSEL, n)
|
|
#define REG_MIC_BIASE_VSEL_SHIFT 5
|
|
#define REG_MIC_BIASE_VSEL_MASK (0x1F << REG_MIC_BIASE_VSEL_SHIFT)
|
|
#define REG_MIC_BIASE_VSEL(n) BITFIELD_VAL(REG_MIC_BIASE_VSEL, n)
|
|
#define REG_MIC_LDOE_RES_SHIFT 1
|
|
#define REG_MIC_LDOE_RES_MASK (0xF << REG_MIC_LDOE_RES_SHIFT)
|
|
#define REG_MIC_LDOE_RES(n) BITFIELD_VAL(REG_MIC_LDOE_RES, n)
|
|
#define REG_MIC_LDOE_LOOPCTRL (1 << 0)
|
|
|
|
// 39 PMU_REG_MIC_LDO_EN
|
|
#define REG_LED_IO1_AIO_EN (1 << 15)
|
|
#define REG_LED_IO2_AIO_EN (1 << 14)
|
|
#define REG_LED_IO1_RX_EN (1 << 13)
|
|
#define REG_LED_IO2_RX_EN (1 << 12)
|
|
#define REG_MIC_LDOA_EN (1 << 11)
|
|
#define REG_MIC_LDOB_EN (1 << 10)
|
|
#define REG_MIC_LDOC_EN (1 << 9)
|
|
#define REG_MIC_LDOD_EN (1 << 8)
|
|
#define REG_MIC_LDOE_EN (1 << 7)
|
|
#define DCDC1_OFFSET_CURRENT_EN (1 << 6)
|
|
#define DCDC2_OFFSET_CURRENT_EN (1 << 5)
|
|
#define DCDC3_OFFSET_CURRENT_EN (1 << 4)
|
|
#define DCDC4_OFFSET_CURRENT_EN (1 << 3)
|
|
|
|
// 3A PMU_REG_LED_CFG
|
|
#define REG_LED_IO1_IBIT_SHIFT 14
|
|
#define REG_LED_IO1_IBIT_MASK (0x3 << REG_LED_IO1_IBIT_SHIFT)
|
|
#define REG_LED_IO1_IBIT(n) BITFIELD_VAL(REG_LED_IO1_IBIT, n)
|
|
#define REG_LED_IO1_OENB (1 << 13)
|
|
#define REG_LED_IO1_PDEN (1 << 12)
|
|
#define REG_LED_IO1_PU (1 << 11)
|
|
#define REG_LED_IO1_PUEN (1 << 10)
|
|
#define REG_LED_IO1_SEL_SHIFT 8
|
|
#define REG_LED_IO1_SEL_MASK (0x3 << REG_LED_IO1_SEL_SHIFT)
|
|
#define REG_LED_IO1_SEL(n) BITFIELD_VAL(REG_LED_IO1_SEL, n)
|
|
#define REG_LED_IO2_IBIT_SHIFT 6
|
|
#define REG_LED_IO2_IBIT_MASK (0x3 << REG_LED_IO2_IBIT_SHIFT)
|
|
#define REG_LED_IO2_IBIT(n) BITFIELD_VAL(REG_LED_IO2_IBIT, n)
|
|
#define REG_LED_IO2_OENB (1 << 5)
|
|
#define REG_LED_IO2_PDEN (1 << 4)
|
|
#define REG_LED_IO2_PU (1 << 3)
|
|
#define REG_LED_IO2_PUEN (1 << 2)
|
|
#define REG_LED_IO2_SEL_SHIFT 0
|
|
#define REG_LED_IO2_SEL_MASK (0x3 << REG_LED_IO2_SEL_SHIFT)
|
|
#define REG_LED_IO2_SEL(n) BITFIELD_VAL(REG_LED_IO2_SEL, n)
|
|
|
|
// 3B PMU_REG_MIC_BIAS_A
|
|
#define REG_MIC_BIASA_CHANSEL_SHIFT 14
|
|
#define REG_MIC_BIASA_CHANSEL_MASK (0x3 << REG_MIC_BIASA_CHANSEL_SHIFT)
|
|
#define REG_MIC_BIASA_CHANSEL(n) BITFIELD_VAL(REG_MIC_BIASA_CHANSEL, n)
|
|
#define REG_MIC_BIASA_EN (1 << 13)
|
|
#define REG_MIC_BIASA_ENLPF (1 << 12)
|
|
#define REG_MIC_BIASA_LPFSEL_SHIFT 10
|
|
#define REG_MIC_BIASA_LPFSEL_MASK (0x3 << REG_MIC_BIASA_LPFSEL_SHIFT)
|
|
#define REG_MIC_BIASA_LPFSEL(n) BITFIELD_VAL(REG_MIC_BIASA_LPFSEL, n)
|
|
#define REG_MIC_BIASA_VSEL_SHIFT 5
|
|
#define REG_MIC_BIASA_VSEL_MASK (0x1F << REG_MIC_BIASA_VSEL_SHIFT)
|
|
#define REG_MIC_BIASA_VSEL(n) BITFIELD_VAL(REG_MIC_BIASA_VSEL, n)
|
|
#define REG_MIC_LDOA_RES_SHIFT 1
|
|
#define REG_MIC_LDOA_RES_MASK (0xF << REG_MIC_LDOA_RES_SHIFT)
|
|
#define REG_MIC_LDOA_RES(n) BITFIELD_VAL(REG_MIC_LDOA_RES, n)
|
|
#define REG_MIC_LDOA_LOOPCTRL (1 << 0)
|
|
|
|
// 3C PMU_REG_MIC_BIAS_B
|
|
#define REG_MIC_BIASB_CHANSEL_SHIFT 14
|
|
#define REG_MIC_BIASB_CHANSEL_MASK (0x3 << REG_MIC_BIASB_CHANSEL_SHIFT)
|
|
#define REG_MIC_BIASB_CHANSEL(n) BITFIELD_VAL(REG_MIC_BIASB_CHANSEL, n)
|
|
#define REG_MIC_BIASB_EN (1 << 13)
|
|
#define REG_MIC_BIASB_ENLPF (1 << 12)
|
|
#define REG_MIC_BIASB_LPFSEL_SHIFT 10
|
|
#define REG_MIC_BIASB_LPFSEL_MASK (0x3 << REG_MIC_BIASB_LPFSEL_SHIFT)
|
|
#define REG_MIC_BIASB_LPFSEL(n) BITFIELD_VAL(REG_MIC_BIASB_LPFSEL, n)
|
|
#define REG_MIC_BIASB_VSEL_SHIFT 5
|
|
#define REG_MIC_BIASB_VSEL_MASK (0x1F << REG_MIC_BIASB_VSEL_SHIFT)
|
|
#define REG_MIC_BIASB_VSEL(n) BITFIELD_VAL(REG_MIC_BIASB_VSEL, n)
|
|
#define REG_MIC_LDOB_RES_SHIFT 1
|
|
#define REG_MIC_LDOB_RES_MASK (0xF << REG_MIC_LDOB_RES_SHIFT)
|
|
#define REG_MIC_LDOB_RES(n) BITFIELD_VAL(REG_MIC_LDOB_RES, n)
|
|
#define REG_MIC_LDOB_LOOPCTRL (1 << 0)
|
|
|
|
// 3D PMU_REG_MIC_BIAS_C
|
|
#define REG_MIC_BIASC_CHANSEL_SHIFT 14
|
|
#define REG_MIC_BIASC_CHANSEL_MASK (0x3 << REG_MIC_BIASC_CHANSEL_SHIFT)
|
|
#define REG_MIC_BIASC_CHANSEL(n) BITFIELD_VAL(REG_MIC_BIASC_CHANSEL, n)
|
|
#define REG_MIC_BIASC_EN (1 << 13)
|
|
#define REG_MIC_BIASC_ENLPF (1 << 12)
|
|
#define REG_MIC_BIASC_LPFSEL_SHIFT 10
|
|
#define REG_MIC_BIASC_LPFSEL_MASK (0x3 << REG_MIC_BIASC_LPFSEL_SHIFT)
|
|
#define REG_MIC_BIASC_LPFSEL(n) BITFIELD_VAL(REG_MIC_BIASC_LPFSEL, n)
|
|
#define REG_MIC_BIASC_VSEL_SHIFT 5
|
|
#define REG_MIC_BIASC_VSEL_MASK (0x1F << REG_MIC_BIASC_VSEL_SHIFT)
|
|
#define REG_MIC_BIASC_VSEL(n) BITFIELD_VAL(REG_MIC_BIASC_VSEL, n)
|
|
#define REG_MIC_LDOC_RES_SHIFT 1
|
|
#define REG_MIC_LDOC_RES_MASK (0xF << REG_MIC_LDOC_RES_SHIFT)
|
|
#define REG_MIC_LDOC_RES(n) BITFIELD_VAL(REG_MIC_LDOC_RES, n)
|
|
#define REG_MIC_LDOC_LOOPCTRL (1 << 0)
|
|
|
|
// 3E PMU_REG_MIC_BIAS_D
|
|
#define REG_MIC_BIASD_CHANSEL_SHIFT 14
|
|
#define REG_MIC_BIASD_CHANSEL_MASK (0x3 << REG_MIC_BIASD_CHANSEL_SHIFT)
|
|
#define REG_MIC_BIASD_CHANSEL(n) BITFIELD_VAL(REG_MIC_BIASD_CHANSEL, n)
|
|
#define REG_MIC_BIASD_EN (1 << 13)
|
|
#define REG_MIC_BIASD_ENLPF (1 << 12)
|
|
#define REG_MIC_BIASD_LPFSEL_SHIFT 10
|
|
#define REG_MIC_BIASD_LPFSEL_MASK (0x3 << REG_MIC_BIASD_LPFSEL_SHIFT)
|
|
#define REG_MIC_BIASD_LPFSEL(n) BITFIELD_VAL(REG_MIC_BIASD_LPFSEL, n)
|
|
#define REG_MIC_BIASD_VSEL_SHIFT 5
|
|
#define REG_MIC_BIASD_VSEL_MASK (0x1F << REG_MIC_BIASD_VSEL_SHIFT)
|
|
#define REG_MIC_BIASD_VSEL(n) BITFIELD_VAL(REG_MIC_BIASD_VSEL, n)
|
|
#define REG_MIC_LDOD_RES_SHIFT 1
|
|
#define REG_MIC_LDOD_RES_MASK (0xF << REG_MIC_LDOD_RES_SHIFT)
|
|
#define REG_MIC_LDOD_RES(n) BITFIELD_VAL(REG_MIC_LDOD_RES, n)
|
|
#define REG_MIC_LDOD_LOOPCTRL (1 << 0)
|
|
|
|
// 3F PMU_REG_EFUSE_CTRL
|
|
#define TSMC_EFUSE_A_SHIFT 0
|
|
#define TSMC_EFUSE_A_MASK (0x3F << TSMC_EFUSE_A_SHIFT)
|
|
#define TSMC_EFUSE_A(n) BITFIELD_VAL(TSMC_EFUSE_A, n)
|
|
#define TSMC_EFUSE_CLK_EN (1 << 8)
|
|
#define TSMC_EFUSE_NR (1 << 9)
|
|
#define TSMC_EFUSE_MR (1 << 10)
|
|
#define MANUAL_MODE (1 << 11)
|
|
#define TSMC_EFUSE_PGENB (1 << 12)
|
|
#define REG_MARGIN_READ (1 << 13)
|
|
|
|
// 40 PMU_REG_EFUSE_SEL
|
|
#define TSMC_EFUSE_STROBE_TRIG (1 << 0)
|
|
#define TSMC_EFUSE_STROBE_WIDTH_SHIFT 1
|
|
#define TSMC_EFUSE_STROBE_WIDTH_MASK (0xFF << TSMC_EFUSE_STROBE_WIDTH_SHIFT)
|
|
#define TSMC_EFUSE_STROBE_WIDTH(n) BITFIELD_VAL(TSMC_EFUSE_STROBE_WIDTH, n)
|
|
#define REG_READ_STROBE_WIDTH_SHIFT 9
|
|
#define REG_READ_STROBE_WIDTH_MASK (0xF << REG_READ_STROBE_WIDTH_SHIFT)
|
|
#define REG_READ_STROBE_WIDTH(n) BITFIELD_VAL(REG_READ_STROBE_WIDTH, n)
|
|
#define EFUSE_SEL_SHIFT 13
|
|
#define EFUSE_SEL_MASK (0x7 << EFUSE_SEL_SHIFT)
|
|
#define EFUSE_SEL(n) BITFIELD_VAL(EFUSE_SEL, n)
|
|
|
|
// 41 PMU_REG_DCDC1_OFFSET
|
|
#define DCDC1_OFFSET_BIT_SHIFT 8
|
|
#define DCDC1_OFFSET_BIT_MASK (0xFF << DCDC1_OFFSET_BIT_SHIFT)
|
|
#define DCDC1_OFFSET_BIT(n) BITFIELD_VAL(DCDC1_OFFSET_BIT, n)
|
|
#define DCDC2_OFFSET_BIT_SHIFT 0
|
|
#define DCDC2_OFFSET_BIT_MASK (0xFF << DCDC2_OFFSET_BIT_SHIFT)
|
|
#define DCDC2_OFFSET_BIT(n) BITFIELD_VAL(DCDC2_OFFSET_BIT, n)
|
|
|
|
// 43 PMU_REG_BUCK2ANA_CFG
|
|
#define REG_PU_VBUCK2ANA_LDO_DR (1 << 15)
|
|
#define REG_PU_VBUCK2ANA_LDO (1 << 14)
|
|
#define LP_EN_VBUCK2ANA_LDO_DR (1 << 13)
|
|
#define LP_EN_VBUCK2ANA_LDO (1 << 12)
|
|
#define LDO_VBUCK2ANA_VBIT_DSLEEP_SHIFT 6
|
|
#define LDO_VBUCK2ANA_VBIT_DSLEEP_MASK (0x3F << LDO_VBUCK2ANA_VBIT_DSLEEP_SHIFT)
|
|
#define LDO_VBUCK2ANA_VBIT_DSLEEP(n) BITFIELD_VAL(LDO_VBUCK2ANA_VBIT_DSLEEP, n)
|
|
#define LDO_VBUCK2ANA_VBIT_NORMAL_SHIFT 0
|
|
#define LDO_VBUCK2ANA_VBIT_NORMAL_MASK (0x3F << LDO_VBUCK2ANA_VBIT_NORMAL_SHIFT)
|
|
#define LDO_VBUCK2ANA_VBIT_NORMAL(n) BITFIELD_VAL(LDO_VBUCK2ANA_VBIT_NORMAL, n)
|
|
|
|
#define REG_PU_LDO_VBUCK2ANA_DR REG_PU_VBUCK2ANA_LDO_DR
|
|
#define REG_PU_LDO_VBUCK2ANA_REG REG_PU_VBUCK2ANA_LDO
|
|
#define LP_EN_VBUCK2ANA_LDO_REG LP_EN_VBUCK2ANA_LDO
|
|
// No pu dsleep cfg
|
|
#define REG_PU_LDO_VBUCK2ANA_DSLEEP 0
|
|
|
|
// 44 PMU_REG_SLEEP_CFG
|
|
#define PMIC_TMODE_1300_SHIFT 0
|
|
#define PMIC_TMODE_1300_MASK (0x7 << PMIC_TMODE_1300_SHIFT)
|
|
#define PMIC_TMODE_1300(n) BITFIELD_VAL(PMIC_TMODE_1300, n)
|
|
#define POWERON_PRESS_EN (1 << 3)
|
|
#define POWERON_RELEASE_EN (1 << 4)
|
|
#define SLEEP_ALLOW (1 << 5)
|
|
#define REG_VHPPA2VCODEC_SLP_ON (1 << 6)
|
|
|
|
#define REG_PU_LDO_VHPPA2VCODEC_DSLEEP REG_VHPPA2VCODEC_SLP_ON
|
|
|
|
// 46 PMU_REG_DCDC_DIG_VOLT
|
|
#define REG_DCDC1_VBIT_DSLEEP_SHIFT 8
|
|
#define REG_DCDC1_VBIT_DSLEEP_MASK (0xFF << REG_DCDC1_VBIT_DSLEEP_SHIFT)
|
|
#define REG_DCDC1_VBIT_DSLEEP(n) BITFIELD_VAL(REG_DCDC1_VBIT_DSLEEP, n)
|
|
#define REG_DCDC1_VBIT_NORMAL_SHIFT 0
|
|
#define REG_DCDC1_VBIT_NORMAL_MASK (0xFF << REG_DCDC1_VBIT_NORMAL_SHIFT)
|
|
#define REG_DCDC1_VBIT_NORMAL(n) BITFIELD_VAL(REG_DCDC1_VBIT_NORMAL, n)
|
|
#define MAX_DCDC1_VBIT_VAL \
|
|
(REG_DCDC1_VBIT_NORMAL_MASK >> REG_DCDC1_VBIT_NORMAL_SHIFT)
|
|
|
|
// 47 PMU_REG_DCDC_ANA_VOLT
|
|
#define REG_DCDC2_VBIT_DSLEEP_SHIFT 8
|
|
#define REG_DCDC2_VBIT_DSLEEP_MASK (0xFF << REG_DCDC2_VBIT_DSLEEP_SHIFT)
|
|
#define REG_DCDC2_VBIT_DSLEEP(n) BITFIELD_VAL(REG_DCDC2_VBIT_DSLEEP, n)
|
|
#define REG_DCDC2_VBIT_NORMAL_SHIFT 0
|
|
#define REG_DCDC2_VBIT_NORMAL_MASK (0xFF << REG_DCDC2_VBIT_NORMAL_SHIFT)
|
|
#define REG_DCDC2_VBIT_NORMAL(n) BITFIELD_VAL(REG_DCDC2_VBIT_NORMAL, n)
|
|
#define MAX_DCDC2_VBIT_VAL \
|
|
(REG_DCDC2_VBIT_NORMAL_MASK >> REG_DCDC2_VBIT_NORMAL_SHIFT)
|
|
|
|
// 48 PMU_REG_DCDC_HPPA_VOLT
|
|
#define REG_DCDC3_VBIT_DSLEEP_SHIFT 8
|
|
#define REG_DCDC3_VBIT_DSLEEP_MASK (0xFF << REG_DCDC3_VBIT_DSLEEP_SHIFT)
|
|
#define REG_DCDC3_VBIT_DSLEEP(n) BITFIELD_VAL(REG_DCDC3_VBIT_DSLEEP, n)
|
|
#define REG_DCDC3_VBIT_NORMAL_SHIFT 0
|
|
#define REG_DCDC3_VBIT_NORMAL_MASK (0xFF << REG_DCDC3_VBIT_NORMAL_SHIFT)
|
|
#define REG_DCDC3_VBIT_NORMAL(n) BITFIELD_VAL(REG_DCDC3_VBIT_NORMAL, n)
|
|
#define MAX_DCDC3_VBIT_VAL \
|
|
(REG_DCDC3_VBIT_NORMAL_MASK >> REG_DCDC3_VBIT_NORMAL_SHIFT)
|
|
|
|
// 49 PMU_REG_DCDC4_VOLT
|
|
#define REG_DCDC4_VBIT_DSLEEP_SHIFT 8
|
|
#define REG_DCDC4_VBIT_DSLEEP_MASK (0xFF << REG_DCDC4_VBIT_DSLEEP_SHIFT)
|
|
#define REG_DCDC4_VBIT_DSLEEP(n) BITFIELD_VAL(REG_DCDC4_VBIT_DSLEEP, n)
|
|
#define REG_DCDC4_VBIT_NORMAL_SHIFT 0
|
|
#define REG_DCDC4_VBIT_NORMAL_MASK (0xFF << REG_DCDC4_VBIT_NORMAL_SHIFT)
|
|
#define REG_DCDC4_VBIT_NORMAL(n) BITFIELD_VAL(REG_DCDC4_VBIT_NORMAL, n)
|
|
|
|
// 4A PMU_REG_DCDC_ANA_EN
|
|
#define REG_DCDC2_PFM_SEL_DSLEEP (1 << 11)
|
|
#define REG_DCDC2_PFM_SEL_NORMAL (1 << 10)
|
|
#define REG_DCDC2_ULP_MODE_DSLEEP (1 << 9)
|
|
#define REG_DCDC2_ULP_MODE_NORMAL (1 << 8)
|
|
#define REG_DCDC2_BURST_MODE_SEL_DSLEEP (1 << 7)
|
|
#define REG_DCDC2_BURST_MODE_SEL_NORMAL (1 << 6)
|
|
#define REG_DCDC2_VREF_SEL_DSLEEP_SHIFT 4
|
|
#define REG_DCDC2_VREF_SEL_DSLEEP_MASK (0x3 << REG_DCDC2_VREF_SEL_DSLEEP_SHIFT)
|
|
#define REG_DCDC2_VREF_SEL_DSLEEP(n) BITFIELD_VAL(REG_DCDC2_VREF_SEL_DSLEEP, n)
|
|
#define REG_DCDC2_VREF_SEL_NORMAL_SHIFT 2
|
|
#define REG_DCDC2_VREF_SEL_NORMAL_MASK (0x3 << REG_DCDC2_VREF_SEL_NORMAL_SHIFT)
|
|
#define REG_DCDC2_VREF_SEL_NORMAL(n) BITFIELD_VAL(REG_DCDC2_VREF_SEL_NORMAL, n)
|
|
#define REG_PU_DCDC2_DR (1 << 1)
|
|
#define REG_PU_DCDC2 (1 << 0)
|
|
|
|
// 4B PMU_REG_DCDC_HPPA_EN
|
|
#define REG_DCDC3_PFM_SEL_DSLEEP (1 << 11)
|
|
#define REG_DCDC3_PFM_SEL_NORMAL (1 << 10)
|
|
#define REG_DCDC3_ULP_MODE_DSLEEP (1 << 9)
|
|
#define REG_DCDC3_ULP_MODE_NORMAL (1 << 8)
|
|
#define REG_DCDC3_BURST_MODE_SEL_DSLEEP (1 << 7)
|
|
#define REG_DCDC3_BURST_MODE_SEL_NORMAL (1 << 6)
|
|
#define REG_DCDC3_VREF_SEL_DSLEEP_SHIFT 4
|
|
#define REG_DCDC3_VREF_SEL_DSLEEP_MASK (0x3 << REG_DCDC3_VREF_SEL_DSLEEP_SHIFT)
|
|
#define REG_DCDC3_VREF_SEL_DSLEEP(n) BITFIELD_VAL(REG_DCDC3_VREF_SEL_DSLEEP, n)
|
|
#define REG_DCDC3_VREF_SEL_NORMAL_SHIFT 2
|
|
#define REG_DCDC3_VREF_SEL_NORMAL_MASK (0x3 << REG_DCDC3_VREF_SEL_NORMAL_SHIFT)
|
|
#define REG_DCDC3_VREF_SEL_NORMAL(n) BITFIELD_VAL(REG_DCDC3_VREF_SEL_NORMAL, n)
|
|
#define REG_PU_DCDC3_DR (1 << 1)
|
|
#define REG_PU_DCDC3 (1 << 0)
|
|
|
|
// 4C PMU_REG_DCDC4_EN
|
|
#define REG_DCDC4_PFM_SEL_DSLEEP (1 << 11)
|
|
#define REG_DCDC4_PFM_SEL_NORMAL (1 << 10)
|
|
#define REG_DCDC4_ULP_MODE_DSLEEP (1 << 9)
|
|
#define REG_DCDC4_ULP_MODE_NORMAL (1 << 8)
|
|
#define REG_DCDC4_BURST_MODE_SEL_DSLEEP (1 << 7)
|
|
#define REG_DCDC4_BURST_MODE_SEL_NORMAL (1 << 6)
|
|
#define REG_DCDC4_VREF_SEL_DSLEEP_SHIFT 4
|
|
#define REG_DCDC4_VREF_SEL_DSLEEP_MASK (0x3 << REG_DCDC4_VREF_SEL_DSLEEP_SHIFT)
|
|
#define REG_DCDC4_VREF_SEL_DSLEEP(n) BITFIELD_VAL(REG_DCDC4_VREF_SEL_DSLEEP, n)
|
|
#define REG_DCDC4_VREF_SEL_NORMAL_SHIFT 2
|
|
#define REG_DCDC4_VREF_SEL_NORMAL_MASK (0x3 << REG_DCDC4_VREF_SEL_NORMAL_SHIFT)
|
|
#define REG_DCDC4_VREF_SEL_NORMAL(n) BITFIELD_VAL(REG_DCDC4_VREF_SEL_NORMAL, n)
|
|
#define REG_PU_DCDC4_DR (1 << 1)
|
|
#define REG_PU_DCDC4 (1 << 0)
|
|
|
|
// 4F PMU_REG_POWER_OFF
|
|
#define SOFT_POWER_OFF (1 << 0)
|
|
#define HARDWARE_POWER_OFF_EN (1 << 1)
|
|
#define AC_ON_EN (1 << 2)
|
|
#define RC_CAL_READY (1 << 3)
|
|
#define KEY_START (1 << 4)
|
|
#define GPADC_START (1 << 5)
|
|
#define EFUSE_READ_DONE (1 << 6)
|
|
#define EFUSE_READ_BUSY (1 << 7)
|
|
#define VBAT_OVP (1 << 8)
|
|
#define VCORE_LOW (1 << 9)
|
|
#define REG_LED_IO1_DATA_IN (1 << 10)
|
|
#define REG_LED_IO2_DATA_IN (1 << 11)
|
|
#define RD_EFUSE_REG (1 << 12)
|
|
#define REG_WDT_LOAD (1 << 13)
|
|
|
|
#define EFUSE_READ_TRIG_SHIFT (12)
|
|
#define EFUSE_READ_TRIG_MASK (0xF << EFUSE_READ_TRIG_SHIFT)
|
|
#define EFUSE_READ_TRIG(n) BITFIELD_VAL(EFUSE_READ_TRIG, n)
|
|
#define EFUSE_READ_TRIG_WORD (0xA)
|
|
|
|
// 52 PMU_REG_INT_STATUS
|
|
#define RD_RES1 (1 << 15)
|
|
#define RTC_INT_1 (1 << 14)
|
|
#define RTC_INT_0 (1 << 13)
|
|
#define KEY_ERR1_INTR (1 << 12)
|
|
#define KEY_ERR0_INTR (1 << 11)
|
|
#define KEY_PRESS_INTR (1 << 10)
|
|
#define KEY_RELEASE_INTR (1 << 9)
|
|
#define SAMPLE_PERIOD_DONE_INTR (1 << 8)
|
|
#define CHAN_DATA_VALID_INTR_SHIFT 0
|
|
#define CHAN_DATA_VALID_INTR_MASK (0xFF << CHAN_DATA_VALID_INTR_SHIFT)
|
|
#define CHAN_DATA_VALID_INTR(n) BITFIELD_VAL(CHAN_DATA_VALID_INTR, n)
|
|
|
|
// 53 PMU_REG_INT_MSKED_STATUS
|
|
// 51 PMU_REG_INT_CLR
|
|
#define PMIC_CODEC_PWM (1 << 15)
|
|
#define RTC_INT1_MSKED (1 << 14)
|
|
#define RTC_INT0_MSKED (1 << 13)
|
|
#define KEY_ERR1_INTR_MSKED (1 << 12)
|
|
#define KEY_ERR0_INTR_MSKED (1 << 11)
|
|
#define KEY_PRESS_INTR_MSKED (1 << 10)
|
|
#define KEY_RELEASE_INTR_MSKED (1 << 9)
|
|
#define SAMPLE_DONE_INTR_MSKED (1 << 8)
|
|
#define CHAN_DATA_INTR_MSKED_SHIFT 0
|
|
#define CHAN_DATA_INTR_MSKED_MASK (0xFF << CHAN_DATA_INTR_MSKED_SHIFT)
|
|
#define CHAN_DATA_INTR_MSKED(n) BITFIELD_VAL(CHAN_DATA_INTR_MSKED, n)
|
|
|
|
// 5E PMU_REG_CHARGER_STATUS
|
|
#define DIG_PU_VHPPA (1 << 15)
|
|
#define DIG_PU_VRTC_RF (1 << 14)
|
|
#define DIG_PU_VCODEC (1 << 13)
|
|
#define DIG_PU_VUSB (1 << 12)
|
|
#define POWER_ON_RELEASE (1 << 11)
|
|
#define POWER_ON_PRESS (1 << 10)
|
|
#define POWER_ON (1 << 9)
|
|
#define DEEPSLEEP_MODE (1 << 8)
|
|
// #define PMU_LDO_ON (1 << 7)
|
|
#define PU_OSC_OUT (1 << 6)
|
|
#define UVLO_LV (1 << 5)
|
|
#define AC_ON_DET_OUT_MASKED (1 << 4)
|
|
#define AC_ON_DET_IN_MASKED (1 << 3)
|
|
#define AC_ON (1 << 2)
|
|
#define AC_ON_DET_OUT (1 << 1)
|
|
#define AC_ON_DET_IN (1 << 0)
|
|
|
|
// 77 PMU_REG_ANA_77
|
|
#define REG_AUDPLL_DIVN_SHIFT 0
|
|
#define REG_AUDPLL_DIVN_MASK (0x1F << REG_AUDPLL_DIVN_SHIFT)
|
|
#define REG_AUDPLL_DIVN(n) BITFIELD_VAL(REG_AUDPLL_DIVN, n)
|
|
#define REG_AUDPLL_DIVN_RST (1 << 5)
|
|
#define REG_AUDPLL_DIV_DR (1 << 6)
|
|
#define REG_AUDPLL_EN_CLKA (1 << 7)
|
|
#define REG_AUDPLL_EN_CLKD (1 << 8)
|
|
#define REG_AUDPLL_FORCE_LK (1 << 9)
|
|
#define REG_AUDPLL_LK_ERR23 (1 << 10)
|
|
#define REG_AUDPLL_LK_LONG (1 << 11)
|
|
#define REG_AUDPLL_LK_RSTB (1 << 12)
|
|
#define REG_AUDPLL_LK_WIN_SHIFT 13
|
|
#define REG_AUDPLL_LK_WIN_MASK (0x7 << REG_AUDPLL_LK_WIN_SHIFT)
|
|
#define REG_AUDPLL_LK_WIN(n) BITFIELD_VAL(REG_AUDPLL_LK_WIN, n)
|
|
|
|
// 101 PMU_REG_DCDC_RAMP_EN
|
|
#define REG_MIC_BIASA_IX2 (1 << 15)
|
|
#define REG_MIC_BIASB_IX2 (1 << 14)
|
|
#define REG_MIC_BIASC_IX2 (1 << 13)
|
|
#define REG_MIC_BIASD_IX2 (1 << 12)
|
|
#define REG_MIC_BIASE_IX2 (1 << 11)
|
|
#define REG_PULLDOWN_VGP (1 << 10)
|
|
#define REG_PU_LDO_DIG_DSLEEP (1 << 9)
|
|
#define LDO_VHPPA2VCODEC_BYPASS (1 << 8)
|
|
#define LDO_VGP_LV_MODE (1 << 7)
|
|
#define IPTAT_EN (1 << 6)
|
|
#define REG_PU_AVDD25_ANA (1 << 5)
|
|
#define REG_DCDC1_RAMP_EN (1 << 4)
|
|
#define REG_DCDC2_RAMP_EN (1 << 3)
|
|
#define REG_DCDC3_RAMP_EN (1 << 2)
|
|
#define REG_PU_VMEM_DELAY_DR (1 << 1)
|
|
#define REG_PU_VMEM_DELAY (1 << 0)
|
|
|
|
// 107 PMU_REG_SUBCNT_DATA
|
|
#define SUBCNT_DATA2_SHIFT 8
|
|
#define SUBCNT_DATA2_MASK (0xFF << SUBCNT_DATA2_SHIFT)
|
|
#define SUBCNT_DATA2(n) BITFIELD_VAL(SUBCNT_DATA2, n)
|
|
#define SUBCNT_DATA3_SHIFT 0
|
|
#define SUBCNT_DATA3_MASK (0xFF << SUBCNT_DATA3_SHIFT)
|
|
#define SUBCNT_DATA3(n) BITFIELD_VAL(SUBCNT_DATA3, n)
|
|
|
|
// 108 PMU_REG_PWM_BR_EN
|
|
#define TG_SUBCNT_D2_ST_SHIFT 9
|
|
#define TG_SUBCNT_D2_ST_MASK (0x7F << TG_SUBCNT_D2_ST_SHIFT)
|
|
#define TG_SUBCNT_D2_ST(n) BITFIELD_VAL(TG_SUBCNT_D2_ST, n)
|
|
#define REG_PWM2_BR_EN (1 << 8)
|
|
#define TG_SUBCNT_D3_ST_SHIFT 1
|
|
#define TG_SUBCNT_D3_ST_MASK (0x7F << TG_SUBCNT_D3_ST_SHIFT)
|
|
#define TG_SUBCNT_D3_ST(n) BITFIELD_VAL(TG_SUBCNT_D3_ST, n)
|
|
#define REG_PWM3_BR_EN (1 << 0)
|
|
|
|
// 109 PMU_REG_PWM_EN
|
|
#define REG_LED0_OUT (1 << 15)
|
|
#define REG_LED1_OUT (1 << 14)
|
|
#define PWM_SELECT_EN_SHIFT 12
|
|
#define PWM_SELECT_EN_MASK (0x3 << PWM_SELECT_EN_SHIFT)
|
|
#define PWM_SELECT_EN(n) BITFIELD_VAL(PWM_SELECT_EN, n)
|
|
#define PWM_SELECT_INV_SHIFT 10
|
|
#define PWM_SELECT_INV_MASK (0x3 << PWM_SELECT_INV_SHIFT)
|
|
#define PWM_SELECT_INV(n) BITFIELD_VAL(PWM_SELECT_INV, n)
|
|
#define REG_CLK_PWM_DIV_SHIFT 5
|
|
#define REG_CLK_PWM_DIV_MASK (0x1F << REG_CLK_PWM_DIV_SHIFT)
|
|
#define REG_CLK_PWM_DIV(n) BITFIELD_VAL(REG_CLK_PWM_DIV, n)
|
|
|
|
// 10B PMU_REG_WDT_TIMER
|
|
#define REG_WDT_TIMER_SHIFT 0
|
|
#define REG_WDT_TIMER_MASK (0xFFFF << REG_WDT_TIMER_SHIFT)
|
|
#define REG_WDT_TIMER(n) BITFIELD_VAL(REG_WDT_TIMER, n)
|
|
|
|
// 10C PMU_REG_WDT_CFG
|
|
#define REG_HW_RESET_TIME_SHIFT 10
|
|
#define REG_HW_RESET_TIME_MASK (0x3F << REG_HW_RESET_TIME_SHIFT)
|
|
#define REG_HW_RESET_TIME(n) BITFIELD_VAL(REG_HW_RESET_TIME, n)
|
|
#define REG_HW_RESET_EN (1 << 9)
|
|
#define REG_WDT_RESET_EN (1 << 8)
|
|
#define REG_WDT_EN (1 << 7)
|
|
#define BG_R_TEMP_SHIFT 4
|
|
#define BG_R_TEMP_MASK (0x7 << BG_R_TEMP_SHIFT)
|
|
#define BG_R_TEMP(n) BITFIELD_VAL(BG_R_TEMP, n)
|
|
#define BG_TRIM_VBG_SHIFT 1
|
|
#define BG_TRIM_VBG_MASK (0x7 << BG_TRIM_VBG_SHIFT)
|
|
#define BG_TRIM_VBG(n) BITFIELD_VAL(BG_TRIM_VBG, n)
|
|
#define SAR_PU_OVP (1 << 0)
|
|
|
|
// 80 PMU_REG_RF_80
|
|
#define RF_80_PAGE_IDX (1 << 15)
|
|
#define RF_80_S_DONE_SHIFT 4
|
|
#define RF_80_S_DONE_MASK (0x7FF << RF_80_S_DONE_SHIFT)
|
|
#define RF_80_S_DONE(n) BITFIELD_VAL(RF_80_S_DONE, n)
|
|
#define RF_80_REVID_SHIFT 0
|
|
#define RF_80_REVID_MASK (0xF << RF_80_REVID_SHIFT)
|
|
#define RF_80_REVID(n) BITFIELD_VAL(RF_80_REVID, n)
|
|
|
|
// BD PMU_REG_RF_BD
|
|
#define REG_BBPLL_FREQ_34_32_SHIFT 0
|
|
#define REG_BBPLL_FREQ_34_32_MASK (0x7 << REG_BBPLL_FREQ_34_32_SHIFT)
|
|
#define REG_BBPLL_FREQ_34_32(n) BITFIELD_VAL(REG_BBPLL_FREQ_34_32, n)
|
|
#define REG_BBPLL_FREQ_EN (1 << 3)
|
|
|
|
enum PMU_REG_T {
|
|
PMU_REG_METAL_ID = 0x00,
|
|
PMU_REG_POWER_KEY_CFG = 0x02,
|
|
PMU_REG_BIAS_CFG = 0x03,
|
|
PMU_REG_CHARGER_CFG = 0x05,
|
|
PMU_REG_ANA_CFG = 0x07,
|
|
PMU_REG_DIG_CFG = 0x08,
|
|
PMU_REG_IO_CFG = 0x09,
|
|
PMU_REG_MEM_CFG = 0x0A,
|
|
PMU_REG_GP_CFG = 0x0B,
|
|
PMU_REG_USB_CFG = 0x0C,
|
|
PMU_REG_BAT2DIG_CFG = 0x0D,
|
|
PMU_REG_HPPA_LDO_EN = 0x0E,
|
|
PMU_REG_HPPA2CODEC_CFG = 0x0F,
|
|
PMU_REG_CODEC_CFG = 0x10,
|
|
PMU_REG_DCDC_DIG_EN = 0x15,
|
|
PMU_REG_DCDC_ANA_CFG_16 = 0x16,
|
|
PMU_REG_DCDC_ANA_CFG_17 = 0x17,
|
|
PMU_REG_DCDC_ANA_CFG_18 = 0x18,
|
|
PMU_REG_DCDC_ANA_CFG_19 = 0x19,
|
|
PMU_REG_DCDC_HPPA_CFG_1A = 0x1A,
|
|
PMU_REG_DCDC_HPPA_CFG_1B = 0x1B,
|
|
PMU_REG_DCDC_HPPA_CFG_1C = 0x1C,
|
|
PMU_REG_DCDC_HPPA_CFG_1D = 0x1D,
|
|
PMU_REG_PWR_SEL = 0x21,
|
|
PMU_REG_INT_MASK = 0x26,
|
|
PMU_REG_INT_EN = 0x27,
|
|
PMU_REG_RTC_LOAD_LOW = 0x2D,
|
|
PMU_REG_RTC_LOAD_HIGH = 0x2E,
|
|
PMU_REG_RTC_MATCH1_LOW = 0x31,
|
|
PMU_REG_RTC_MATCH1_HIGH = 0x32,
|
|
PMU_REG_DCDC_DIG_CFG_33 = 0x33,
|
|
PMU_REG_DCDC_DIG_CFG_34 = 0x34,
|
|
PMU_REG_DCDC_DIG_CFG_35 = 0x35,
|
|
PMU_REG_DCDC_DIG_CFG_36 = 0x36,
|
|
PMU_REG_RTC_DIV_1HZ = 0x37,
|
|
PMU_REG_MIC_BIAS_E = 0x38,
|
|
PMU_REG_MIC_LDO_EN = 0x39,
|
|
PMU_REG_LED_CFG = 0x3A,
|
|
PMU_REG_MIC_BIAS_A = 0x3B,
|
|
PMU_REG_MIC_BIAS_B = 0x3C,
|
|
PMU_REG_MIC_BIAS_C = 0x3D,
|
|
PMU_REG_MIC_BIAS_D = 0x3E,
|
|
PMU_REG_EFUSE_CTRL = 0x3F,
|
|
PMU_REG_EFUSE_SEL = 0x40,
|
|
PMU_REG_DCDC1_OFFSET = 0x41,
|
|
PMU_REG_BUCK2ANA_CFG = 0x43,
|
|
PMU_REG_SLEEP_CFG = 0x44,
|
|
PMU_REG_DCDC_DIG_VOLT = 0x46,
|
|
PMU_REG_DCDC_ANA_VOLT = 0x47,
|
|
PMU_REG_DCDC_HPPA_VOLT = 0x48,
|
|
PMU_REG_DCDC4_VOLT = 0x49,
|
|
PMU_REG_DCDC_ANA_EN = 0x4A,
|
|
PMU_REG_DCDC_HPPA_EN = 0x4B,
|
|
PMU_REG_POWER_OFF = 0x4F,
|
|
PMU_REG_INT_CLR = 0x51,
|
|
PMU_REG_INT_STATUS = 0x52,
|
|
PMU_REG_INT_MSKED_STATUS = 0x53,
|
|
PMU_REG_RTC_VAL_LOW = 0x54,
|
|
PMU_REG_RTC_VAL_HIGH = 0x55,
|
|
PMU_REG_CHARGER_STATUS = 0x5E,
|
|
|
|
PMU_REG_DCDC_RAMP_EN = 0x101,
|
|
|
|
PMU_REG_PWM2_TOGGLE = 0x103,
|
|
PMU_REG_PWM3_TOGGLE = 0x104,
|
|
PMU_REG_PWM2_ST1 = 0x105,
|
|
PMU_REG_PWM3_ST1 = 0x106,
|
|
PMU_REG_SUBCNT_DATA = 0x107,
|
|
PMU_REG_PWM_BR_EN = 0x108,
|
|
PMU_REG_PWM_EN = 0x109,
|
|
|
|
PMU_REG_WDT_TIMER = 0x10B,
|
|
PMU_REG_WDT_CFG = 0x10C,
|
|
|
|
PMU_REG_MODULE_START = PMU_REG_ANA_CFG,
|
|
PMU_REG_EFUSE_VAL_START = 0x148,
|
|
|
|
PMU_REG_ANA_60 = 0x60,
|
|
PMU_REG_ANA_77 = 0x77,
|
|
|
|
PMU_REG_RF_80 = 0x80,
|
|
PMU_REG_RF_B5 = 0xB5,
|
|
PMU_REG_RF_BB = 0xBB,
|
|
PMU_REG_RF_BC = 0xBC,
|
|
PMU_REG_RF_BD = 0xBD,
|
|
};
|
|
|
|
enum PMU_VCORE_REQ_T {
|
|
PMU_VCORE_FLASH_WRITE_ENABLED = (1 << 0),
|
|
PMU_VCORE_FLASH_FREQ_HIGH = (1 << 1),
|
|
PMU_VCORE_PSRAM_FREQ_HIGH = (1 << 2),
|
|
PMU_VCORE_USB_HS_ENABLED = (1 << 3),
|
|
PMU_VCORE_RS_FREQ_HIGH = (1 << 4),
|
|
PMU_VCORE_SYS_FREQ_MEDIUM = (1 << 5),
|
|
PMU_VCORE_SYS_FREQ_HIGH = (1 << 6),
|
|
};
|
|
|
|
enum PMU_VUSB_REQ_T {
|
|
PMU_VUSB_REQ_INIT = (1 << 0),
|
|
PMU_VUSB_REQ_USB = (1 << 1),
|
|
PMU_VUSB_REQ_LBRT = (1 << 2),
|
|
};
|
|
|
|
union BOOT_SETTINGS_T {
|
|
struct {
|
|
unsigned short usb_dld_dis : 1;
|
|
unsigned short uart_dld_en : 1;
|
|
unsigned short uart_trace_en : 1;
|
|
unsigned short pll_dis : 1;
|
|
unsigned short uart_baud_div2 : 1;
|
|
unsigned short sec_freq_div2 : 1;
|
|
unsigned short crystal_freq : 2;
|
|
unsigned short reserved : 4;
|
|
unsigned short chksum : 4;
|
|
};
|
|
unsigned short reg;
|
|
};
|
|
|
|
enum PMU_MODUAL_T {
|
|
PMU_ANA,
|
|
PMU_DIG,
|
|
PMU_IO,
|
|
PMU_MEM,
|
|
PMU_GP,
|
|
PMU_USB,
|
|
PMU_BAT2DIG,
|
|
PMU_HPPA2CODEC,
|
|
PMU_CODEC,
|
|
PMU_BUCK2ANA,
|
|
};
|
|
|
|
struct PMU_MODULE_CFG_T {
|
|
unsigned short pu_dr;
|
|
unsigned short pu;
|
|
unsigned short lp_en_dr;
|
|
unsigned short lp_en;
|
|
unsigned short pu_dsleep;
|
|
unsigned short vbit_dsleep_mask;
|
|
unsigned short vbit_dsleep_shift;
|
|
unsigned short vbit_normal_mask;
|
|
unsigned short vbit_normal_shift;
|
|
};
|
|
|
|
#define PMU_MOD_CFG_VAL(m) \
|
|
{ \
|
|
REG_PU_LDO_V##m##_DR, REG_PU_LDO_V##m##_REG, LP_EN_V##m##_LDO_DR, \
|
|
LP_EN_V##m##_LDO_REG, REG_PU_LDO_V##m##_DSLEEP, \
|
|
LDO_V##m##_VBIT_DSLEEP_MASK, LDO_V##m##_VBIT_DSLEEP_SHIFT, \
|
|
LDO_V##m##_VBIT_NORMAL_MASK, LDO_V##m##_VBIT_NORMAL_SHIFT \
|
|
}
|
|
|
|
static const struct PMU_MODULE_CFG_T pmu_module_cfg[] = {
|
|
PMU_MOD_CFG_VAL(ANA), PMU_MOD_CFG_VAL(CORE),
|
|
PMU_MOD_CFG_VAL(IO), PMU_MOD_CFG_VAL(MEM),
|
|
PMU_MOD_CFG_VAL(GP), PMU_MOD_CFG_VAL(USB),
|
|
PMU_MOD_CFG_VAL(BAT2VCORE), PMU_MOD_CFG_VAL(HPPA2VCODEC),
|
|
PMU_MOD_CFG_VAL(CODEC), PMU_MOD_CFG_VAL(BUCK2ANA),
|
|
};
|
|
|
|
#ifdef ANC_PROD_TEST
|
|
#define OPT_TYPE
|
|
#else
|
|
#define OPT_TYPE const
|
|
#endif
|
|
|
|
static OPT_TYPE bool vcodec_off =
|
|
#ifdef VCODEC_OFF
|
|
true;
|
|
#else
|
|
false;
|
|
#endif
|
|
static OPT_TYPE uint8_t ana_act_dcdc =
|
|
#ifdef VANA_1P2V
|
|
PMU_DCDC_ANA_1_2V;
|
|
#elif defined(VANA_1P35V)
|
|
PMU_DCDC_ANA_1_35V;
|
|
#elif defined(VANA_1P4V)
|
|
PMU_DCDC_ANA_1_4V;
|
|
#elif defined(VANA_1P5V)
|
|
PMU_DCDC_ANA_1_5V;
|
|
#elif defined(VANA_1P6V)
|
|
PMU_DCDC_ANA_1_6V;
|
|
#else
|
|
PMU_DCDC_ANA_1_3V;
|
|
#endif
|
|
static OPT_TYPE POSSIBLY_UNUSED uint16_t vcodec_mv =
|
|
(uint16_t)(VCODEC_VOLT * 1000);
|
|
static OPT_TYPE POSSIBLY_UNUSED uint16_t vhppa_mv =
|
|
(uint16_t)(VHPPA_VOLT * 1000);
|
|
|
|
static enum HAL_CHIP_METAL_ID_T BOOT_BSS_LOC pmu_metal_id;
|
|
|
|
static enum PMU_POWER_MODE_T BOOT_BSS_LOC pmu_power_mode = PMU_POWER_MODE_NONE;
|
|
|
|
static enum PMU_VCORE_REQ_T BOOT_BSS_LOC pmu_vcore_req;
|
|
|
|
// Move all the data/bss invovled in pmu_open() to .sram_data/.sram_bss,
|
|
// so that pmu_open() can be called at the end of BootInit(),
|
|
// for data/bss is initialized after BootInit().
|
|
static enum PMU_VUSB_REQ_T SRAM_BSS_DEF(pmu_vusb_req);
|
|
|
|
static uint16_t SRAM_BSS_DEF(dcdc_ramp_map);
|
|
|
|
static PMU_CHARGER_IRQ_HANDLER_T charger_irq_handler;
|
|
|
|
static PMU_IRQ_UNIFIED_HANDLER_T pmu_irq_hdlrs[PMU_IRQ_TYPE_QTY];
|
|
|
|
static uint8_t SRAM_BSS_DEF(vio_risereq_map);
|
|
STATIC_ASSERT(sizeof(vio_risereq_map) * 8 >= PMU_VIORISE_REQ_USER_QTY,
|
|
"vio_risereq_map size too small");
|
|
|
|
static uint8_t SRAM_DATA_DEF(vio_act_normal) = IO_VOLT_ACTIVE_NORMAL;
|
|
static uint8_t SRAM_DATA_DEF(vio_act_rise) = IO_VOLT_ACTIVE_RISE;
|
|
static uint8_t SRAM_DATA_DEF(vio_lp) = IO_VOLT_SLEEP;
|
|
|
|
static const uint8_t ana_lp_dcdc = PMU_DCDC_ANA_SLEEP_1_3V;
|
|
|
|
// BT might have connection drop issues if dig_lp is lower than 0.8V
|
|
static const uint8_t dig_lp_ldo = PMU_VDIG_0_8V;
|
|
static const uint8_t dig_lp_dcdc = PMU_DCDC_DIG_0_8V;
|
|
|
|
static uint8_t BOOT_DATA_DEF(audpll_codec_div) = 16;
|
|
|
|
#ifdef HIGH_VCORE
|
|
static const bool high_vcore = true;
|
|
#else
|
|
static bool BOOT_BSS_DEF(high_vcore);
|
|
#endif
|
|
|
|
static uint16_t wdt_timer;
|
|
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
static const uint16_t high_perf_freq_mhz =
|
|
#if defined(MTEST_ENABLED) && defined(MTEST_CLK_MHZ)
|
|
MTEST_CLK_MHZ;
|
|
#else
|
|
300;
|
|
#endif
|
|
static bool high_perf_on;
|
|
#endif
|
|
|
|
void pmu_wdt_save_context(void);
|
|
void pmu_wdt_restore_context(void);
|
|
void pmu_charger_save_context(void);
|
|
void pmu_charger_shutdown_config(void);
|
|
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
static void pmu_hppa_dcdc_to_ldo(void);
|
|
#endif
|
|
|
|
#if defined(_AUTO_TEST_)
|
|
static bool at_skip_shutdown = false;
|
|
|
|
void pmu_at_skip_shutdown(bool enable) { at_skip_shutdown = enable; }
|
|
#endif
|
|
|
|
#ifdef RTC_ENABLE
|
|
struct PMU_RTC_CTX_T {
|
|
bool enabled;
|
|
bool alarm_set;
|
|
uint32_t alarm_val;
|
|
};
|
|
|
|
static struct PMU_RTC_CTX_T BOOT_BSS_LOC rtc_ctx;
|
|
|
|
static PMU_RTC_IRQ_HANDLER_T rtc_irq_handler;
|
|
|
|
static void BOOT_TEXT_SRAM_LOC pmu_rtc_save_context(void) {
|
|
if (pmu_rtc_enabled()) {
|
|
rtc_ctx.enabled = true;
|
|
if (pmu_rtc_alarm_status_set()) {
|
|
rtc_ctx.alarm_set = true;
|
|
rtc_ctx.alarm_val = pmu_rtc_get_alarm();
|
|
}
|
|
} else {
|
|
rtc_ctx.enabled = false;
|
|
}
|
|
}
|
|
|
|
static void pmu_rtc_restore_context(void) {
|
|
uint32_t rtc_val;
|
|
|
|
if (rtc_ctx.enabled) {
|
|
pmu_rtc_enable();
|
|
if (rtc_ctx.alarm_set) {
|
|
rtc_val = pmu_rtc_get();
|
|
if (rtc_val - rtc_ctx.alarm_val <= 1 || rtc_ctx.alarm_val - rtc_val < 5) {
|
|
rtc_ctx.alarm_val = rtc_val + 5;
|
|
}
|
|
pmu_rtc_set_alarm(rtc_ctx.alarm_val);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
union VOLT_COMP_T {
|
|
struct VOLT_COMP_FIELD_T {
|
|
uint16_t dcdc1_v : 5; // bit[4:0]: 0 ~ 31
|
|
uint16_t dcdc1_f : 1; // bit[5] : 1: negative, 0: positive;
|
|
uint16_t dcdc2_v : 4; // bit[9:6]: 0 ~ 15
|
|
uint16_t dcdc2_f : 1; // bit[10] :
|
|
uint16_t dcdc3_v : 4; // bit[14:11]: 0 ~ 15
|
|
uint16_t dcdc3_f : 1; // bit[15]
|
|
} f;
|
|
uint16_t v;
|
|
};
|
|
|
|
static int8_t pmu_dcdc_dig_comp = 0;
|
|
static int8_t pmu_dcdc_ana_comp = 0;
|
|
static int8_t pmu_dcdc_hppa_comp = 0;
|
|
|
|
static POSSIBLY_UNUSED void pmu_get_dcdc_calib_value(void) {
|
|
union VOLT_COMP_T cv;
|
|
|
|
pmu_get_efuse(PMU_EFUSE_PAGE_RESERVED_7, &cv.v);
|
|
if (cv.f.dcdc1_f) { // digital
|
|
pmu_dcdc_dig_comp = -(int8_t)(cv.f.dcdc1_v);
|
|
} else {
|
|
pmu_dcdc_dig_comp = (int8_t)(cv.f.dcdc1_v);
|
|
}
|
|
if (cv.f.dcdc2_f) { // ana
|
|
pmu_dcdc_ana_comp = -(int8_t)(cv.f.dcdc2_v);
|
|
} else {
|
|
pmu_dcdc_ana_comp = (int8_t)(cv.f.dcdc2_v);
|
|
}
|
|
if (cv.f.dcdc3_f) { // hppa
|
|
pmu_dcdc_hppa_comp = -(int8_t)(cv.f.dcdc3_v);
|
|
} else {
|
|
pmu_dcdc_hppa_comp = (int8_t)(cv.f.dcdc3_v);
|
|
}
|
|
}
|
|
|
|
static POSSIBLY_UNUSED unsigned short
|
|
pmu_reg_val_add(unsigned short val, int delta, unsigned short max) {
|
|
int result = val + delta;
|
|
|
|
if (result > max) {
|
|
result = max;
|
|
} else if (result < 0) {
|
|
result = 0;
|
|
}
|
|
|
|
return (unsigned short)result;
|
|
}
|
|
#endif
|
|
|
|
static unsigned int NOINLINE BOOT_TEXT_SRAM_LOC
|
|
pmu_count_zeros(unsigned int val, unsigned int bits) {
|
|
int cnt = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < bits; i++) {
|
|
if ((val & (1 << i)) == 0) {
|
|
cnt++;
|
|
}
|
|
}
|
|
|
|
return cnt;
|
|
}
|
|
|
|
static int BOOT_TEXT_FLASH_LOC pmu_read_efuse_block(unsigned int block) {
|
|
int ret;
|
|
unsigned short val;
|
|
uint32_t start;
|
|
uint32_t timeout = MS_TO_TICKS(50);
|
|
|
|
val = TSMC_EFUSE_PGENB | TSMC_EFUSE_CLK_EN;
|
|
ret = pmu_write(PMU_REG_EFUSE_CTRL, val);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
val =
|
|
TSMC_EFUSE_STROBE_WIDTH(20) | REG_READ_STROBE_WIDTH(4) | EFUSE_SEL(block);
|
|
ret = pmu_write(PMU_REG_EFUSE_SEL, val);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
ret = pmu_read(PMU_REG_POWER_OFF, &val);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
val = SET_BITFIELD(val, EFUSE_READ_TRIG, EFUSE_READ_TRIG_WORD);
|
|
ret = pmu_write(PMU_REG_POWER_OFF, val);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
hal_sys_timer_delay(US_TO_TICKS(500));
|
|
|
|
start = hal_sys_timer_get();
|
|
do {
|
|
ret = pmu_read(PMU_REG_POWER_OFF, &val);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
if (hal_sys_timer_get() - start > timeout) {
|
|
return -2;
|
|
}
|
|
} while ((val & (EFUSE_READ_DONE | EFUSE_READ_BUSY)) != EFUSE_READ_DONE);
|
|
|
|
val = TSMC_EFUSE_PGENB;
|
|
ret = pmu_write(PMU_REG_EFUSE_CTRL, val);
|
|
if (ret) {
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void BOOT_TEXT_FLASH_LOC bbpll_freq_pll_config(uint32_t freq) {
|
|
int ret;
|
|
uint64_t PLL_cfg_val;
|
|
uint16_t v[3];
|
|
uint16_t val;
|
|
uint32_t crystal = hal_cmu_get_crystal_freq();
|
|
|
|
PLL_cfg_val = ((uint64_t)(1 << 28) * (freq / 2) + crystal / 2) / crystal;
|
|
v[0] = PLL_cfg_val & 0xFFFF;
|
|
v[1] = (PLL_cfg_val >> 16) & 0xFFFF;
|
|
v[2] = (PLL_cfg_val >> 32) & 0xFFFF;
|
|
|
|
ret = pmu_write(PMU_REG_RF_BB, v[0]);
|
|
if (ret) {
|
|
return;
|
|
}
|
|
|
|
ret = pmu_write(PMU_REG_RF_BC, v[1]);
|
|
if (ret) {
|
|
return;
|
|
}
|
|
|
|
ret = pmu_read(PMU_REG_RF_BD, &val);
|
|
if (ret) {
|
|
return;
|
|
}
|
|
val = SET_BITFIELD(val, REG_BBPLL_FREQ_34_32, v[2]) | REG_BBPLL_FREQ_EN;
|
|
ret = pmu_write(PMU_REG_RF_BD, val);
|
|
if (ret) {
|
|
return;
|
|
}
|
|
|
|
// Delay at least for 7us
|
|
hal_sys_timer_delay(US_TO_TICKS(100));
|
|
}
|
|
|
|
uint32_t BOOT_TEXT_FLASH_LOC read_hw_metal_id(void) {
|
|
int ret;
|
|
uint16_t val;
|
|
uint32_t metal_id;
|
|
int i;
|
|
union BOOT_SETTINGS_T boot;
|
|
|
|
#ifdef RTC_ENABLE
|
|
// RTC will be restored in pmu_open()
|
|
pmu_rtc_save_context();
|
|
#endif
|
|
|
|
pmu_wdt_save_context();
|
|
|
|
pmu_charger_save_context();
|
|
|
|
// Reset PMU (to recover from a possible insane state, e.g., ESD reset)
|
|
pmu_write(PMU_REG_METAL_ID, 0xCAFE);
|
|
pmu_write(PMU_REG_METAL_ID, 0x5FEE);
|
|
hal_sys_timer_delay(US_TO_TICKS(500));
|
|
|
|
#if defined(PMU_FULL_INIT) || (!defined(PROGRAMMER))
|
|
// Reset RF
|
|
pmu_write(PMU_REG_RF_80, 0xCAFE);
|
|
pmu_write(PMU_REG_RF_80, 0x5FEE);
|
|
hal_sys_timer_delay(US_TO_TICKS(500));
|
|
|
|
// Reset ANA
|
|
pmu_write(PMU_REG_ANA_60, 0xCAFE);
|
|
pmu_write(PMU_REG_ANA_60, 0x5FEE);
|
|
hal_sys_timer_delay(US_TO_TICKS(500));
|
|
#endif
|
|
|
|
#ifdef __WATCHER_DOG_RESET__
|
|
pmu_wdt_restore_context();
|
|
#endif
|
|
|
|
#ifndef EFUSE_BLOCK_NUM
|
|
#define EFUSE_BLOCK_NUM 6
|
|
#endif
|
|
|
|
for (i = 0; i < EFUSE_BLOCK_NUM; i++) {
|
|
ret = pmu_read_efuse_block(i);
|
|
if (ret) {
|
|
SAFE_PROGRAM_STOP();
|
|
}
|
|
}
|
|
|
|
ret = pmu_get_efuse(PMU_EFUSE_PAGE_BOOT, &boot.reg);
|
|
if (ret) {
|
|
boot.reg = 0;
|
|
} else {
|
|
if (pmu_count_zeros(boot.reg, 12) != boot.chksum) {
|
|
boot.reg = 0;
|
|
}
|
|
}
|
|
hal_cmu_set_crystal_freq_index(boot.crystal_freq);
|
|
// Update ISPI cfg
|
|
ret = hal_analogif_open();
|
|
if (ret) {
|
|
SAFE_PROGRAM_STOP();
|
|
}
|
|
|
|
#if !defined(PROGRAMMER) && !defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
if (hal_cmu_get_crystal_freq() != hal_cmu_get_default_crystal_freq()) {
|
|
// Update bbpll freq after resetting RF and getting crystal freq
|
|
bbpll_freq_pll_config(384000000);
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
#ifndef HIGH_VCORE
|
|
pmu_get_efuse(PMU_EFUSE_PAGE_SW_CFG, &val);
|
|
if ((val & (3 << 13)) == (3 << 13)) {
|
|
high_vcore = true;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
// enhance xtal drv
|
|
pmu_write(0x9d, 0x886c);
|
|
// Enable 26M doubler (52M)
|
|
pmu_write(0xB5, 0x8000);
|
|
#ifdef ANA_26M_X4_ENABLE
|
|
pmu_write(0xBF, 0x0400);
|
|
#endif
|
|
|
|
// Power up bbpll and audpll clk buf
|
|
// Clk buf bits:
|
|
// 0-rfpll 1-bt_dac 2-codec_resample&audpll_prechr 3-bbpll 4-audpll 5-usbhspll
|
|
// 6-lbrt 7-dig
|
|
pmu_read(0xC4, &val);
|
|
val &= ~0xFF;
|
|
val |= (1 << 2) | (1 << 3) | (1 << 4) | (1 << 7);
|
|
#if defined(USB_HIGH_SPEED) || defined(USB_USE_USBPLL)
|
|
val |= (1 << 5);
|
|
#endif
|
|
pmu_write(0xC4, val);
|
|
|
|
// Cfg bbpll
|
|
pmu_write(0x9F, 0xC22F);
|
|
pmu_write(0xA0, 0x2788);
|
|
|
|
// Cfg audpll
|
|
pmu_write(0x79, 0x0011);
|
|
pmu_write(0x77, 0x71B1);
|
|
|
|
// Set audpll to 24.576M*17
|
|
pmu_write(0x7C, 0x4F16);
|
|
pmu_write(0x7B, 0x011A);
|
|
pmu_write(0x7A, 0x2008);
|
|
|
|
// Clear reg_bt_tst_buf_sel_in/out to avoid impacting P00-P03 and P30-P33 pins
|
|
pmu_write(0xA2, 0x01C2);
|
|
|
|
// Enable SWD debug mode
|
|
pmu_read(PMU_REG_SLEEP_CFG, &val);
|
|
val = SET_BITFIELD(val, PMIC_TMODE_1300, 2);
|
|
pmu_write(PMU_REG_SLEEP_CFG, val);
|
|
|
|
pmu_read(PMU_REG_METAL_ID, &val);
|
|
pmu_metal_id = GET_BITFIELD(val, PMU_METAL_ID);
|
|
|
|
metal_id = hal_cmu_get_aon_revision_id();
|
|
|
|
if (metal_id == HAL_CHIP_METAL_ID_1) {
|
|
uint32_t data;
|
|
|
|
hal_psc_bt_enable();
|
|
hal_cmu_bt_clock_enable();
|
|
hal_cmu_bt_reset_clear();
|
|
data = *(volatile uint32_t *)0xA0000004;
|
|
hal_cmu_bt_reset_set();
|
|
hal_cmu_bt_clock_disable();
|
|
hal_psc_bt_disable();
|
|
|
|
if (data == 0xA0007471) {
|
|
metal_id = HAL_CHIP_METAL_ID_2;
|
|
}
|
|
}
|
|
|
|
// Init pll dividers
|
|
pmu_read(PMU_REG_ANA_77, &val);
|
|
val = SET_BITFIELD(val, REG_AUDPLL_DIVN, audpll_codec_div);
|
|
pmu_write(PMU_REG_ANA_77, val);
|
|
|
|
return metal_id;
|
|
}
|
|
|
|
void BOOT_TEXT_SRAM_LOC pmu_pll_div_reset_set(enum HAL_CMU_PLL_T pll) {
|
|
uint32_t lock;
|
|
uint16_t val;
|
|
|
|
lock = int_lock();
|
|
if (pll == HAL_CMU_PLL_AUD) {
|
|
pmu_read(PMU_REG_ANA_77, &val);
|
|
val |= REG_AUDPLL_DIVN_MASK | REG_AUDPLL_DIVN_RST;
|
|
pmu_write(PMU_REG_ANA_77, val);
|
|
} else if (pll == HAL_CMU_PLL_USB) {
|
|
// In fact bbpll
|
|
#ifdef AUDIO_USE_BBPLL
|
|
// 0xD2, bit13 (reset)
|
|
// 0xF5, bit[4:0] (div)
|
|
#endif
|
|
} else if (pll == HAL_CMU_PLL_QTY) {
|
|
// In fact usbhspll
|
|
}
|
|
int_unlock(lock);
|
|
}
|
|
|
|
void BOOT_TEXT_SRAM_LOC pmu_pll_div_reset_clear(enum HAL_CMU_PLL_T pll) {
|
|
uint32_t lock;
|
|
uint16_t val;
|
|
|
|
lock = int_lock();
|
|
if (pll == HAL_CMU_PLL_AUD) {
|
|
pmu_read(PMU_REG_ANA_77, &val);
|
|
val &= ~REG_AUDPLL_DIVN_RST;
|
|
pmu_write(PMU_REG_ANA_77, val);
|
|
val = SET_BITFIELD(val, REG_AUDPLL_DIVN, audpll_codec_div);
|
|
pmu_write(PMU_REG_ANA_77, val);
|
|
} else if (pll == HAL_CMU_PLL_USB) {
|
|
// In fact bbpll
|
|
#ifdef AUDIO_USE_BBPLL
|
|
#endif
|
|
} else if (pll == HAL_CMU_PLL_QTY) {
|
|
// In fact usbhspll
|
|
}
|
|
int_unlock(lock);
|
|
}
|
|
|
|
void pmu_pll_div_set(enum HAL_CMU_PLL_T pll, enum PMU_PLL_DIV_TYPE_T type,
|
|
uint32_t div) {
|
|
uint32_t lock;
|
|
uint16_t val;
|
|
|
|
if (type != PMU_PLL_DIV_CODEC) {
|
|
return;
|
|
}
|
|
|
|
lock = int_lock();
|
|
if (pll == HAL_CMU_PLL_AUD) {
|
|
if (div != audpll_codec_div) {
|
|
audpll_codec_div = div;
|
|
pmu_read(PMU_REG_ANA_77, &val);
|
|
val |= REG_AUDPLL_DIVN_MASK;
|
|
pmu_write(PMU_REG_ANA_77, val);
|
|
if (div != (REG_AUDPLL_DIVN_MASK >> REG_AUDPLL_DIVN_SHIFT)) {
|
|
val = SET_BITFIELD(val, REG_AUDPLL_DIVN, audpll_codec_div);
|
|
pmu_write(PMU_REG_ANA_77, val);
|
|
}
|
|
}
|
|
} else if (pll == HAL_CMU_PLL_USB) {
|
|
// In fact bbpll
|
|
#ifdef AUDIO_USE_BBPLL
|
|
#endif
|
|
} else if (pll == HAL_CMU_PLL_QTY) {
|
|
// In fact usbhspll
|
|
}
|
|
int_unlock(lock);
|
|
}
|
|
|
|
#if defined(USE_CYBERON)
|
|
static uint32_t BOOT_BSS_LOC cyb_hack_efuse_check = 0;
|
|
void cyb_efuse_check_enable(int enabled) { cyb_hack_efuse_check = enabled; }
|
|
|
|
int cyb_efuse_check_status(void) { return cyb_hack_efuse_check; }
|
|
|
|
#if 1
|
|
int BOOT_TEXT_SRAM_LOC Cyb_pmu_get_efuse(enum PMU_EFUSE_PAGE_T page,
|
|
unsigned short *efuse) {
|
|
// PMU_DEBUG_TRACE(2,"page %x, efuse %x", page, efuse);
|
|
if (page == 0XE) {
|
|
*efuse = 0x1B9C;
|
|
}
|
|
if (page == 0xF) {
|
|
*efuse = 0x098B;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
int BOOT_TEXT_SRAM_LOC pmu_get_efuse(enum PMU_EFUSE_PAGE_T page,
|
|
unsigned short *efuse) {
|
|
int ret;
|
|
|
|
// #if defined(USE_CYBERON)
|
|
#if 0
|
|
if (cyb_efuse_check_status()) {
|
|
PMU_DEBUG_TRACE(2,"page %x, efuse %x", page, efuse);
|
|
if((int)page==0xE){
|
|
*efuse=0x1B9C;
|
|
return 0;
|
|
}
|
|
if((int)page==0xF){
|
|
*efuse = 0x098B;
|
|
return 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
ret = pmu_read(PMU_REG_EFUSE_VAL_START + page, efuse);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int pmu_get_security_value(union SECURITY_VALUE_T *val) {
|
|
int ret;
|
|
|
|
ret = pmu_get_efuse(PMU_EFUSE_PAGE_SECURITY, &val->reg);
|
|
if (ret) {
|
|
// Error
|
|
goto _no_security;
|
|
}
|
|
|
|
if (!val->security_en) {
|
|
// OK
|
|
goto _no_security;
|
|
}
|
|
ret = 1;
|
|
if (pmu_count_zeros(val->key_id, 3) != val->key_chksum) {
|
|
// Error
|
|
goto _no_security;
|
|
}
|
|
if (pmu_count_zeros(val->vendor_id, 6) != val->vendor_chksum) {
|
|
// Error
|
|
goto _no_security;
|
|
}
|
|
if ((pmu_count_zeros(val->reg, 15) & 1) != val->chksum) {
|
|
// Error
|
|
goto _no_security;
|
|
}
|
|
|
|
// OK
|
|
return 0;
|
|
|
|
_no_security:
|
|
val->reg = 0;
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void pmu_sys_ctrl(bool shutdown) {
|
|
uint16_t val;
|
|
uint32_t lock = int_lock();
|
|
|
|
PMU_INFO_TRACE_IMM(0, "Start pmu %s", shutdown ? "shutdown" : "reboot");
|
|
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
// Default vcore might not be high enough to support high performance mode
|
|
pmu_high_performance_mode_enable(false);
|
|
hal_cmu_sys_set_freq(HAL_CMU_FREQ_26M);
|
|
#endif
|
|
pmu_hppa_dcdc_to_ldo();
|
|
pmu_mode_change(PMU_POWER_MODE_LDO);
|
|
hal_sys_timer_delay(MS_TO_TICKS(1));
|
|
#endif
|
|
|
|
#ifdef RTC_ENABLE
|
|
pmu_rtc_save_context();
|
|
#endif
|
|
|
|
// Reset PMU
|
|
pmu_write(PMU_REG_METAL_ID, 0xCAFE);
|
|
pmu_write(PMU_REG_METAL_ID, 0x5FEE);
|
|
hal_sys_timer_delay(4);
|
|
|
|
#ifdef RTC_ENABLE
|
|
pmu_rtc_restore_context();
|
|
#endif
|
|
|
|
if (shutdown) {
|
|
#if defined(_AUTO_TEST_)
|
|
if (at_skip_shutdown) {
|
|
hal_cmu_sys_reboot();
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
pmu_wdt_config(3 * 1000, 3 * 1000);
|
|
pmu_wdt_start();
|
|
pmu_charger_shutdown_config();
|
|
#endif
|
|
|
|
// Power off
|
|
pmu_read(PMU_REG_POWER_OFF, &val);
|
|
val |= SOFT_POWER_OFF;
|
|
for (int i = 0; i < 100; i++) {
|
|
pmu_write(PMU_REG_POWER_OFF, val);
|
|
hal_sys_timer_delay(MS_TO_TICKS(5));
|
|
}
|
|
|
|
hal_sys_timer_delay(MS_TO_TICKS(50));
|
|
|
|
// can't reach here
|
|
PMU_INFO_TRACE_IMM(0, "\nError: pmu shutdown failed!\n");
|
|
hal_sys_timer_delay(MS_TO_TICKS(5));
|
|
} else {
|
|
#if defined(PMU_FULL_INIT) || (!defined(PROGRAMMER))
|
|
// CAUTION:
|
|
// 1) Never reset RF because system or flash might be using X2/X4, which are
|
|
// off by default 2) Never reset RF/ANA because system or flash might be
|
|
// using PLL, and the reset might cause clock glitch
|
|
// TODO:
|
|
// Restore BBPLL settings in RF
|
|
#endif
|
|
}
|
|
|
|
hal_cmu_sys_reboot();
|
|
|
|
int_unlock(lock);
|
|
}
|
|
|
|
void pmu_shutdown(void) { pmu_sys_ctrl(true); }
|
|
|
|
void pmu_reboot(void) { pmu_sys_ctrl(false); }
|
|
|
|
static inline uint16_t pmu_get_module_addr(enum PMU_MODUAL_T module) {
|
|
if (module == PMU_HPPA2CODEC || module == PMU_CODEC) {
|
|
return PMU_REG_MODULE_START + module + 1;
|
|
} else if (module == PMU_BUCK2ANA) {
|
|
return PMU_REG_BUCK2ANA_CFG;
|
|
} else {
|
|
return PMU_REG_MODULE_START + module;
|
|
}
|
|
}
|
|
|
|
void pmu_module_config(enum PMU_MODUAL_T module, unsigned short is_manual,
|
|
unsigned short ldo_on, unsigned short lp_mode,
|
|
unsigned short dpmode) {
|
|
unsigned short val;
|
|
unsigned char module_address;
|
|
const struct PMU_MODULE_CFG_T *module_cfg_p = &pmu_module_cfg[module];
|
|
|
|
module_address = pmu_get_module_addr(module);
|
|
|
|
if (module == PMU_ANA) {
|
|
pmu_read(PMU_REG_BIAS_CFG, &val);
|
|
if (is_manual) {
|
|
val |= module_cfg_p->pu_dr;
|
|
} else {
|
|
val &= ~module_cfg_p->pu_dr;
|
|
}
|
|
|
|
if (ldo_on) {
|
|
val |= module_cfg_p->pu;
|
|
} else {
|
|
val &= ~module_cfg_p->pu;
|
|
}
|
|
pmu_write(PMU_REG_BIAS_CFG, val);
|
|
} else if (module == PMU_DIG) {
|
|
pmu_read(PMU_REG_DCDC_DIG_EN, &val);
|
|
if (is_manual) {
|
|
val |= module_cfg_p->pu_dr;
|
|
} else {
|
|
val &= ~module_cfg_p->pu_dr;
|
|
}
|
|
|
|
if (ldo_on) {
|
|
val |= module_cfg_p->pu;
|
|
} else {
|
|
val &= ~module_cfg_p->pu;
|
|
}
|
|
pmu_write(PMU_REG_DCDC_DIG_EN, val);
|
|
} else if (module == PMU_HPPA2CODEC) {
|
|
pmu_read(PMU_REG_SLEEP_CFG, &val);
|
|
if (dpmode) {
|
|
val |= module_cfg_p->pu_dsleep;
|
|
} else {
|
|
val &= ~module_cfg_p->pu_dsleep;
|
|
}
|
|
pmu_write(PMU_REG_SLEEP_CFG, val);
|
|
} else if (module == PMU_CODEC) {
|
|
pmu_read(PMU_REG_HPPA2CODEC_CFG, &val);
|
|
if (dpmode) {
|
|
val |= module_cfg_p->pu_dsleep;
|
|
} else {
|
|
val &= ~module_cfg_p->pu_dsleep;
|
|
}
|
|
pmu_write(PMU_REG_HPPA2CODEC_CFG, val);
|
|
}
|
|
|
|
pmu_read(module_address, &val);
|
|
|
|
if (module != PMU_ANA && module != PMU_DIG) {
|
|
if (is_manual) {
|
|
val |= module_cfg_p->pu_dr;
|
|
} else {
|
|
val &= ~module_cfg_p->pu_dr;
|
|
}
|
|
|
|
if (ldo_on) {
|
|
val |= module_cfg_p->pu;
|
|
} else {
|
|
val &= ~module_cfg_p->pu;
|
|
}
|
|
}
|
|
|
|
if (lp_mode) {
|
|
val &= ~module_cfg_p->lp_en_dr;
|
|
} else {
|
|
val = (val & ~module_cfg_p->lp_en) | module_cfg_p->lp_en_dr;
|
|
}
|
|
|
|
if (module != PMU_HPPA2CODEC && module != PMU_CODEC) {
|
|
if (dpmode) {
|
|
val |= module_cfg_p->pu_dsleep;
|
|
} else {
|
|
val &= ~module_cfg_p->pu_dsleep;
|
|
}
|
|
}
|
|
|
|
pmu_write(module_address, val);
|
|
}
|
|
|
|
void pmu_module_set_volt(unsigned char module, unsigned short sleep_v,
|
|
unsigned short normal_v) {
|
|
unsigned short val;
|
|
unsigned char module_address;
|
|
const struct PMU_MODULE_CFG_T *module_cfg_p = &pmu_module_cfg[module];
|
|
|
|
module_address = pmu_get_module_addr(module);
|
|
|
|
pmu_read(module_address, &val);
|
|
val &= ~module_cfg_p->vbit_normal_mask;
|
|
val |= (normal_v << module_cfg_p->vbit_normal_shift) &
|
|
module_cfg_p->vbit_normal_mask;
|
|
val &= ~module_cfg_p->vbit_dsleep_mask;
|
|
val |= (sleep_v << module_cfg_p->vbit_dsleep_shift) &
|
|
module_cfg_p->vbit_dsleep_mask;
|
|
pmu_write(module_address, val);
|
|
}
|
|
|
|
int pmu_module_get_volt(unsigned char module, unsigned short *sleep_vp,
|
|
unsigned short *normal_vp) {
|
|
unsigned short val;
|
|
unsigned char module_address;
|
|
const struct PMU_MODULE_CFG_T *module_cfg_p = &pmu_module_cfg[module];
|
|
|
|
module_address = pmu_get_module_addr(module);
|
|
|
|
pmu_read(module_address, &val);
|
|
if (normal_vp) {
|
|
*normal_vp = (val & module_cfg_p->vbit_normal_mask) >>
|
|
module_cfg_p->vbit_normal_shift;
|
|
}
|
|
if (sleep_vp) {
|
|
*sleep_vp = (val & module_cfg_p->vbit_dsleep_mask) >>
|
|
module_cfg_p->vbit_dsleep_shift;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void pmu_module_ramp_volt(unsigned char module, unsigned short sleep_v,
|
|
unsigned short normal_v) {
|
|
uint16_t old_normal_v;
|
|
uint16_t old_sleep_v;
|
|
|
|
pmu_module_get_volt(module, &old_sleep_v, &old_normal_v);
|
|
|
|
if (old_normal_v < normal_v) {
|
|
while (old_normal_v++ < normal_v) {
|
|
pmu_module_set_volt(module, sleep_v, old_normal_v);
|
|
}
|
|
} else if (old_normal_v != normal_v || old_sleep_v != sleep_v) {
|
|
pmu_module_set_volt(module, sleep_v, normal_v);
|
|
}
|
|
}
|
|
|
|
static void pmu_dcdc_ana_get_volt(unsigned short *normal_vp,
|
|
unsigned short *dsleep_vp) {
|
|
unsigned short val;
|
|
|
|
pmu_read(PMU_REG_DCDC_ANA_VOLT, &val);
|
|
if (normal_vp) {
|
|
*normal_vp = GET_BITFIELD(val, REG_DCDC2_VBIT_NORMAL);
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp = GET_BITFIELD(val, REG_DCDC2_VBIT_DSLEEP);
|
|
}
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
if (normal_vp) {
|
|
*normal_vp =
|
|
pmu_reg_val_add(*normal_vp, -pmu_dcdc_ana_comp, MAX_DCDC2_VBIT_VAL);
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp =
|
|
pmu_reg_val_add(*dsleep_vp, -pmu_dcdc_ana_comp, MAX_DCDC2_VBIT_VAL);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void pmu_dcdc_ana_set_volt(unsigned short normal_v,
|
|
unsigned short dsleep_v) {
|
|
unsigned short val;
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
normal_v = pmu_reg_val_add(normal_v, pmu_dcdc_ana_comp, MAX_DCDC2_VBIT_VAL);
|
|
dsleep_v = pmu_reg_val_add(dsleep_v, pmu_dcdc_ana_comp, MAX_DCDC2_VBIT_VAL);
|
|
#endif
|
|
|
|
pmu_read(PMU_REG_DCDC_ANA_VOLT, &val);
|
|
val &= ~REG_DCDC2_VBIT_DSLEEP_MASK;
|
|
val &= ~REG_DCDC2_VBIT_NORMAL_MASK;
|
|
val |= REG_DCDC2_VBIT_DSLEEP(dsleep_v);
|
|
val |= REG_DCDC2_VBIT_NORMAL(normal_v);
|
|
pmu_write(PMU_REG_DCDC_ANA_VOLT, val);
|
|
|
|
if (normal_v > dsleep_v) {
|
|
dcdc_ramp_map |= REG_DCDC2_RAMP_EN;
|
|
} else {
|
|
dcdc_ramp_map &= ~REG_DCDC2_RAMP_EN;
|
|
}
|
|
}
|
|
|
|
static void pmu_ana_set_volt(int mode_change, enum PMU_POWER_MODE_T mode) {
|
|
uint16_t old_act_dcdc;
|
|
uint16_t old_lp_dcdc;
|
|
uint16_t new_act_dcdc;
|
|
|
|
if (mode == PMU_POWER_MODE_ANA_DCDC || mode == PMU_POWER_MODE_DIG_DCDC) {
|
|
pmu_dcdc_ana_get_volt(&old_act_dcdc, &old_lp_dcdc);
|
|
new_act_dcdc = ana_act_dcdc;
|
|
if (old_act_dcdc < new_act_dcdc) {
|
|
while (old_act_dcdc++ < new_act_dcdc) {
|
|
pmu_dcdc_ana_set_volt(old_act_dcdc, ana_lp_dcdc);
|
|
}
|
|
hal_sys_timer_delay_us(PMU_VANA_STABLE_TIME_US);
|
|
} else if (old_act_dcdc != new_act_dcdc || old_lp_dcdc != ana_lp_dcdc) {
|
|
pmu_dcdc_ana_set_volt(new_act_dcdc, ana_lp_dcdc);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void pmu_dcdc_dig_get_volt(unsigned short *normal_vp,
|
|
unsigned short *dsleep_vp) {
|
|
unsigned short val;
|
|
|
|
pmu_read(PMU_REG_DCDC_DIG_VOLT, &val);
|
|
if (normal_vp) {
|
|
*normal_vp = GET_BITFIELD(val, REG_DCDC1_VBIT_NORMAL);
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp = GET_BITFIELD(val, REG_DCDC1_VBIT_DSLEEP);
|
|
}
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
if (normal_vp) {
|
|
*normal_vp =
|
|
pmu_reg_val_add(*normal_vp, -pmu_dcdc_dig_comp, MAX_DCDC1_VBIT_VAL);
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp =
|
|
pmu_reg_val_add(*dsleep_vp, -pmu_dcdc_dig_comp, MAX_DCDC1_VBIT_VAL);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void pmu_dcdc_dig_set_volt(unsigned short normal_v,
|
|
unsigned short dsleep_v) {
|
|
unsigned short val;
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
normal_v = pmu_reg_val_add(normal_v, pmu_dcdc_dig_comp, MAX_DCDC1_VBIT_VAL);
|
|
dsleep_v = pmu_reg_val_add(dsleep_v, pmu_dcdc_dig_comp, MAX_DCDC1_VBIT_VAL);
|
|
#endif
|
|
|
|
pmu_read(PMU_REG_DCDC_DIG_VOLT, &val);
|
|
val &= ~REG_DCDC1_VBIT_DSLEEP_MASK;
|
|
val &= ~REG_DCDC1_VBIT_NORMAL_MASK;
|
|
val |= REG_DCDC1_VBIT_DSLEEP(dsleep_v);
|
|
val |= REG_DCDC1_VBIT_NORMAL(normal_v);
|
|
pmu_write(PMU_REG_DCDC_DIG_VOLT, val);
|
|
|
|
if (normal_v > dsleep_v) {
|
|
dcdc_ramp_map |= REG_DCDC1_RAMP_EN;
|
|
} else {
|
|
dcdc_ramp_map &= ~REG_DCDC1_RAMP_EN;
|
|
}
|
|
}
|
|
|
|
static void BOOT_TEXT_SRAM_LOC pmu_dig_get_target_volt(uint16_t *ldo,
|
|
uint16_t *dcdc) {
|
|
uint16_t ldo_volt;
|
|
uint16_t dcdc_volt;
|
|
|
|
if (0) {
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
} else if (pmu_vcore_req & (PMU_VCORE_SYS_FREQ_HIGH)) {
|
|
if (high_perf_freq_mhz <= 260) {
|
|
ldo_volt = PMU_VDIG_1_05V;
|
|
dcdc_volt = PMU_DCDC_DIG_1_05V;
|
|
} else if (high_perf_freq_mhz <= 300) {
|
|
ldo_volt = PMU_VDIG_1_1V;
|
|
dcdc_volt = PMU_DCDC_DIG_1_1V;
|
|
} else {
|
|
ldo_volt = PMU_VDIG_1_2V;
|
|
dcdc_volt = PMU_DCDC_DIG_1_1V;
|
|
}
|
|
#endif
|
|
} else if (pmu_vcore_req &
|
|
(PMU_VCORE_USB_HS_ENABLED | PMU_VCORE_RS_FREQ_HIGH |
|
|
PMU_VCORE_SYS_FREQ_MEDIUM)) {
|
|
ldo_volt = PMU_VDIG_0_9V;
|
|
dcdc_volt = PMU_DCDC_DIG_0_9V;
|
|
} else if (pmu_vcore_req &
|
|
(PMU_VCORE_FLASH_FREQ_HIGH | PMU_VCORE_PSRAM_FREQ_HIGH |
|
|
PMU_VCORE_FLASH_WRITE_ENABLED)) {
|
|
ldo_volt = PMU_VDIG_0_8V;
|
|
dcdc_volt = PMU_DCDC_DIG_0_8V;
|
|
} else {
|
|
// Common cases
|
|
if (high_vcore) {
|
|
ldo_volt = PMU_VDIG_0_8V;
|
|
dcdc_volt = PMU_DCDC_DIG_0_8V;
|
|
} else {
|
|
ldo_volt = PMU_VDIG_0_75V;
|
|
dcdc_volt = PMU_DCDC_DIG_0_75V;
|
|
}
|
|
#ifdef __SAVE_POWER_MODE__
|
|
ldo_volt = PMU_VDIG_0_75V;
|
|
dcdc_volt = PMU_DCDC_DIG_0_75V;
|
|
#endif
|
|
}
|
|
|
|
#if defined(PROGRAMMER) || defined(__BES_OTA_MODE__) && !defined(PMU_FULL_INIT)
|
|
// Try to keep the same vcore voltage as ROM (hardware default)
|
|
if (ldo_volt < PMU_VDIG_0_9V) {
|
|
ldo_volt = PMU_VDIG_0_9V;
|
|
}
|
|
if (dcdc_volt < PMU_DCDC_DIG_0_9V) {
|
|
dcdc_volt = PMU_DCDC_DIG_0_9V;
|
|
}
|
|
#endif
|
|
|
|
#if defined(MTEST_ENABLED) && defined(MTEST_VOLT)
|
|
#ifdef DIG_DCDC_MODE
|
|
dcdc_volt = MTEST_VOLT;
|
|
#else
|
|
ldo_volt = MTEST_VOLT;
|
|
#endif
|
|
#endif
|
|
|
|
if (ldo) {
|
|
*ldo = ldo_volt;
|
|
}
|
|
if (dcdc) {
|
|
*dcdc = dcdc_volt;
|
|
}
|
|
}
|
|
|
|
static void pmu_dig_set_volt(int mode_change, enum PMU_POWER_MODE_T mode) {
|
|
uint32_t lock;
|
|
uint16_t dcdc_volt, old_act_dcdc, old_lp_dcdc;
|
|
uint16_t ldo_volt, old_act_ldo, old_lp_ldo;
|
|
uint16_t ldo_real, dcdc_real;
|
|
bool volt_inc = false;
|
|
|
|
lock = int_lock();
|
|
|
|
if (mode == PMU_POWER_MODE_NONE) {
|
|
mode = pmu_power_mode;
|
|
}
|
|
|
|
pmu_dig_get_target_volt(&ldo_volt, &dcdc_volt);
|
|
|
|
pmu_module_get_volt(PMU_DIG, &old_lp_ldo, &old_act_ldo);
|
|
pmu_dcdc_dig_get_volt(&old_act_dcdc, &old_lp_dcdc);
|
|
|
|
if (mode_change) {
|
|
// Both DCDC and LDO might have been enabled
|
|
ldo_real = (old_act_ldo - PMU_VDIG_0_4V) / 0x2;
|
|
dcdc_real = (old_act_dcdc - PMU_DCDC_DIG_0_4V) / 0x10;
|
|
if (dcdc_real < ldo_real) {
|
|
dcdc_real = ldo_real;
|
|
}
|
|
ldo_real = PMU_VDIG_0_4V + dcdc_real * 0x2;
|
|
dcdc_real = PMU_DCDC_DIG_0_4V + dcdc_real * 0x10;
|
|
|
|
// Set the voltage to current real voltage
|
|
if (old_act_ldo < ldo_real) {
|
|
old_act_ldo = ldo_real;
|
|
old_lp_ldo = dig_lp_ldo;
|
|
pmu_module_set_volt(PMU_DIG, old_lp_ldo, old_act_ldo);
|
|
}
|
|
if (old_act_dcdc < dcdc_real) {
|
|
old_act_dcdc = dcdc_real;
|
|
old_lp_dcdc = dig_lp_dcdc;
|
|
pmu_dcdc_dig_set_volt(old_act_dcdc, old_lp_dcdc);
|
|
}
|
|
}
|
|
|
|
if (mode_change || mode == PMU_POWER_MODE_DIG_DCDC) {
|
|
if (old_act_dcdc < dcdc_volt) {
|
|
volt_inc = true;
|
|
while (old_act_dcdc++ < dcdc_volt) {
|
|
pmu_dcdc_dig_set_volt(old_act_dcdc, dig_lp_dcdc);
|
|
}
|
|
} else if (old_act_dcdc != dcdc_volt || old_lp_dcdc != dig_lp_dcdc) {
|
|
pmu_dcdc_dig_set_volt(dcdc_volt, dig_lp_dcdc);
|
|
}
|
|
}
|
|
|
|
if (mode_change || mode != PMU_POWER_MODE_DIG_DCDC) {
|
|
if (old_act_ldo < ldo_volt) {
|
|
volt_inc = true;
|
|
}
|
|
pmu_module_ramp_volt(PMU_DIG, dig_lp_ldo, ldo_volt);
|
|
}
|
|
|
|
if (mode_change == 0) {
|
|
// Update the voltage of the other mode
|
|
if (mode == PMU_POWER_MODE_DIG_DCDC) {
|
|
pmu_module_set_volt(PMU_DIG, dig_lp_ldo, ldo_volt);
|
|
} else {
|
|
pmu_dcdc_dig_set_volt(dcdc_volt, dig_lp_dcdc);
|
|
}
|
|
}
|
|
|
|
if (volt_inc) {
|
|
hal_sys_timer_delay_us(PMU_VCORE_STABLE_TIME_US);
|
|
}
|
|
|
|
int_unlock(lock);
|
|
}
|
|
|
|
static void pmu_ldo_mode_en(void) {
|
|
unsigned short val;
|
|
|
|
// Enable vana ldo
|
|
pmu_module_config(PMU_ANA, PMU_AUTO_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_ON);
|
|
// Enable vcore ldo
|
|
pmu_module_config(PMU_DIG, PMU_AUTO_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_ON);
|
|
|
|
pmu_ana_set_volt(1, PMU_POWER_MODE_LDO);
|
|
pmu_dig_set_volt(1, PMU_POWER_MODE_LDO);
|
|
|
|
hal_sys_timer_delay_us(PMU_LDO_PU_STABLE_TIME_US);
|
|
|
|
// Disable vcore dcdc
|
|
pmu_read(PMU_REG_DCDC_DIG_EN, &val);
|
|
val = (val & ~REG_PU_DCDC1) | REG_PU_DCDC1_DR;
|
|
pmu_write(PMU_REG_DCDC_DIG_EN, val);
|
|
// Disable vana dcdc
|
|
pmu_read(PMU_REG_DCDC_ANA_EN, &val);
|
|
val = (val & ~REG_PU_DCDC2) | REG_PU_DCDC2_DR;
|
|
pmu_write(PMU_REG_DCDC_ANA_EN, val);
|
|
}
|
|
|
|
static void pmu_dcdc_ana_mode_en(void) {
|
|
unsigned short val;
|
|
|
|
if (pmu_power_mode == PMU_POWER_MODE_DIG_DCDC) {
|
|
// Enable vcore ldo
|
|
pmu_module_config(PMU_DIG, PMU_AUTO_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_ON);
|
|
|
|
pmu_ana_set_volt(1, PMU_POWER_MODE_ANA_DCDC);
|
|
pmu_dig_set_volt(1, PMU_POWER_MODE_ANA_DCDC);
|
|
|
|
hal_sys_timer_delay_us(PMU_LDO_PU_STABLE_TIME_US);
|
|
|
|
// Disable vcore dcdc
|
|
pmu_read(PMU_REG_DCDC_DIG_EN, &val);
|
|
val = (val & ~REG_PU_DCDC1) | REG_PU_DCDC1_DR;
|
|
pmu_write(PMU_REG_DCDC_DIG_EN, val);
|
|
} else {
|
|
pmu_read(PMU_REG_DCDC_ANA_CFG_19, &val);
|
|
val |= DCDC2_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_19, val);
|
|
|
|
// Enable vana dcdc
|
|
pmu_read(PMU_REG_DCDC_ANA_EN, &val);
|
|
#ifdef DCDC_ULP_LP_ON
|
|
val = (val & ~REG_DCDC2_ULP_MODE_NORMAL) | REG_DCDC2_ULP_MODE_DSLEEP |
|
|
REG_PU_DCDC2_DR | REG_PU_DCDC2;
|
|
#else
|
|
val = (val & ~REG_DCDC2_ULP_MODE_NORMAL) | REG_PU_DCDC2_DR | REG_PU_DCDC2;
|
|
#endif
|
|
pmu_write(PMU_REG_DCDC_ANA_EN, val);
|
|
|
|
pmu_ana_set_volt(1, PMU_POWER_MODE_ANA_DCDC);
|
|
pmu_dig_set_volt(1, PMU_POWER_MODE_ANA_DCDC);
|
|
|
|
hal_sys_timer_delay_us(PMU_DCDC_PU_STABLE_TIME_US);
|
|
|
|
// Disable vana ldo
|
|
pmu_module_config(PMU_ANA, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
|
|
pmu_read(PMU_REG_DCDC_ANA_CFG_19, &val);
|
|
val &= ~DCDC2_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_19, val);
|
|
}
|
|
}
|
|
|
|
static void pmu_dcdc_dual_mode_en(void) {
|
|
unsigned short val;
|
|
|
|
pmu_read(PMU_REG_DCDC_ANA_CFG_19, &val);
|
|
val |= DCDC2_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_19, val);
|
|
pmu_read(PMU_REG_DCDC_DIG_CFG_36, &val);
|
|
val |= DCDC1_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_36, val);
|
|
|
|
// Enable vana dcdc
|
|
pmu_read(PMU_REG_DCDC_ANA_EN, &val);
|
|
#ifdef DCDC_ULP_LP_ON
|
|
val = (val & ~REG_DCDC2_ULP_MODE_NORMAL) | REG_DCDC2_ULP_MODE_DSLEEP |
|
|
REG_PU_DCDC2_DR | REG_PU_DCDC2;
|
|
#else
|
|
val = (val & ~(REG_DCDC2_ULP_MODE_NORMAL | REG_DCDC2_ULP_MODE_DSLEEP)) |
|
|
REG_PU_DCDC2_DR | REG_PU_DCDC2;
|
|
#endif
|
|
pmu_write(PMU_REG_DCDC_ANA_EN, val);
|
|
// Enable vcore dcdc
|
|
pmu_read(PMU_REG_DCDC_DIG_EN, &val);
|
|
#ifdef DCDC_ULP_LP_ON
|
|
val = (val & ~REG_DCDC1_ULP_MODE_NORMAL) | REG_DCDC1_ULP_MODE_DSLEEP |
|
|
REG_PU_DCDC1_DR | REG_PU_DCDC1;
|
|
#else
|
|
val = (val & ~(REG_DCDC1_ULP_MODE_NORMAL | REG_DCDC1_ULP_MODE_DSLEEP)) |
|
|
REG_PU_DCDC1_DR | REG_PU_DCDC1;
|
|
#endif
|
|
pmu_write(PMU_REG_DCDC_DIG_EN, val);
|
|
|
|
pmu_ana_set_volt(1, PMU_POWER_MODE_DIG_DCDC);
|
|
pmu_dig_set_volt(1, PMU_POWER_MODE_DIG_DCDC);
|
|
|
|
hal_sys_timer_delay_us(PMU_DCDC_PU_STABLE_TIME_US);
|
|
|
|
// Disable vana ldo
|
|
pmu_module_config(PMU_ANA, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
// Disable vcore ldo
|
|
pmu_module_config(PMU_DIG, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
|
|
pmu_read(PMU_REG_DCDC_ANA_CFG_19, &val);
|
|
val &= ~DCDC2_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_19, val);
|
|
pmu_read(PMU_REG_DCDC_DIG_CFG_36, &val);
|
|
val &= ~DCDC1_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_36, val);
|
|
}
|
|
|
|
void pmu_mode_change(enum PMU_POWER_MODE_T mode) {
|
|
uint32_t lock;
|
|
|
|
if (pmu_power_mode == mode || mode == PMU_POWER_MODE_NONE) {
|
|
return;
|
|
}
|
|
|
|
lock = int_lock();
|
|
|
|
if (mode == PMU_POWER_MODE_ANA_DCDC) {
|
|
pmu_dcdc_ana_mode_en();
|
|
} else if (mode == PMU_POWER_MODE_DIG_DCDC) {
|
|
pmu_dcdc_dual_mode_en();
|
|
} else if (mode == PMU_POWER_MODE_LDO) {
|
|
pmu_ldo_mode_en();
|
|
}
|
|
|
|
pmu_power_mode = mode;
|
|
|
|
int_unlock(lock);
|
|
}
|
|
|
|
void pmu_sleep_en(unsigned char sleep_en) {
|
|
unsigned short val;
|
|
|
|
pmu_read(PMU_REG_SLEEP_CFG, &val);
|
|
if (sleep_en) {
|
|
val |= SLEEP_ALLOW;
|
|
} else {
|
|
val &= ~SLEEP_ALLOW;
|
|
}
|
|
pmu_write(PMU_REG_SLEEP_CFG, val);
|
|
}
|
|
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
static uint32_t pmu_vcodec_mv_to_val(uint16_t mv) {
|
|
uint32_t val;
|
|
|
|
#ifdef VHPPA2VCODEC
|
|
if (mv == 1900) {
|
|
val = PMU_HPPA2CODEC_1_9V;
|
|
} else if (mv >= 1950) {
|
|
val = PMU_HPPA2CODEC_1_95V;
|
|
} else {
|
|
val = PMU_HPPA2CODEC_1_7V;
|
|
}
|
|
#else
|
|
if (mv == 1900) {
|
|
val = PMU_CODEC_1_9V;
|
|
} else if (mv >= 1950) {
|
|
val = PMU_CODEC_1_9V;
|
|
} else {
|
|
val = PMU_CODEC_1_7V;
|
|
}
|
|
#endif
|
|
|
|
return val;
|
|
}
|
|
|
|
static uint32_t pmu_ldo_hppa_mv_to_val(uint16_t mv) {
|
|
uint32_t val;
|
|
|
|
if (mv == 1600) {
|
|
val = PMU_VHPPA_1_6V;
|
|
} else if (mv == 1700) {
|
|
val = PMU_VHPPA_1_7V;
|
|
} else if (mv >= 1900) {
|
|
val = PMU_VHPPA_1_9V;
|
|
} else {
|
|
val = PMU_VHPPA_1_8V;
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
static void POSSIBLY_UNUSED pmu_ldo_hppa_get_volt(unsigned short *normal_vp,
|
|
unsigned short *dsleep_vp) {
|
|
uint16_t val;
|
|
|
|
pmu_read(PMU_REG_HPPA_LDO_EN, &val);
|
|
val = GET_BITFIELD(val, REG_RES_SEL_VHPPA);
|
|
if (normal_vp) {
|
|
*normal_vp = val;
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp = val;
|
|
}
|
|
}
|
|
|
|
static void pmu_ldo_hppa_set_volt(unsigned short normal_v,
|
|
unsigned short dsleep_v) {
|
|
uint16_t val;
|
|
|
|
pmu_read(PMU_REG_HPPA_LDO_EN, &val);
|
|
val = SET_BITFIELD(val, REG_RES_SEL_VHPPA, normal_v);
|
|
pmu_write(PMU_REG_HPPA_LDO_EN, val);
|
|
}
|
|
|
|
static void pmu_ldo_hppa_en(int enable) {
|
|
uint16_t val;
|
|
|
|
pmu_read(PMU_REG_HPPA_LDO_EN, &val);
|
|
if (enable) {
|
|
val |= (REG_PU_LDO_VHPPA_DSLEEP | REG_PU_LDO_VHPPA_EN);
|
|
} else {
|
|
val &= ~(REG_PU_LDO_VHPPA_DSLEEP | REG_PU_LDO_VHPPA_EN);
|
|
}
|
|
pmu_write(PMU_REG_HPPA_LDO_EN, val);
|
|
}
|
|
|
|
#ifndef HPPA_LDO_ON
|
|
static uint32_t pmu_dcdc_hppa_mv_to_val(uint16_t mv) {
|
|
uint32_t val;
|
|
|
|
if (mv == 1600) {
|
|
val = PMU_DCDC_HPPA_1_6V;
|
|
} else if (mv == 1700) {
|
|
val = PMU_DCDC_HPPA_1_7V;
|
|
} else if (mv == 1900) {
|
|
val = PMU_DCDC_HPPA_1_9V;
|
|
} else if (mv >= 1950) {
|
|
val = PMU_DCDC_HPPA_1_95V;
|
|
} else {
|
|
val = PMU_DCDC_HPPA_1_8V;
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
static void pmu_dcdc_hppa_get_volt(unsigned short *normal_vp,
|
|
unsigned short *dsleep_vp) {
|
|
unsigned short val;
|
|
|
|
pmu_read(PMU_REG_DCDC_HPPA_VOLT, &val);
|
|
if (normal_vp) {
|
|
*normal_vp = GET_BITFIELD(val, REG_DCDC3_VBIT_NORMAL);
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp = GET_BITFIELD(val, REG_DCDC3_VBIT_DSLEEP);
|
|
}
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
if (normal_vp) {
|
|
*normal_vp =
|
|
pmu_reg_val_add(*normal_vp, -pmu_dcdc_hppa_comp, MAX_DCDC3_VBIT_VAL);
|
|
}
|
|
if (dsleep_vp) {
|
|
*dsleep_vp =
|
|
pmu_reg_val_add(*dsleep_vp, -pmu_dcdc_hppa_comp, MAX_DCDC3_VBIT_VAL);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static void pmu_dcdc_hppa_set_volt(unsigned short normal_v,
|
|
unsigned short dsleep_v) {
|
|
unsigned short val;
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
normal_v = pmu_reg_val_add(normal_v, pmu_dcdc_hppa_comp, MAX_DCDC3_VBIT_VAL);
|
|
dsleep_v = pmu_reg_val_add(dsleep_v, pmu_dcdc_hppa_comp, MAX_DCDC3_VBIT_VAL);
|
|
#endif
|
|
|
|
pmu_read(PMU_REG_DCDC_HPPA_VOLT, &val);
|
|
val &= ~REG_DCDC3_VBIT_DSLEEP_MASK;
|
|
val &= ~REG_DCDC3_VBIT_NORMAL_MASK;
|
|
val |= REG_DCDC3_VBIT_DSLEEP(dsleep_v);
|
|
val |= REG_DCDC3_VBIT_NORMAL(normal_v);
|
|
pmu_write(PMU_REG_DCDC_HPPA_VOLT, val);
|
|
|
|
if (normal_v > dsleep_v) {
|
|
dcdc_ramp_map |= REG_DCDC3_RAMP_EN;
|
|
} else {
|
|
dcdc_ramp_map &= ~REG_DCDC3_RAMP_EN;
|
|
}
|
|
}
|
|
|
|
static void pmu_dcdc_hppa_en(int enable) {
|
|
uint16_t val;
|
|
|
|
if (enable) {
|
|
pmu_read(PMU_REG_DCDC_HPPA_CFG_1D, &val);
|
|
val |= DCDC3_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1D, val);
|
|
}
|
|
|
|
pmu_read(PMU_REG_DCDC_HPPA_EN, &val);
|
|
if (enable) {
|
|
#ifdef DCDC_ULP_LP_ON
|
|
val = (val & ~REG_DCDC3_ULP_MODE_NORMAL) | REG_DCDC3_ULP_MODE_DSLEEP |
|
|
REG_PU_DCDC3_DR | REG_PU_DCDC3;
|
|
#else
|
|
val = (val & ~REG_DCDC3_ULP_MODE_NORMAL) | REG_PU_DCDC3_DR | REG_PU_DCDC3;
|
|
#endif
|
|
} else {
|
|
val = (val & ~(REG_DCDC3_ULP_MODE_NORMAL | REG_PU_DCDC3)) | REG_PU_DCDC3_DR;
|
|
}
|
|
pmu_write(PMU_REG_DCDC_HPPA_EN, val);
|
|
|
|
if (enable) {
|
|
hal_sys_timer_delay_us(PMU_DCDC_PU_STABLE_TIME_US);
|
|
pmu_read(PMU_REG_DCDC_HPPA_CFG_1D, &val);
|
|
val &= ~DCDC3_REG_BYPASS;
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1D, val);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static uint32_t pmu_vhppa_mv_to_val(uint16_t mv) {
|
|
#ifdef HPPA_LDO_ON
|
|
return pmu_ldo_hppa_mv_to_val(mv);
|
|
#else
|
|
return pmu_dcdc_hppa_mv_to_val(mv);
|
|
#endif
|
|
}
|
|
|
|
static void POSSIBLY_UNUSED pmu_hppa_get_volt(unsigned short *normal_vp,
|
|
unsigned short *dsleep_vp) {
|
|
#ifdef HPPA_LDO_ON
|
|
pmu_ldo_hppa_get_volt(normal_vp, dsleep_vp);
|
|
#else
|
|
pmu_dcdc_hppa_get_volt(normal_vp, dsleep_vp);
|
|
#endif
|
|
}
|
|
|
|
static void pmu_hppa_set_volt(unsigned short normal_v,
|
|
unsigned short dsleep_v) {
|
|
#ifdef HPPA_LDO_ON
|
|
pmu_ldo_hppa_set_volt(normal_v, dsleep_v);
|
|
#else
|
|
pmu_dcdc_hppa_set_volt(normal_v, dsleep_v);
|
|
#endif
|
|
}
|
|
|
|
static void pmu_hppa_en(int enable) {
|
|
#ifdef HPPA_LDO_ON
|
|
pmu_ldo_hppa_en(enable);
|
|
#else
|
|
pmu_dcdc_hppa_en(enable);
|
|
#endif
|
|
}
|
|
|
|
static void pmu_hppa_dcdc_to_ldo(void) {
|
|
#ifndef HPPA_LDO_ON
|
|
uint16_t val;
|
|
uint16_t act_volt;
|
|
|
|
pmu_ldo_hppa_en(true);
|
|
|
|
val = pmu_dcdc_hppa_mv_to_val(vhppa_mv);
|
|
pmu_dcdc_hppa_get_volt(&act_volt, NULL);
|
|
if (val < act_volt) {
|
|
val = pmu_ldo_hppa_mv_to_val(HPPA_RAMP_UP_VOLT_MV);
|
|
} else {
|
|
val = pmu_ldo_hppa_mv_to_val(vhppa_mv);
|
|
}
|
|
pmu_ldo_hppa_set_volt(val, val);
|
|
|
|
hal_sys_timer_delay_us(PMU_LDO_PU_STABLE_TIME_US);
|
|
#endif
|
|
}
|
|
|
|
static void BOOT_TEXT_FLASH_LOC pmu_dig_init_volt(void) {
|
|
uint16_t ldo_volt;
|
|
uint16_t val;
|
|
|
|
pmu_dig_get_target_volt(&ldo_volt, NULL);
|
|
|
|
pmu_read(PMU_REG_DIG_CFG, &val);
|
|
if (GET_BITFIELD(val, LDO_DIG_VBIT_NORMAL) < ldo_volt) {
|
|
val = SET_BITFIELD(val, LDO_DIG_VBIT_NORMAL, ldo_volt);
|
|
pmu_write(PMU_REG_DIG_CFG, val);
|
|
}
|
|
}
|
|
|
|
int pmu_codec_volt_ramp_up(void) {
|
|
#ifndef VMEM_ON
|
|
unsigned short normal, dsleep;
|
|
unsigned short target;
|
|
const unsigned short step =
|
|
#ifdef HPPA_LDO_ON
|
|
1;
|
|
#else
|
|
8;
|
|
#endif
|
|
|
|
if (vcodec_off) {
|
|
target = pmu_vhppa_mv_to_val(HPPA_RAMP_UP_VOLT_MV);
|
|
|
|
pmu_hppa_get_volt(&normal, &dsleep);
|
|
|
|
if (normal < target) {
|
|
if (normal + step < target) {
|
|
normal += step;
|
|
} else {
|
|
normal = target;
|
|
}
|
|
|
|
pmu_hppa_set_volt(normal, dsleep);
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
int pmu_codec_volt_ramp_down(void) {
|
|
#ifndef VMEM_ON
|
|
unsigned short normal, dsleep;
|
|
unsigned short target;
|
|
const unsigned short step =
|
|
#ifdef HPPA_LDO_ON
|
|
1;
|
|
#else
|
|
8;
|
|
#endif
|
|
|
|
if (vcodec_off) {
|
|
target = pmu_vhppa_mv_to_val(vhppa_mv);
|
|
|
|
pmu_hppa_get_volt(&normal, &dsleep);
|
|
|
|
if (normal > target) {
|
|
if (normal - step > target) {
|
|
normal -= step;
|
|
} else {
|
|
normal = target;
|
|
}
|
|
|
|
pmu_hppa_set_volt(normal, dsleep);
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
int BOOT_TEXT_FLASH_LOC pmu_open(void) {
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
|
|
uint16_t val;
|
|
enum PMU_POWER_MODE_T mode;
|
|
enum PMU_MODUAL_T codec;
|
|
|
|
ASSERT(!vcodec_off || vcodec_mv == vhppa_mv,
|
|
"Invalid vcodec/vhppa cfg: vcodec_off=%d vcodec_mv=%u vhppa_mv=%u",
|
|
vcodec_off, vcodec_mv, vhppa_mv);
|
|
ASSERT(vcodec_mv == 1600 || vcodec_mv == 1700 || vcodec_mv == 1800 ||
|
|
vcodec_mv == 1900 || vcodec_mv == 1950,
|
|
"Invalid vcodec cfg: vcodec_mv=%u", vcodec_mv);
|
|
ASSERT(vhppa_mv == 1600 || vhppa_mv == 1700 || vhppa_mv == 1800 ||
|
|
vhppa_mv == 1900 || vhppa_mv == 1950,
|
|
"Invalid vhppa cfg: vhppa_mv=%u", vhppa_mv);
|
|
|
|
// Disable and clear all PMU irqs by default
|
|
pmu_write(PMU_REG_INT_MASK, 0);
|
|
pmu_write(PMU_REG_INT_EN, 0);
|
|
// PMU irqs cannot be cleared by PMU soft reset
|
|
pmu_read(PMU_REG_CHARGER_STATUS, &val);
|
|
pmu_write(PMU_REG_CHARGER_STATUS, val);
|
|
pmu_read(PMU_REG_INT_STATUS, &val);
|
|
pmu_write(PMU_REG_INT_CLR, val);
|
|
|
|
pmu_read(PMU_REG_POWER_KEY_CFG, &val);
|
|
// Allow PMU to sleep when power key is pressed
|
|
val &= ~POWERKEY_WAKEUP_OSC_EN;
|
|
// Increase big bandgap startup time (stable time)
|
|
val = SET_BITFIELD(val, REG_VCORE_SSTIME_MODE, 2);
|
|
pmu_write(PMU_REG_POWER_KEY_CFG, val);
|
|
|
|
#ifdef FORCE_BIG_BANDGAP
|
|
// Force big bandgap
|
|
pmu_read(PMU_REG_INT_EN, &val);
|
|
val |= REG_BG_SLEEP_MSK;
|
|
pmu_write(PMU_REG_INT_EN, val);
|
|
pmu_read(PMU_REG_BIAS_CFG, &val);
|
|
val |= BG_CONSTANT_GM_BIAS_DR | BG_CONSTANT_GM_BIAS_REG;
|
|
val |= BG_CORE_EN_DR | BG_CORE_EN_REG;
|
|
pmu_write(PMU_REG_BIAS_CFG, val);
|
|
hal_sys_timer_delay_us(20);
|
|
val |= BG_VBG_SEL_DR | BG_VBG_SEL_REG;
|
|
pmu_write(PMU_REG_BIAS_CFG, val);
|
|
#else
|
|
// Allow low power bandgap
|
|
pmu_read(PMU_REG_BIAS_CFG, &val);
|
|
val &= ~BG_VBG_SEL_DR;
|
|
pmu_write(PMU_REG_BIAS_CFG, val);
|
|
#endif
|
|
|
|
// Init DCDC settings part 1
|
|
if (pmu_metal_id >= HAL_CHIP_METAL_ID_1) {
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_16, 0x8E0F);
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_17, 0x0211);
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_18, 0xA484);
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_19, 0xE210);
|
|
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1A, 0x8E0F);
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1B, 0x0211);
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1C, 0xA484);
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1D, 0xE210);
|
|
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_33, 0x8E0F);
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_34, 0x0211);
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_35, 0xA484);
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_36, 0xE210);
|
|
|
|
pmu_read(PMU_REG_MIC_LDO_EN, &val);
|
|
val |= DCDC1_OFFSET_CURRENT_EN;
|
|
pmu_write(PMU_REG_MIC_LDO_EN, val);
|
|
|
|
pmu_read(PMU_REG_DCDC1_OFFSET, &val);
|
|
val = SET_BITFIELD(val, DCDC1_OFFSET_BIT, 0xE0);
|
|
pmu_write(PMU_REG_DCDC1_OFFSET, val);
|
|
}
|
|
|
|
#ifdef PMU_DCDC_CALIB
|
|
pmu_get_dcdc_calib_value();
|
|
#endif
|
|
|
|
#ifndef NO_SLEEP
|
|
pmu_sleep_en(true);
|
|
#endif
|
|
|
|
// Disable vbat2vcore
|
|
pmu_module_config(PMU_BAT2DIG, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
#ifdef LBRT
|
|
// Enable vbuck2ana
|
|
pmu_module_config(PMU_BUCK2ANA, PMU_MANUAL_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_ON);
|
|
pmu_module_set_volt(PMU_BUCK2ANA, PMU_VBUCK2ANA_1_3V, PMU_VBUCK2ANA_1_3V);
|
|
// Disable vana dcdc
|
|
pmu_read(PMU_REG_HPPA_LDO_EN, &val);
|
|
val &= ~REG_BYPASS_VBUCK2ANA;
|
|
pmu_write(PMU_REG_HPPA_LDO_EN, val);
|
|
#else
|
|
// Disable vbuck2ana
|
|
pmu_module_config(PMU_BUCK2ANA, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
#endif
|
|
|
|
// Disable vhppa ldo
|
|
pmu_ldo_hppa_en(false);
|
|
|
|
#ifdef VMEM_ON
|
|
pmu_module_config(PMU_MEM, PMU_MANUAL_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_ON);
|
|
pmu_module_ramp_volt(PMU_MEM, PMU_VMEM_1_8V, PMU_VMEM_1_8V);
|
|
pmu_hppa_en(false);
|
|
// VHPPA will be enabled/disabled dynamically. Enable soft start.
|
|
pmu_read(PMU_REG_DCDC_HPPA_CFG_1D, &val);
|
|
val |= DCDC3_SOFT_START_EN;
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1D, val);
|
|
#else
|
|
// vmem and vhppa is shorted -- enable vhppa dcdc and disable vmem ldo
|
|
val = pmu_vhppa_mv_to_val(1800);
|
|
pmu_hppa_set_volt(val, val);
|
|
pmu_hppa_en(true);
|
|
pmu_module_config(PMU_MEM, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
#endif
|
|
|
|
pmu_module_config(PMU_GP, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
|
|
#ifndef PROGRAMMER
|
|
#ifdef VUSB_ON
|
|
pmu_vusb_req |= PMU_VUSB_REQ_INIT;
|
|
#endif
|
|
// Disable usbphy power, and vusb if possible
|
|
pmu_usb_config(PMU_USB_CONFIG_TYPE_NONE);
|
|
#ifdef VUSB_ON
|
|
pmu_vusb_req &= ~PMU_VUSB_REQ_INIT;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef __BEST_FLASH_VIA_ANA__
|
|
pmu_module_config(PMU_IO, PMU_AUTO_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
#else
|
|
pmu_module_config(PMU_IO, PMU_AUTO_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_ON);
|
|
#endif
|
|
pmu_module_ramp_volt(PMU_IO, vio_lp, vio_act_normal);
|
|
|
|
// Disable vcodec
|
|
pmu_module_config(PMU_CODEC, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
// Disable vhppa2vcodec
|
|
pmu_module_config(PMU_HPPA2CODEC, PMU_MANUAL_MODE, PMU_LDO_OFF,
|
|
PMU_LP_MODE_ON, PMU_DSLEEP_MODE_OFF);
|
|
#ifdef VHPPA2VCODEC
|
|
codec = PMU_HPPA2CODEC;
|
|
#else
|
|
codec = PMU_CODEC;
|
|
#endif
|
|
val = pmu_vcodec_mv_to_val(vcodec_mv);
|
|
// No need to ramp because the LDO is disabled (and its soft start is enabled)
|
|
pmu_module_set_volt(codec, val, val);
|
|
|
|
val = pmu_vhppa_mv_to_val(vhppa_mv);
|
|
#ifdef VMEM_ON
|
|
// No need to ramp because VHPPA is disabled (and its soft start is enabled)
|
|
pmu_hppa_set_volt(val, val);
|
|
#else
|
|
uint16_t old_act_volt;
|
|
uint16_t old_lp_volt;
|
|
|
|
// VHPPA is on. Ramp is needed.
|
|
pmu_hppa_get_volt(&old_act_volt, &old_lp_volt);
|
|
if (old_act_volt < val) {
|
|
while (old_act_volt++ < val) {
|
|
pmu_hppa_set_volt(old_act_volt, val);
|
|
}
|
|
} else if (old_act_volt != val || old_lp_volt != val) {
|
|
pmu_hppa_set_volt(val, val);
|
|
}
|
|
#endif
|
|
|
|
#ifdef DIG_DCDC_MODE
|
|
mode = PMU_POWER_MODE_DIG_DCDC;
|
|
#elif defined(ANA_DCDC_MODE)
|
|
mode = PMU_POWER_MODE_ANA_DCDC;
|
|
#else // LDO_MODE
|
|
mode = PMU_POWER_MODE_LDO;
|
|
#endif
|
|
|
|
pmu_mode_change(mode);
|
|
|
|
#ifdef RTC_ENABLE
|
|
pmu_rtc_restore_context();
|
|
#endif
|
|
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
// Increase bbpll voltage
|
|
pmu_write(0xA0, 0x3FE8); // div=2 (bit14=0)
|
|
pmu_write(0xA1, 0xF918);
|
|
|
|
pmu_high_performance_mode_enable(true);
|
|
#endif
|
|
|
|
// Init DCDC settings part 2
|
|
if (pmu_metal_id >= HAL_CHIP_METAL_ID_1) {
|
|
hal_sys_timer_delay_us(5000);
|
|
pmu_write(PMU_REG_DCDC_ANA_CFG_16, 0x8E1F);
|
|
pmu_write(PMU_REG_DCDC_HPPA_CFG_1A, 0x8E1F);
|
|
pmu_write(PMU_REG_DCDC_DIG_CFG_33, 0x8E1F);
|
|
}
|
|
#endif // PMU_INIT || (!PROGRAMMER)
|
|
|
|
return 0;
|
|
}
|
|
|
|
void pmu_codec_vad_save_power(void) {
|
|
uint16_t val;
|
|
|
|
// reduce ldo power supply
|
|
pmu_read(PMU_REG_DCDC_RAMP_EN, &val);
|
|
val &= ~REG_MIC_BIASA_IX2;
|
|
pmu_write(PMU_REG_DCDC_RAMP_EN, val);
|
|
|
|
// enable dcdc1 low power mode
|
|
pmu_read(PMU_REG_DCDC_DIG_EN, &val);
|
|
val |= REG_DCDC1_ULP_MODE_NORMAL;
|
|
pmu_write(PMU_REG_DCDC_DIG_EN, val);
|
|
|
|
// enable dcdc2 low power mode
|
|
pmu_read(PMU_REG_DCDC_ANA_EN, &val);
|
|
val |= REG_DCDC2_ULP_MODE_NORMAL;
|
|
pmu_write(PMU_REG_DCDC_ANA_EN, val);
|
|
|
|
// enable dcdc3 low power mode
|
|
pmu_read(PMU_REG_DCDC_HPPA_EN, &val);
|
|
val |= REG_DCDC3_ULP_MODE_NORMAL;
|
|
pmu_write(PMU_REG_DCDC_HPPA_EN, val);
|
|
}
|
|
|
|
void pmu_codec_vad_restore_power(void) {
|
|
uint16_t val;
|
|
|
|
// restore ldo power supply
|
|
pmu_read(PMU_REG_DCDC_RAMP_EN, &val);
|
|
val |= REG_MIC_BIASA_IX2;
|
|
pmu_write(PMU_REG_DCDC_RAMP_EN, val);
|
|
|
|
// disable dcdc1 low power mode
|
|
pmu_read(PMU_REG_DCDC_DIG_EN, &val);
|
|
val &= ~REG_DCDC1_ULP_MODE_NORMAL;
|
|
pmu_write(PMU_REG_DCDC_DIG_EN, val);
|
|
|
|
// disable dcdc2 low power mode
|
|
pmu_read(PMU_REG_DCDC_ANA_EN, &val);
|
|
val &= ~REG_DCDC2_ULP_MODE_NORMAL;
|
|
pmu_write(PMU_REG_DCDC_ANA_EN, val);
|
|
|
|
// disable dcdc3 low power mode
|
|
pmu_read(PMU_REG_DCDC_HPPA_EN, &val);
|
|
val &= ~REG_DCDC3_ULP_MODE_NORMAL;
|
|
pmu_write(PMU_REG_DCDC_HPPA_EN, val);
|
|
}
|
|
|
|
void pmu_sleep(void) {
|
|
uint16_t val;
|
|
|
|
if (dcdc_ramp_map) {
|
|
// Enable DCDC ramp
|
|
pmu_read(PMU_REG_DCDC_RAMP_EN, &val);
|
|
val |= dcdc_ramp_map;
|
|
pmu_write(PMU_REG_DCDC_RAMP_EN, val);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void pmu_wakeup(void) {
|
|
uint16_t val;
|
|
|
|
if (dcdc_ramp_map) {
|
|
// Disable DCDC ramp so that s/w can control the voltages freely
|
|
pmu_read(PMU_REG_DCDC_RAMP_EN, &val);
|
|
val &= ~dcdc_ramp_map;
|
|
pmu_write(PMU_REG_DCDC_RAMP_EN, val);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void pmu_codec_config(int enable) {
|
|
enum PMU_MODUAL_T codec;
|
|
|
|
#ifdef VHPPA2VCODEC
|
|
codec = PMU_HPPA2CODEC;
|
|
#else
|
|
codec = PMU_CODEC;
|
|
#endif
|
|
|
|
if (vcodec_off) {
|
|
#ifdef VMEM_ON
|
|
pmu_hppa_en(enable);
|
|
#endif
|
|
} else {
|
|
if (enable) {
|
|
pmu_module_config(codec, PMU_MANUAL_MODE, PMU_LDO_ON, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
} else {
|
|
pmu_module_config(codec, PMU_MANUAL_MODE, PMU_LDO_OFF, PMU_LP_MODE_ON,
|
|
PMU_DSLEEP_MODE_OFF);
|
|
}
|
|
}
|
|
}
|
|
|
|
void pmu_codec_hppa_enable(int enable) {
|
|
if (!vcodec_off) {
|
|
#ifdef VMEM_ON
|
|
pmu_hppa_en(enable);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static uint32_t mic_bias_remap(uint32_t map) {
|
|
// The vmic1 pin has been replaced by the vmic3 pin in package bonding for all
|
|
// chip models since ver-B
|
|
if (hal_get_chip_metal_id() >= HAL_CHIP_METAL_ID_1) {
|
|
if (map & AUD_VMIC_MAP_VMIC1) {
|
|
map = (map & ~AUD_VMIC_MAP_VMIC1) | AUD_VMIC_MAP_VMIC3;
|
|
}
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
void pmu_codec_mic_bias_enable(uint32_t map) {
|
|
uint16_t val;
|
|
int i;
|
|
enum PMU_REG_T bias_reg;
|
|
uint16_t ldo_en;
|
|
uint8_t volt;
|
|
uint8_t res;
|
|
static const uint16_t ldo_mask = REG_MIC_LDOA_EN | REG_MIC_LDOB_EN |
|
|
REG_MIC_LDOC_EN | REG_MIC_LDOD_EN |
|
|
REG_MIC_LDOE_EN;
|
|
|
|
map = mic_bias_remap(map);
|
|
|
|
#ifdef DIGMIC_HIGH_VOLT
|
|
volt = PMU_VMIC_3_3V;
|
|
#else
|
|
volt = PMU_VMIC_2_2V;
|
|
#endif
|
|
|
|
if (vcodec_mv < 1900) {
|
|
if (volt >= 0x1F) {
|
|
volt = 0x1F;
|
|
} else {
|
|
volt += 1;
|
|
}
|
|
}
|
|
|
|
res = PMU_VMIC_RES_3_3V;
|
|
|
|
ldo_en = 0;
|
|
for (i = 0; i < MAX_ANA_MIC_CH_NUM; i++) {
|
|
if (i == MAX_ANA_MIC_CH_NUM - 1) {
|
|
bias_reg = PMU_REG_MIC_BIAS_E;
|
|
} else {
|
|
bias_reg = PMU_REG_MIC_BIAS_A + i;
|
|
}
|
|
pmu_read(bias_reg, &val);
|
|
if (map & (AUD_VMIC_MAP_VMIC1 << i)) {
|
|
ldo_en |= (REG_MIC_LDOA_EN >> i);
|
|
val = (val & ~(REG_MIC_BIASA_VSEL_MASK | REG_MIC_LDOA_RES_MASK)) |
|
|
REG_MIC_BIASA_VSEL(volt) | REG_MIC_LDOA_RES(res) | REG_MIC_BIASA_EN;
|
|
} else {
|
|
val &= ~REG_MIC_BIASA_EN;
|
|
}
|
|
pmu_write(bias_reg, val);
|
|
}
|
|
pmu_read(PMU_REG_MIC_LDO_EN, &val);
|
|
val = (val & ~ldo_mask) | ldo_en;
|
|
pmu_write(PMU_REG_MIC_LDO_EN, val);
|
|
}
|
|
|
|
void pmu_codec_mic_bias_lowpower_mode(uint32_t map) {
|
|
uint16_t val;
|
|
|
|
map = mic_bias_remap(map);
|
|
|
|
if (map & AUD_VMIC_MAP_VMIC3) {
|
|
pmu_read(PMU_REG_DCDC_RAMP_EN, &val);
|
|
val &= ~REG_MIC_BIASC_IX2;
|
|
pmu_write(PMU_REG_DCDC_RAMP_EN, val);
|
|
|
|
pmu_read(PMU_REG_MIC_BIAS_C, &val);
|
|
val = SET_BITFIELD(val, REG_MIC_BIASC_CHANSEL, 0x3);
|
|
pmu_write(PMU_REG_MIC_BIAS_C, val);
|
|
}
|
|
}
|
|
|
|
void pmu_codec_adc_pre_start(void) {}
|
|
|
|
void pmu_codec_adc_post_start(void (*delay_ms)(uint32_t)) {}
|
|
|
|
void pmu_codec_dac_pre_start(void) {}
|
|
|
|
void pmu_codec_dac_post_start(void (*delay_ms)(uint32_t)) {}
|
|
|
|
SRAM_TEXT_LOC void pmu_flash_write_config(void) {
|
|
#ifdef FLASH_WRITE_AT_HIGH_VCORE
|
|
uint32_t lock;
|
|
|
|
if (pmu_vcore_req & PMU_VCORE_FLASH_WRITE_ENABLED) {
|
|
return;
|
|
}
|
|
|
|
#if defined(__PMU_VIO_DYNAMIC_CTRL_MODE__)
|
|
pmu_viorise_req(PMU_VIORISE_REQ_USER_FLASH, true);
|
|
#endif
|
|
|
|
lock = int_lock();
|
|
pmu_vcore_req |= PMU_VCORE_FLASH_WRITE_ENABLED;
|
|
int_unlock(lock);
|
|
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
#endif
|
|
}
|
|
|
|
SRAM_TEXT_LOC void pmu_flash_read_config(void) {
|
|
#ifdef FLASH_WRITE_AT_HIGH_VCORE
|
|
uint32_t lock;
|
|
|
|
if ((pmu_vcore_req & PMU_VCORE_FLASH_WRITE_ENABLED) == 0) {
|
|
return;
|
|
}
|
|
|
|
lock = int_lock();
|
|
pmu_vcore_req &= ~PMU_VCORE_FLASH_WRITE_ENABLED;
|
|
int_unlock(lock);
|
|
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
|
|
#if defined(__PMU_VIO_DYNAMIC_CTRL_MODE__)
|
|
pmu_viorise_req(PMU_VIORISE_REQ_USER_FLASH, false);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void BOOT_TEXT_FLASH_LOC pmu_flash_freq_config(uint32_t freq) {
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
uint32_t lock;
|
|
|
|
lock = int_lock();
|
|
if (freq > 52000000) {
|
|
// The real max freq is 120M
|
|
// pmu_vcore_req |= PMU_VCORE_FLASH_FREQ_HIGH;
|
|
} else {
|
|
pmu_vcore_req &= ~PMU_VCORE_FLASH_FREQ_HIGH;
|
|
}
|
|
int_unlock(lock);
|
|
|
|
if (pmu_power_mode == PMU_POWER_MODE_NONE) {
|
|
// PMU not init yet
|
|
pmu_dig_init_volt();
|
|
return;
|
|
}
|
|
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
#endif
|
|
}
|
|
|
|
void BOOT_TEXT_FLASH_LOC pmu_psram_freq_config(uint32_t freq) {
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
uint32_t lock;
|
|
|
|
lock = int_lock();
|
|
if (freq > 52000000) {
|
|
pmu_vcore_req |= PMU_VCORE_PSRAM_FREQ_HIGH;
|
|
} else {
|
|
pmu_vcore_req &= ~PMU_VCORE_PSRAM_FREQ_HIGH;
|
|
}
|
|
int_unlock(lock);
|
|
|
|
if (pmu_power_mode == PMU_POWER_MODE_NONE) {
|
|
// PMU not init yet
|
|
pmu_dig_init_volt();
|
|
return;
|
|
}
|
|
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
#endif
|
|
}
|
|
|
|
void pmu_anc_config(int enable) {}
|
|
|
|
void pmu_fir_high_speed_config(int enable) {}
|
|
|
|
void pmu_iir_freq_config(uint32_t freq) {}
|
|
|
|
void pmu_rs_freq_config(uint32_t freq) {
|
|
uint32_t lock;
|
|
|
|
lock = int_lock();
|
|
if (freq >= 60000000) {
|
|
pmu_vcore_req |= PMU_VCORE_RS_FREQ_HIGH;
|
|
} else {
|
|
pmu_vcore_req &= ~PMU_VCORE_RS_FREQ_HIGH;
|
|
}
|
|
int_unlock(lock);
|
|
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
}
|
|
|
|
void BOOT_TEXT_SRAM_LOC pmu_sys_freq_config(enum HAL_CMU_FREQ_T freq) {
|
|
#if defined(PMU_INIT) || (!defined(PROGRAMMER))
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE) || defined(ULTRA_LOW_POWER) || \
|
|
!defined(OSC_26M_X4_AUD2BB)
|
|
uint32_t lock;
|
|
enum PMU_VCORE_REQ_T old_req;
|
|
bool update = false;
|
|
|
|
lock = int_lock();
|
|
old_req = pmu_vcore_req;
|
|
pmu_vcore_req &= ~(PMU_VCORE_SYS_FREQ_HIGH | PMU_VCORE_SYS_FREQ_MEDIUM);
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
if (freq > HAL_CMU_FREQ_104M) {
|
|
if (high_perf_on) {
|
|
// The real freq is 350M
|
|
pmu_vcore_req |= PMU_VCORE_SYS_FREQ_HIGH;
|
|
} else {
|
|
pmu_vcore_req |= PMU_VCORE_SYS_FREQ_MEDIUM;
|
|
}
|
|
} else {
|
|
#ifndef OSC_26M_X4_AUD2BB
|
|
if (freq == HAL_CMU_FREQ_104M) {
|
|
// The real freq is 200M
|
|
pmu_vcore_req |= PMU_VCORE_SYS_FREQ_MEDIUM;
|
|
}
|
|
#endif
|
|
}
|
|
#else
|
|
if (freq > HAL_CMU_FREQ_104M) {
|
|
pmu_vcore_req |= PMU_VCORE_SYS_FREQ_MEDIUM;
|
|
}
|
|
#endif
|
|
if (old_req != pmu_vcore_req) {
|
|
update = true;
|
|
}
|
|
int_unlock(lock);
|
|
|
|
if (!update) {
|
|
// Nothing changes
|
|
return;
|
|
}
|
|
|
|
if (pmu_power_mode == PMU_POWER_MODE_NONE) {
|
|
// PMU not init yet
|
|
pmu_dig_init_volt();
|
|
return;
|
|
}
|
|
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void pmu_high_performance_mode_enable(bool enable) {
|
|
#if defined(MCU_HIGH_PERFORMANCE_MODE)
|
|
uint16_t val;
|
|
|
|
if (high_perf_on == enable) {
|
|
return;
|
|
}
|
|
high_perf_on = enable;
|
|
|
|
if (!enable) {
|
|
if (high_perf_freq_mhz > 300) {
|
|
// Switch to 52M to avoid using PLL
|
|
hal_cmu_sys_set_freq(HAL_CMU_FREQ_52M);
|
|
// Restore the default div
|
|
pmu_read(0xA0, &val);
|
|
val &= ~(1 << 14); // div=2 (bit14=0)
|
|
pmu_write(0xA0, val);
|
|
// Restore the sys freq
|
|
hal_cmu_sys_set_freq(hal_sysfreq_get_hw_freq());
|
|
}
|
|
// Restore the default PLL freq (384M)
|
|
bbpll_freq_pll_config(192 * 1000000 * 2);
|
|
}
|
|
|
|
pmu_sys_freq_config(hal_sysfreq_get_hw_freq());
|
|
|
|
if (enable) {
|
|
uint32_t pll_freq;
|
|
|
|
// Change freq first, and then change divider.
|
|
// Otherwise there will be an instant very high freq sent to digital domain.
|
|
|
|
if (high_perf_freq_mhz <= 300) {
|
|
pll_freq = high_perf_freq_mhz * 1000000 * 2;
|
|
} else {
|
|
pll_freq = high_perf_freq_mhz * 1000000;
|
|
}
|
|
bbpll_freq_pll_config(pll_freq);
|
|
|
|
if (high_perf_freq_mhz > 300) {
|
|
// Switch to 52M to avoid using PLL
|
|
hal_cmu_sys_set_freq(HAL_CMU_FREQ_52M);
|
|
pmu_read(0xA0, &val);
|
|
val |= (1 << 14); // div=1 (bit14=1)
|
|
pmu_write(0xA0, val);
|
|
// Restore the sys freq
|
|
hal_cmu_sys_set_freq(hal_sysfreq_get_hw_freq());
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void pmu_usb_config(enum PMU_USB_CONFIG_TYPE_T type) {
|
|
uint32_t lock;
|
|
bool update;
|
|
unsigned short ldo_on, deep_sleep_on;
|
|
|
|
update = false;
|
|
|
|
if (type == PMU_USB_CONFIG_TYPE_NONE) {
|
|
usbphy_ldo_config(false);
|
|
|
|
ldo_on = PMU_LDO_OFF;
|
|
deep_sleep_on = PMU_DSLEEP_MODE_OFF;
|
|
} else {
|
|
ldo_on = PMU_LDO_ON;
|
|
deep_sleep_on = PMU_DSLEEP_MODE_ON;
|
|
}
|
|
|
|
lock = int_lock();
|
|
|
|
if (type == PMU_USB_CONFIG_TYPE_NONE) {
|
|
pmu_vusb_req &= ~PMU_VUSB_REQ_USB;
|
|
if (pmu_vusb_req == 0) {
|
|
update = true;
|
|
}
|
|
} else {
|
|
if (pmu_vusb_req == 0) {
|
|
update = true;
|
|
}
|
|
pmu_vusb_req |= PMU_VUSB_REQ_USB;
|
|
}
|
|
|
|
if (update) {
|
|
pmu_module_config(PMU_USB, PMU_MANUAL_MODE, ldo_on, PMU_LP_MODE_ON,
|
|
deep_sleep_on);
|
|
}
|
|
|
|
#ifdef USB_HIGH_SPEED
|
|
if (type == PMU_USB_CONFIG_TYPE_NONE) {
|
|
pmu_vcore_req &= ~PMU_VCORE_USB_HS_ENABLED;
|
|
} else {
|
|
pmu_vcore_req |= PMU_VCORE_USB_HS_ENABLED;
|
|
}
|
|
#endif
|
|
|
|
int_unlock(lock);
|
|
|
|
if (pmu_power_mode != PMU_POWER_MODE_NONE) {
|
|
// PMU has been inited
|
|
pmu_dig_set_volt(0, PMU_POWER_MODE_NONE);
|
|
}
|
|
|
|
if (type != PMU_USB_CONFIG_TYPE_NONE) {
|
|
usbphy_ldo_config(true);
|
|
}
|
|
}
|
|
|
|
void pmu_lbrt_config(int enable) {
|
|
uint32_t lock;
|
|
bool update;
|
|
unsigned short ldo_on, deep_sleep_on;
|
|
|
|
update = false;
|
|
|
|
if (enable) {
|
|
ldo_on = PMU_LDO_ON;
|
|
deep_sleep_on = PMU_DSLEEP_MODE_ON;
|
|
} else {
|
|
ldo_on = PMU_LDO_OFF;
|
|
deep_sleep_on = PMU_DSLEEP_MODE_OFF;
|
|
}
|
|
|
|
lock = int_lock();
|
|
|
|
if (enable) {
|
|
if (pmu_vusb_req == 0) {
|
|
update = true;
|
|
}
|
|
pmu_vusb_req |= PMU_VUSB_REQ_LBRT;
|
|
} else {
|
|
pmu_vusb_req &= ~PMU_VUSB_REQ_LBRT;
|
|
if (pmu_vusb_req == 0) {
|
|
update = true;
|
|
}
|
|
}
|
|
|
|
if (update) {
|
|
pmu_module_config(PMU_USB, PMU_MANUAL_MODE, ldo_on, PMU_LP_MODE_ON,
|
|
deep_sleep_on);
|
|
}
|
|
|
|
int_unlock(lock);
|
|
}
|
|
|
|
struct PMU_CHG_CTX_T {
|
|
uint16_t pmu_chg_status;
|
|
};
|
|
|
|
struct PMU_CHG_CTX_T BOOT_BSS_LOC pmu_chg_ctx;
|
|
|
|
void BOOT_TEXT_SRAM_LOC pmu_charger_save_context(void) {
|
|
pmu_read(PMU_REG_CHARGER_STATUS, &pmu_chg_ctx.pmu_chg_status);
|
|
}
|
|
|
|
enum PMU_POWER_ON_CAUSE_T pmu_charger_poweron_status(void) {
|
|
enum PMU_POWER_ON_CAUSE_T pmu_power_on_cause = PMU_POWER_ON_CAUSE_NONE;
|
|
|
|
if (pmu_chg_ctx.pmu_chg_status & AC_ON_DET_OUT) {
|
|
pmu_power_on_cause = PMU_POWER_ON_CAUSE_CHARGER_ACOFF;
|
|
} else if (pmu_chg_ctx.pmu_chg_status & AC_ON) {
|
|
pmu_power_on_cause = PMU_POWER_ON_CAUSE_CHARGER_ACON;
|
|
}
|
|
return pmu_power_on_cause;
|
|
}
|
|
|
|
void pmu_charger_init(void) {
|
|
unsigned short readval_cfg;
|
|
uint32_t lock;
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_CHARGER_CFG, &readval_cfg);
|
|
readval_cfg &= ~(REG_CHARGE_IN_INTR_MSK | REG_CHARGE_OUT_INTR_MSK |
|
|
REG_AC_ON_OUT_EN | REG_AC_ON_IN_EN | REG_CHARGE_INTR_EN);
|
|
pmu_write(PMU_REG_CHARGER_CFG, readval_cfg);
|
|
int_unlock(lock);
|
|
|
|
// PMU irqs cannot be cleared by PMU soft reset
|
|
pmu_read(PMU_REG_CHARGER_STATUS, &readval_cfg);
|
|
pmu_write(PMU_REG_CHARGER_STATUS, readval_cfg);
|
|
pmu_read(PMU_REG_INT_STATUS, &readval_cfg);
|
|
pmu_write(PMU_REG_INT_CLR, readval_cfg);
|
|
|
|
hal_sys_timer_delay(MS_TO_TICKS(1));
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_CHARGER_CFG, &readval_cfg);
|
|
readval_cfg |= REG_AC_ON_OUT_EN | REG_AC_ON_IN_EN | REG_CHARGE_INTR_EN;
|
|
readval_cfg = SET_BITFIELD(readval_cfg, REG_AC_ON_DB_VALUE, 8);
|
|
pmu_write(PMU_REG_CHARGER_CFG, readval_cfg);
|
|
int_unlock(lock);
|
|
|
|
#ifdef PMU_ACON_CAUSE_POWER_UP
|
|
pmu_read(0x102, &readval_cfg);
|
|
readval_cfg |= 1;
|
|
pmu_write(0x102, readval_cfg);
|
|
#endif
|
|
}
|
|
|
|
void pmu_charger_shutdown_config(void) {
|
|
#ifdef PMU_ACON_CAUSE_POWER_UP
|
|
pmu_wdt_stop();
|
|
pmu_charger_init();
|
|
#endif
|
|
}
|
|
|
|
static void pmu_charger_irq_handler(uint16_t irq_status) {
|
|
enum PMU_CHARGER_STATUS_T status = PMU_CHARGER_UNKNOWN;
|
|
|
|
PMU_DEBUG_TRACE(3, "%s REG_%02X=0x%04X", __func__, PMU_REG_CHARGER_STATUS,
|
|
irq_status);
|
|
|
|
if ((irq_status & (AC_ON_DET_IN_MASKED | AC_ON_DET_OUT_MASKED)) == 0) {
|
|
PMU_DEBUG_TRACE(1, "%s SKIP", __func__);
|
|
return;
|
|
} else if ((irq_status & (AC_ON_DET_IN_MASKED | AC_ON_DET_OUT_MASKED)) ==
|
|
(AC_ON_DET_IN_MASKED | AC_ON_DET_OUT_MASKED)) {
|
|
PMU_DEBUG_TRACE(1, "%s DITHERING", __func__);
|
|
hal_sys_timer_delay(2);
|
|
} else {
|
|
PMU_DEBUG_TRACE(1, "%s NORMAL", __func__);
|
|
}
|
|
|
|
status = pmu_charger_get_status();
|
|
|
|
if (charger_irq_handler) {
|
|
charger_irq_handler(status);
|
|
}
|
|
}
|
|
|
|
void pmu_charger_set_irq_handler(PMU_CHARGER_IRQ_HANDLER_T handler) {
|
|
uint32_t lock;
|
|
uint16_t val;
|
|
|
|
charger_irq_handler = handler;
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_CHARGER_CFG, &val);
|
|
if (handler) {
|
|
val |= REG_CHARGE_IN_INTR_MSK | REG_CHARGE_OUT_INTR_MSK;
|
|
} else {
|
|
val &= ~(REG_CHARGE_IN_INTR_MSK | REG_CHARGE_OUT_INTR_MSK);
|
|
}
|
|
pmu_write(PMU_REG_CHARGER_CFG, val);
|
|
pmu_set_irq_unified_handler(PMU_IRQ_TYPE_CHARGER,
|
|
handler ? pmu_charger_irq_handler : NULL);
|
|
int_unlock(lock);
|
|
}
|
|
|
|
void pmu_charger_plugin_config(void) {
|
|
if (IO_VOLT_ACTIVE_RISE < PMU_IO_3_1V) {
|
|
vio_act_rise = PMU_IO_3_1V;
|
|
}
|
|
if (IO_VOLT_SLEEP < PMU_IO_3_2V) {
|
|
vio_lp = PMU_IO_3_2V;
|
|
}
|
|
pmu_viorise_req(PMU_VIORISE_REQ_USER_CHARGER, true);
|
|
}
|
|
|
|
void pmu_charger_plugout_config(void) {
|
|
vio_act_rise = IO_VOLT_ACTIVE_RISE;
|
|
vio_lp = IO_VOLT_SLEEP;
|
|
pmu_viorise_req(PMU_VIORISE_REQ_USER_CHARGER, false);
|
|
}
|
|
|
|
enum PMU_CHARGER_STATUS_T pmu_charger_get_status(void) {
|
|
unsigned short readval;
|
|
enum PMU_CHARGER_STATUS_T status;
|
|
|
|
pmu_read(PMU_REG_CHARGER_STATUS, &readval);
|
|
if (readval & AC_ON)
|
|
status = PMU_CHARGER_PLUGIN;
|
|
else
|
|
status = PMU_CHARGER_PLUGOUT;
|
|
|
|
return status;
|
|
}
|
|
|
|
#ifdef RTC_ENABLE
|
|
void pmu_rtc_enable(void) {
|
|
uint16_t readval;
|
|
uint32_t lock;
|
|
|
|
#ifdef SIMU
|
|
// Set RTC counter to 1KHz
|
|
pmu_write(PMU_REG_RTC_DIV_1HZ, 32 - 2);
|
|
#else
|
|
// Set RTC counter to 1Hz
|
|
pmu_write(PMU_REG_RTC_DIV_1HZ, CONFIG_SYSTICK_HZ * 2 - 2);
|
|
#endif
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_POWER_KEY_CFG, &readval);
|
|
readval |= RTC_POWER_ON_EN | PU_LPO_DR | PU_LPO_REG;
|
|
pmu_write(PMU_REG_POWER_KEY_CFG, readval);
|
|
int_unlock(lock);
|
|
}
|
|
|
|
void pmu_rtc_disable(void) {
|
|
uint16_t readval;
|
|
uint32_t lock;
|
|
|
|
pmu_rtc_clear_alarm();
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_POWER_KEY_CFG, &readval);
|
|
readval &= ~(RTC_POWER_ON_EN | PU_LPO_DR);
|
|
pmu_write(PMU_REG_POWER_KEY_CFG, readval);
|
|
int_unlock(lock);
|
|
}
|
|
|
|
int BOOT_TEXT_SRAM_LOC pmu_rtc_enabled(void) {
|
|
uint16_t readval;
|
|
|
|
pmu_read(PMU_REG_POWER_KEY_CFG, &readval);
|
|
|
|
return !!(readval & RTC_POWER_ON_EN);
|
|
}
|
|
|
|
void pmu_rtc_set(uint32_t seconds) {
|
|
uint16_t high, low;
|
|
|
|
// Need 3 seconds to load a new value
|
|
seconds += 3;
|
|
|
|
high = seconds >> 16;
|
|
low = seconds & 0xFFFF;
|
|
|
|
pmu_write(PMU_REG_RTC_LOAD_LOW, low);
|
|
pmu_write(PMU_REG_RTC_LOAD_HIGH, high);
|
|
}
|
|
|
|
uint32_t pmu_rtc_get(void) {
|
|
uint16_t high, low, high2;
|
|
|
|
pmu_read(PMU_REG_RTC_VAL_HIGH, &high);
|
|
pmu_read(PMU_REG_RTC_VAL_LOW, &low);
|
|
// Handle counter wrap
|
|
pmu_read(PMU_REG_RTC_VAL_HIGH, &high2);
|
|
if (high != high2) {
|
|
high = high2;
|
|
pmu_read(PMU_REG_RTC_VAL_LOW, &low);
|
|
}
|
|
|
|
return (high << 16) | low;
|
|
}
|
|
|
|
void pmu_rtc_set_alarm(uint32_t seconds) {
|
|
uint16_t readval;
|
|
uint16_t high, low;
|
|
uint32_t lock;
|
|
|
|
// Need 1 second to raise the interrupt
|
|
if (seconds > 0) {
|
|
seconds -= 1;
|
|
}
|
|
|
|
high = seconds >> 16;
|
|
low = seconds & 0xFFFF;
|
|
|
|
pmu_write(PMU_REG_INT_CLR, RTC_INT1_MSKED);
|
|
|
|
pmu_write(PMU_REG_RTC_MATCH1_LOW, low);
|
|
pmu_write(PMU_REG_RTC_MATCH1_HIGH, high);
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_INT_EN, &readval);
|
|
readval |= RTC_INT_EN_1;
|
|
pmu_write(PMU_REG_INT_EN, readval);
|
|
int_unlock(lock);
|
|
}
|
|
|
|
uint32_t BOOT_TEXT_SRAM_LOC pmu_rtc_get_alarm(void) {
|
|
uint16_t high, low;
|
|
|
|
pmu_read(PMU_REG_RTC_MATCH1_LOW, &low);
|
|
pmu_read(PMU_REG_RTC_MATCH1_HIGH, &high);
|
|
|
|
// Compensate the alarm offset
|
|
return (uint32_t)((high << 16) | low) + 1;
|
|
}
|
|
|
|
void pmu_rtc_clear_alarm(void) {
|
|
uint16_t readval;
|
|
uint32_t lock;
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_INT_EN, &readval);
|
|
readval &= ~RTC_INT_EN_1;
|
|
pmu_write(PMU_REG_INT_EN, readval);
|
|
int_unlock(lock);
|
|
|
|
pmu_write(PMU_REG_INT_CLR, RTC_INT1_MSKED);
|
|
}
|
|
|
|
int BOOT_TEXT_SRAM_LOC pmu_rtc_alarm_status_set(void) {
|
|
uint16_t readval;
|
|
|
|
pmu_read(PMU_REG_INT_EN, &readval);
|
|
|
|
return !!(readval & RTC_INT_EN_1);
|
|
}
|
|
|
|
int pmu_rtc_alarm_alerted() {
|
|
uint16_t readval;
|
|
|
|
pmu_read(PMU_REG_INT_STATUS, &readval);
|
|
|
|
return !!(readval & RTC_INT_1);
|
|
}
|
|
|
|
static void pmu_rtc_irq_handler(uint16_t irq_status) {
|
|
uint32_t seconds;
|
|
|
|
if (irq_status & RTC_INT1_MSKED) {
|
|
pmu_rtc_clear_alarm();
|
|
|
|
if (rtc_irq_handler) {
|
|
seconds = pmu_rtc_get();
|
|
rtc_irq_handler(seconds);
|
|
}
|
|
}
|
|
}
|
|
|
|
void pmu_rtc_set_irq_handler(PMU_RTC_IRQ_HANDLER_T handler) {
|
|
uint16_t readval;
|
|
uint32_t lock;
|
|
|
|
rtc_irq_handler = handler;
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_INT_MASK, &readval);
|
|
if (handler) {
|
|
readval |= RTC_INT1_MSK;
|
|
} else {
|
|
readval &= ~RTC_INT1_MSK;
|
|
}
|
|
pmu_write(PMU_REG_INT_MASK, readval);
|
|
pmu_set_irq_unified_handler(PMU_IRQ_TYPE_RTC,
|
|
handler ? pmu_rtc_irq_handler : NULL);
|
|
int_unlock(lock);
|
|
}
|
|
#endif
|
|
|
|
int pmu_pwrkey_set_irq(enum HAL_PWRKEY_IRQ_T type) {
|
|
uint16_t val;
|
|
uint16_t int_en;
|
|
|
|
if (type == HAL_PWRKEY_IRQ_NONE) {
|
|
// Clear existing IRQs
|
|
pmu_write(PMU_REG_CHARGER_STATUS, (POWER_ON_PRESS | POWER_ON_RELEASE));
|
|
// Disable future IRQs
|
|
int_en = 0;
|
|
} else if (type == HAL_PWRKEY_IRQ_FALLING_EDGE) {
|
|
int_en = POWERON_PRESS_EN;
|
|
} else if (type == HAL_PWRKEY_IRQ_RISING_EDGE) {
|
|
int_en = POWERON_RELEASE_EN;
|
|
} else if (type == HAL_PWRKEY_IRQ_BOTH_EDGE) {
|
|
int_en = POWERON_PRESS_EN | POWERON_RELEASE_EN;
|
|
} else {
|
|
return 1;
|
|
}
|
|
|
|
pmu_read(PMU_REG_SLEEP_CFG, &val);
|
|
val = (val & ~(POWERON_PRESS_EN | POWERON_RELEASE_EN)) | int_en;
|
|
pmu_write(PMU_REG_SLEEP_CFG, val);
|
|
|
|
return 0;
|
|
}
|
|
int hal_pwrkey_set_irq(enum HAL_PWRKEY_IRQ_T type)
|
|
__attribute__((alias("pmu_pwrkey_set_irq")));
|
|
|
|
bool pmu_pwrkey_pressed(void) {
|
|
uint16_t val;
|
|
|
|
pmu_read(PMU_REG_CHARGER_STATUS, &val);
|
|
|
|
return !!(val & POWER_ON);
|
|
}
|
|
bool hal_pwrkey_pressed(void) __attribute__((alias("pmu_pwrkey_pressed")));
|
|
|
|
enum HAL_PWRKEY_IRQ_T pmu_pwrkey_irq_value_to_state(uint16_t irq_status) {
|
|
enum HAL_PWRKEY_IRQ_T state = HAL_PWRKEY_IRQ_NONE;
|
|
|
|
if (irq_status & POWER_ON_PRESS) {
|
|
state |= HAL_PWRKEY_IRQ_FALLING_EDGE;
|
|
}
|
|
|
|
if (irq_status & POWER_ON_RELEASE) {
|
|
state |= HAL_PWRKEY_IRQ_RISING_EDGE;
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
static void pmu_general_irq_handler(void) {
|
|
uint32_t lock;
|
|
uint16_t val;
|
|
bool pwrkey, charger, gpadc, rtc;
|
|
|
|
pwrkey = false;
|
|
charger = false;
|
|
gpadc = false;
|
|
rtc = false;
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_CHARGER_STATUS, &val);
|
|
if (val & (POWER_ON_PRESS | POWER_ON_RELEASE)) {
|
|
pwrkey = true;
|
|
}
|
|
if (val & (AC_ON_DET_OUT_MASKED | AC_ON_DET_IN_MASKED)) {
|
|
charger = true;
|
|
}
|
|
if (pwrkey || charger) {
|
|
pmu_write(PMU_REG_CHARGER_STATUS, val);
|
|
}
|
|
int_unlock(lock);
|
|
|
|
if (pwrkey) {
|
|
if (pmu_irq_hdlrs[PMU_IRQ_TYPE_PWRKEY]) {
|
|
pmu_irq_hdlrs[PMU_IRQ_TYPE_PWRKEY](val);
|
|
}
|
|
}
|
|
if (charger) {
|
|
if (pmu_irq_hdlrs[PMU_IRQ_TYPE_CHARGER]) {
|
|
pmu_irq_hdlrs[PMU_IRQ_TYPE_CHARGER](val);
|
|
}
|
|
}
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_INT_MSKED_STATUS, &val);
|
|
if (val & (KEY_ERR1_INTR_MSKED | KEY_ERR0_INTR_MSKED | KEY_PRESS_INTR_MSKED |
|
|
KEY_RELEASE_INTR_MSKED | SAMPLE_DONE_INTR_MSKED |
|
|
CHAN_DATA_INTR_MSKED_MASK)) {
|
|
gpadc = true;
|
|
}
|
|
if (val & (RTC_INT1_MSKED | RTC_INT0_MSKED)) {
|
|
rtc = true;
|
|
}
|
|
if (gpadc || rtc) {
|
|
pmu_write(PMU_REG_INT_CLR, val);
|
|
}
|
|
int_unlock(lock);
|
|
|
|
if (gpadc) {
|
|
if (pmu_irq_hdlrs[PMU_IRQ_TYPE_GPADC]) {
|
|
pmu_irq_hdlrs[PMU_IRQ_TYPE_GPADC](val);
|
|
}
|
|
}
|
|
if (rtc) {
|
|
if (pmu_irq_hdlrs[PMU_IRQ_TYPE_RTC]) {
|
|
pmu_irq_hdlrs[PMU_IRQ_TYPE_RTC](val);
|
|
}
|
|
}
|
|
}
|
|
|
|
int pmu_set_irq_unified_handler(enum PMU_IRQ_TYPE_T type,
|
|
PMU_IRQ_UNIFIED_HANDLER_T hdlr) {
|
|
bool update;
|
|
uint32_t lock;
|
|
int i;
|
|
|
|
if (type >= PMU_IRQ_TYPE_QTY) {
|
|
return 1;
|
|
}
|
|
|
|
update = false;
|
|
|
|
lock = int_lock();
|
|
|
|
for (i = 0; i < PMU_IRQ_TYPE_QTY; i++) {
|
|
if (pmu_irq_hdlrs[i]) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
pmu_irq_hdlrs[type] = hdlr;
|
|
|
|
if (hdlr) {
|
|
update = (i >= PMU_IRQ_TYPE_QTY);
|
|
} else {
|
|
if (i == type) {
|
|
for (; i < PMU_IRQ_TYPE_QTY; i++) {
|
|
if (pmu_irq_hdlrs[i]) {
|
|
break;
|
|
}
|
|
}
|
|
update = (i >= PMU_IRQ_TYPE_QTY);
|
|
}
|
|
}
|
|
|
|
if (update) {
|
|
if (hdlr) {
|
|
NVIC_SetVector(PMU_IRQn, (uint32_t)pmu_general_irq_handler);
|
|
NVIC_SetPriority(PMU_IRQn, IRQ_PRIORITY_NORMAL);
|
|
NVIC_ClearPendingIRQ(PMU_IRQn);
|
|
NVIC_EnableIRQ(PMU_IRQn);
|
|
} else {
|
|
NVIC_DisableIRQ(PMU_IRQn);
|
|
}
|
|
}
|
|
|
|
int_unlock(lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
enum PMU_POWER_ON_CAUSE_T pmu_get_power_on_cause(void) {
|
|
enum PMU_POWER_ON_CAUSE_T pmu_power_on_cause = PMU_POWER_ON_CAUSE_NONE;
|
|
|
|
pmu_power_on_cause = pmu_charger_poweron_status();
|
|
if (pmu_power_on_cause == PMU_POWER_ON_CAUSE_NONE) {
|
|
pmu_power_on_cause = PMU_POWER_ON_CAUSE_POWER_KEY;
|
|
}
|
|
|
|
return pmu_power_on_cause;
|
|
}
|
|
|
|
void pmu_viorise_req(enum PMU_VIORISE_REQ_USER_T user, bool rise) {
|
|
uint32_t lock;
|
|
|
|
lock = int_lock();
|
|
if (rise) {
|
|
if (vio_risereq_map == 0) {
|
|
pmu_module_ramp_volt(PMU_IO, vio_lp, vio_act_rise);
|
|
}
|
|
vio_risereq_map |= (1 << user);
|
|
} else {
|
|
vio_risereq_map &= ~(1 << user);
|
|
if (vio_risereq_map == 0) {
|
|
pmu_module_ramp_volt(PMU_IO, vio_lp, vio_act_normal);
|
|
}
|
|
}
|
|
int_unlock(lock);
|
|
}
|
|
|
|
int pmu_debug_config_ana(uint16_t volt) { return 0; }
|
|
|
|
int pmu_debug_config_codec(uint16_t volt) {
|
|
#ifdef ANC_PROD_TEST
|
|
if (volt == 1600 || volt == 1700 || volt == 1800 || volt == 1900 ||
|
|
volt == 1950) {
|
|
vhppa_mv = vcodec_mv = volt;
|
|
vcodec_off = true;
|
|
} else {
|
|
vcodec_off = false;
|
|
return 1;
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int pmu_debug_config_vcrystal(bool on) { return 0; }
|
|
|
|
int pmu_debug_config_audio_output(bool diff) { return 0; }
|
|
|
|
void pmu_debug_reliability_test(int stage) {
|
|
uint16_t volt;
|
|
|
|
if (stage == 0) {
|
|
volt = PMU_DCDC_ANA_1_2V;
|
|
} else {
|
|
volt = PMU_DCDC_ANA_1_3V;
|
|
}
|
|
pmu_dcdc_ana_set_volt(volt, ana_lp_dcdc);
|
|
}
|
|
|
|
void pmu_led_set_hiz(enum HAL_GPIO_PIN_T pin) {
|
|
uint16_t val1, val2;
|
|
uint32_t lock;
|
|
|
|
if (pin == HAL_GPIO_PIN_LED1 || pin == HAL_GPIO_PIN_LED2) {
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_MIC_LDO_EN, &val1);
|
|
pmu_read(PMU_REG_LED_CFG, &val2);
|
|
if (pin == HAL_GPIO_PIN_LED1) {
|
|
val1 &= ~REG_LED_IO1_RX_EN;
|
|
val2 = (val2 | REG_LED_IO1_PU | REG_LED_IO1_OENB) &
|
|
~(REG_LED_IO1_PUEN | REG_LED_IO1_PDEN);
|
|
} else {
|
|
val1 &= ~REG_LED_IO2_RX_EN;
|
|
val2 = (val2 | REG_LED_IO2_PU | REG_LED_IO2_OENB) &
|
|
~(REG_LED_IO2_PUEN | REG_LED_IO2_PDEN);
|
|
}
|
|
pmu_write(PMU_REG_MIC_LDO_EN, val1);
|
|
pmu_write(PMU_REG_LED_CFG, val2);
|
|
int_unlock(lock);
|
|
}
|
|
}
|
|
|
|
void pmu_led_set_direction(enum HAL_GPIO_PIN_T pin, enum HAL_GPIO_DIR_T dir) {
|
|
uint16_t val;
|
|
uint16_t val_rx;
|
|
uint32_t lock;
|
|
|
|
if (pin == HAL_GPIO_PIN_LED1 || pin == HAL_GPIO_PIN_LED2) {
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_LED_CFG, &val);
|
|
pmu_read(PMU_REG_MIC_LDO_EN, &val_rx);
|
|
if (pin == HAL_GPIO_PIN_LED1) {
|
|
val |= REG_LED_IO1_PU;
|
|
if (dir == HAL_GPIO_DIR_IN) {
|
|
val |= REG_LED_IO1_OENB;
|
|
val_rx |= REG_LED_IO1_RX_EN;
|
|
} else {
|
|
val &= ~REG_LED_IO1_OENB;
|
|
val_rx &= ~REG_LED_IO1_RX_EN;
|
|
}
|
|
} else {
|
|
val |= REG_LED_IO2_PU;
|
|
if (dir == HAL_GPIO_DIR_IN) {
|
|
val |= REG_LED_IO2_OENB;
|
|
val_rx |= REG_LED_IO2_RX_EN;
|
|
} else {
|
|
val &= ~REG_LED_IO2_OENB;
|
|
val_rx &= ~REG_LED_IO2_RX_EN;
|
|
}
|
|
}
|
|
pmu_write(PMU_REG_LED_CFG, val);
|
|
pmu_write(PMU_REG_MIC_LDO_EN, val_rx);
|
|
;
|
|
int_unlock(lock);
|
|
}
|
|
}
|
|
|
|
enum HAL_GPIO_DIR_T pmu_led_get_direction(enum HAL_GPIO_PIN_T pin) {
|
|
uint16_t val;
|
|
|
|
if (pin == HAL_GPIO_PIN_LED1 || pin == HAL_GPIO_PIN_LED2) {
|
|
pmu_read(PMU_REG_LED_CFG, &val);
|
|
if (pin == HAL_GPIO_PIN_LED1) {
|
|
return (val & REG_LED_IO1_OENB) ? HAL_GPIO_DIR_IN : HAL_GPIO_DIR_OUT;
|
|
} else {
|
|
return (val & REG_LED_IO2_OENB) ? HAL_GPIO_DIR_IN : HAL_GPIO_DIR_OUT;
|
|
}
|
|
} else {
|
|
return HAL_GPIO_DIR_IN;
|
|
}
|
|
}
|
|
|
|
void pmu_led_set_voltage_domains(enum HAL_IOMUX_PIN_T pin,
|
|
enum HAL_IOMUX_PIN_VOLTAGE_DOMAINS_T volt) {
|
|
enum PMU_LED_VOLT_T {
|
|
PMU_LED_VOLT_VBAT,
|
|
PMU_LED_VOLT_VMEM,
|
|
PMU_LED_VOLT_VIO,
|
|
};
|
|
enum PMU_LED_VOLT_T sel;
|
|
uint16_t val;
|
|
uint32_t lock;
|
|
|
|
if (pin == HAL_IOMUX_PIN_LED1 || pin == HAL_IOMUX_PIN_LED2) {
|
|
if (volt == HAL_IOMUX_PIN_VOLTAGE_VIO) {
|
|
sel = PMU_LED_VOLT_VIO;
|
|
} else if (volt == HAL_IOMUX_PIN_VOLTAGE_MEM) {
|
|
sel = PMU_LED_VOLT_VMEM;
|
|
} else {
|
|
sel = PMU_LED_VOLT_VBAT;
|
|
}
|
|
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_LED_CFG, &val);
|
|
if (pin == HAL_IOMUX_PIN_LED1) {
|
|
val = SET_BITFIELD(val, REG_LED_IO1_SEL, sel);
|
|
} else {
|
|
val = SET_BITFIELD(val, REG_LED_IO2_SEL, sel);
|
|
}
|
|
pmu_write(PMU_REG_LED_CFG, val);
|
|
int_unlock(lock);
|
|
}
|
|
}
|
|
|
|
void pmu_led_set_pull_select(enum HAL_IOMUX_PIN_T pin,
|
|
enum HAL_IOMUX_PIN_PULL_SELECT_T pull_sel) {
|
|
uint16_t val;
|
|
uint32_t lock;
|
|
|
|
if (pin == HAL_IOMUX_PIN_LED1 || pin == HAL_IOMUX_PIN_LED2) {
|
|
lock = int_lock();
|
|
pmu_read(PMU_REG_LED_CFG, &val);
|
|
if (pin == HAL_IOMUX_PIN_LED1) {
|
|
val &= ~(REG_LED_IO1_PDEN | REG_LED_IO1_PUEN);
|
|
if (pull_sel == HAL_IOMUX_PIN_PULLUP_ENABLE) {
|
|
val |= REG_LED_IO1_PUEN;
|
|
} else if (pull_sel == HAL_IOMUX_PIN_PULLDOWN_ENABLE) {
|
|
val |= REG_LED_IO1_PDEN;
|
|
}
|
|
} else {
|
|
val &= ~(REG_LED_IO2_PDEN | REG_LED_IO2_PUEN);
|
|
if (pull_sel == HAL_IOMUX_PIN_PULLUP_ENABLE) {
|
|
val |= REG_LED_IO2_PUEN;
|
|
} else if (pull_sel == HAL_IOMUX_PIN_PULLDOWN_ENABLE) {
|
|
val |= REG_LED_IO2_PDEN;
|
|
}
|
|
}
|
|
pmu_write(PMU_REG_LED_CFG, val);
|
|
int_unlock(lock);
|
|
}
|
|
}
|
|
|
|
void pmu_led_set_value(enum HAL_GPIO_PIN_T pin, int data) {
|
|
uint16_t val;
|
|
uint32_t lock;
|
|
#ifdef PMU_LED_VIA_PWM
|
|
uint16_t br_val;
|
|
#endif
|
|
if (pin == HAL_GPIO_PIN_LED1 || pin == HAL_GPIO_PIN_LED2) {
|
|
lock = int_lock();
|
|
#ifdef PMU_LED_VIA_PWM
|
|
pmu_read(PMU_REG_PWM_BR_EN, &br_val);
|
|
#endif
|
|
pmu_read(PMU_REG_PWM_EN, &val);
|
|
if (pin == HAL_GPIO_PIN_LED1) {
|
|
#ifdef PMU_LED_VIA_PWM
|
|
pmu_write(PMU_REG_PWM2_TOGGLE, 0xFFFF);
|
|
br_val &= ~REG_PWM2_BR_EN;
|
|
val |= PWM_SELECT_EN(1 << 0);
|
|
if (data) {
|
|
val &= ~PWM_SELECT_INV(1 << 0);
|
|
} else {
|
|
val |= PWM_SELECT_INV(1 << 0);
|
|
}
|
|
#else
|
|
if (data) {
|
|
val |= REG_LED0_OUT;
|
|
} else {
|
|
val &= ~REG_LED0_OUT;
|
|
}
|
|
#endif
|
|
} else {
|
|
#ifdef PMU_LED_VIA_PWM
|
|
pmu_write(PMU_REG_PWM3_TOGGLE, 0xFFFF);
|
|
br_val &= ~REG_PWM3_BR_EN;
|
|
val |= PWM_SELECT_EN(1 << 1);
|
|
if (data) {
|
|
val &= ~PWM_SELECT_INV(1 << 1);
|
|
} else {
|
|
val |= PWM_SELECT_INV(1 << 1);
|
|
}
|
|
#else
|
|
if (data) {
|
|
val |= REG_LED1_OUT;
|
|
} else {
|
|
val &= ~REG_LED1_OUT;
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef PMU_LED_VIA_PWM
|
|
pmu_write(PMU_REG_PWM_BR_EN, br_val);
|
|
#endif
|
|
pmu_write(PMU_REG_PWM_EN, val);
|
|
int_unlock(lock);
|
|
}
|
|
}
|
|
|
|
int pmu_led_get_value(enum HAL_GPIO_PIN_T pin) {
|
|
uint16_t val;
|
|
int data = 0;
|
|
|
|
if (pin == HAL_GPIO_PIN_LED1 || pin == HAL_GPIO_PIN_LED2) {
|
|
pmu_read(PMU_REG_POWER_OFF, &val);
|
|
if (pin == HAL_GPIO_PIN_LED1) {
|
|
data = REG_LED_IO1_DATA_IN;
|
|
} else {
|
|
data = REG_LED_IO2_DATA_IN;
|
|
}
|
|
data &= val;
|
|
}
|
|
|
|
return !!data;
|
|
}
|
|
|
|
struct PMU_WDT_CTX_T {
|
|
bool enabled;
|
|
uint16_t wdt_timer;
|
|
uint16_t wdt_cfg;
|
|
};
|
|
|
|
static struct PMU_WDT_CTX_T BOOT_BSS_LOC wdt_ctx;
|
|
|
|
void BOOT_TEXT_SRAM_LOC pmu_wdt_save_context(void) {
|
|
uint16_t wdt_cfg = 0, wdt_timer = 0;
|
|
pmu_read(PMU_REG_WDT_CFG, &wdt_cfg);
|
|
if (wdt_cfg & (REG_WDT_RESET_EN | REG_WDT_EN)) {
|
|
wdt_ctx.enabled = true;
|
|
wdt_ctx.wdt_cfg = wdt_cfg;
|
|
pmu_read(PMU_REG_WDT_TIMER, &wdt_timer);
|
|
wdt_ctx.wdt_timer = wdt_timer;
|
|
}
|
|
}
|
|
|
|
void BOOT_TEXT_SRAM_LOC pmu_wdt_restore_context(void) {
|
|
if (wdt_ctx.enabled) {
|
|
pmu_write(PMU_REG_WDT_TIMER, wdt_ctx.wdt_timer);
|
|
pmu_write(PMU_REG_WDT_CFG, wdt_ctx.wdt_cfg);
|
|
}
|
|
}
|
|
|
|
void pmu_wdt_set_irq_handler(PMU_WDT_IRQ_HANDLER_T handler) {}
|
|
|
|
int pmu_wdt_config(uint32_t irq_ms, uint32_t reset_ms) {
|
|
// No wdt irq on best2300
|
|
if (irq_ms + reset_ms > 0xFFFF) {
|
|
return 1;
|
|
}
|
|
wdt_timer = irq_ms + reset_ms;
|
|
|
|
pmu_write(PMU_REG_WDT_TIMER, wdt_timer);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void pmu_wdt_start(void) {
|
|
uint16_t val;
|
|
|
|
if (wdt_timer == 0) {
|
|
return;
|
|
}
|
|
|
|
pmu_read(PMU_REG_WDT_CFG, &val);
|
|
val |= (REG_WDT_RESET_EN | REG_WDT_EN);
|
|
pmu_write(PMU_REG_WDT_CFG, val);
|
|
}
|
|
|
|
void pmu_wdt_stop(void) {
|
|
uint16_t val;
|
|
|
|
if (wdt_timer == 0) {
|
|
return;
|
|
}
|
|
|
|
pmu_read(PMU_REG_WDT_CFG, &val);
|
|
val &= ~(REG_WDT_RESET_EN | REG_WDT_EN);
|
|
pmu_write(PMU_REG_WDT_CFG, val);
|
|
}
|
|
|
|
void pmu_wdt_feed(void) {
|
|
if (wdt_timer == 0) {
|
|
return;
|
|
}
|
|
|
|
pmu_write(PMU_REG_WDT_TIMER, wdt_timer);
|
|
}
|
|
|
|
void pmu_ntc_capture_enable(void) {}
|
|
|
|
void pmu_ntc_capture_disable(void) {}
|