cdnutter/iBoot
Archived
1
0 Fork 0
Code Issues Packages Projects Releases Wiki Activity

first and last commit

Browse Source
This commit is contained in:
Chris Nutter committed 2023-07-08 13:03:17 -07:00
commit 1bf4efd552
2612 files changed
+636500
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

drivers/dialog/pmu/NTCTables.h
+92
View File
@@ -0,0 +1,92 @@
/*
* NTCTables.h
* AppleDialogPMU
*
* Created by Heiko Panther on 4/13/09.
* Copyright 2009 Apple Computer, Inc.. All rights reserved.
*
*/
struct NTCLUT {
uint32_t ohm;
int32_t centiCelsius;
};
// ERTJZEG103JA is the thermistor on the N18 MLB.
static const struct NTCLUT ERTJZEG103JA[] = {
{ 205200, -4000 },
{ 154800, -3500 },
{ 117900, -3000 },
{ 90690, -2500 },
{ 70370, -2000 },
{ 55070, -1500 },
{ 43440, -1000 },
{ 34530, -500 },
{ 27640, 0 },
{ 22270, 500 },
{ 18060, 1000 },
{ 14740, 1500 },
{ 12110, 2000 },
{ 10000, 2500 },
{ 8309, 3000 },
{ 6941, 3500 },
{ 5828, 4000 },
{ 4916, 4500 },
{ 4165, 5000 },
{ 3543, 5500 },
{ 3027, 6000 },
{ 2595, 6500 },
{ 2233, 7000 },
{ 1929, 7500 },
{ 1672, 8000 },
{ 1451, 8500 },
{ 1261, 9000 },
{ 1097, 9500 },
{ 956, 10000 },
{ 836, 10500 },
{ 732, 11000 },
{ 642, 11500 },
{ 565, 12000 },
{ 494, 12500 },
{ 0, 0} };
// TDK NTCG103JF103F is the thermistor in the N18 battery pack.
// This table is also used for the Murata NCP03XH103F05RL since its B
// is comparable at B=3380 and B=3435 at 50/85°C
// The Murata part is used on board and battery of N90.
static const struct NTCLUT NTCG103JF103F[] = {
{ 188500, -4000 },
{ 144290, -3500 },
{ 111330, -3000 },
{ 86560, -2500 },
{ 67790, -2000 },
{ 53460, -1500 },
{ 42450, -1000 },
{ 33930, -500 },
{ 27280, 0 },
{ 22070, 500 },
{ 17960, 1000 },
{ 14700, 1500 },
{ 12090, 2000 },
{ 10000, 2500 },
{ 8310, 3000 },
{ 6940, 3500 },
{ 5830, 4000 },
{ 4910, 4500 },
{ 4160, 5000 },
{ 3540, 5500 },
{ 3020, 6000 },
{ 2590, 6500 },
{ 2230, 7000 },
{ 1920, 7500 },
{ 1670, 8000 },
{ 1450, 8500 },
{ 1270, 9000 },
{ 1110, 9500 },
{ 980, 10000 },
{ 860, 10500 },
{ 760, 11000 },
{ 670, 11500 },
{ 600, 12000 },
{ 530, 12500 },
{ 0, 0 } };
drivers/dialog/pmu/charger.c
+1229
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d1755.h
+563
View File
@@ -0,0 +1,563 @@
#define PMU_HAS_SWI 1
#define PMU_HAS_DWI 0
#define PMU_HAS_LCM_LDO 0
#define PMU_HAS_WLED 1
#define PMU_HAS_REG_BANK 0
enum {
kDIALOG_ADDR_R = 0xe8,
kDIALOG_ADDR_W = 0xe9,
kDIALOG_REG_BYTES = 1,
};
enum {
kDIALOG_EVENT_COUNT = 4,
kDIALOG_STATUS_COUNT = 4,
kDIALOG_HIBERNATE_COUNT = 1,
kDIALOG_CHIPID_COUNT = 1,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_GPIO_COUNT = 8,
kDIALOG_GPIO_DEB_REG_COUNT = 3
};
#include "dCommon.h"
enum {
kDIALOG_CHIP_ID = 0x00,
kDIALOG_EVENT_A = 0x01,
kDIALOG_EVENT_B = 0x02,
kDIALOG_EVENT_C = 0x03,
kDIALOG_EVENT_D = 0x04,
kDIALOG_STATUS_A = 0x05,
kDIALOG_STATUS_B = 0x06,
kDIALOG_STATUS_C = 0x07,
kDIALOG_STATUS_D = 0x08,
kDIALOG_IRQ_MASK_A = 0x09,
kDIALOG_IRQ_MASK_B = 0x0a,
kDIALOG_IRQ_MASK_C = 0x0b,
kDIALOG_IRQ_MASK_D = 0x0c,
kDIALOG_SYS_CONTROL = 0x0d,
kDIALOG_FAULT_LOG = 0x0e,
kD1755_ACTIVE1 = 0x10,
kD1755_ACTIVE2 = 0x11,
kD1755_STANDBY1 = 0x12,
kDIALOG_STANDBY = kD1755_STANDBY1,
kD1755_HIBERNATE1 = 0x13,
kD1755_BUCK1 = 0x14,
kDIALOG_BUCK1 = kD1755_BUCK1,
kD1755_BUCK2 = 0x15,
kD1755_SPECIAL = 0x16,
kD1755_LDO1 = 0x17,
kD1755_LDO2 = 0x18,
kD1755_LDO3 = 0x19,
kD1755_LDO4 = 0x1a,
kD1755_LDO5 = 0x1b,
kD1755_LDO6 = 0x1c,
kD1755_LDO7 = 0x1d,
kD1755_LDO8 = 0x1e,
kD1755_LDO9 = 0x1f,
kD1755_LDO10 = 0x20,
kD1755_LDO11 = 0x21,
kDIALOG_LDO_CONTROL = 0x22,
kDIALOG_BUCK_CONTROL = 0x23,
kD1755_BUCK_CONTROL2 = 0x24,
kDIALOG_BUCK_CONTROL2 = kD1755_BUCK_CONTROL2,
kDIALOG_WLED_ISET = 0x25,
kDIALOG_WLED_CONTROL = 0x26,
kDIALOG_WLED_OPTIONS = kDIALOG_WLED_CONTROL,
kDIALOG_CHARGE_BUCK_CONTROL = 0x27,
kD1755_CHARGE_CONTROL_A = 0x28,
kD1755_CHARGE_CONTROL_B = 0x29,
kD1755_CHARGE_TIME = 0x2a,
kDIALOG_CHARGE_CONTROL_ICHG_BAT = kD1755_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_TIME = kD1755_CHARGE_CONTROL_B,
kD1755_BUCK1_PRE1 = 0x2c,
kDIALOG_BUCK1_PRE1 = kD1755_BUCK1_PRE1,
kD1755_BUCK1_PRE2 = 0x2d,
kD1755_BUCK1_PRE3 = 0x2e,
kD1755_BUCK1_SEL = 0x2f,
kDIALOG_BUCK1_SEL = kD1755_BUCK1_SEL,
kD1755_SYS_GPIO_1 = 0x50,
kDIALOG_SYS_GPIO_REG_START = kD1755_SYS_GPIO_1,
kD1755_SYS_GPIO_2 = 0x51,
kD1755_SYS_GPIO_3 = 0x52,
kD1755_SYS_GPIO_4 = 0x53,
kD1755_SYS_GPIO_5 = 0x54,
kD1755_SYS_GPIO_6 = 0x55,
kD1755_SYS_GPIO_7 = 0x56,
kD1755_SYS_GPIO_8 = 0x57,
kD1755_GPIO_DEB1 = 0x59,
kDIALOG_SYS_GPIO_DEB_REG_START = kD1755_GPIO_DEB1,
kD1755_GPIO_DEB2 = 0x5a,
kD1755_GPIO_DEB3 = 0x5b,
kD1755_BUTTON1 = 0x5c,
kD1755_BUTTON2 = 0x5d,
kD1755_BUTTON3 = 0x5e,
kDIALOG_SYS_CONFIG = 0x5f,
kDIALOG_ADC_CONTROL = 0x30,
kDIALOG_ADC_LSB = 0x31,
kDIALOG_ADC_MSB = 0x32,
kDIALOG_ICHG_AVG = 0x35,
kDIALOG_RTC_COUNT_A = 0x40,
kDIALOG_RTC_COUNT_B = 0x41,
kDIALOG_RTC_COUNT_C = 0x42,
kDIALOG_RTC_COUNT_D = 0x43,
kDIALOG_RTC_COUNT_E = 0x44,
kDIALOG_RTC_COUNT_F = 0x45,
kDIALOG_RTC_ALARM_A = 0x46,
kDIALOG_RTC_ALARM_B = 0x47,
kDIALOG_RTC_ALARM_C = 0x48,
kDIALOG_RTC_ALARM_D = 0x49,
kDIALOG_RTC_ALARM_E = 0x4a,
kDIALOG_RTC_TIMEZONE = 0x4b,
kDIALOG_UPCOUNT_A = 0x4c,
kDIALOG_UPCOUNT_B = 0x4d,
kDIALOG_UPCOUNT_C = 0x4e,
kDIALOG_UPCOUNT_D = 0x4f,
kDIALOG_MEMBYTE0 = 0x60,
kDIALOG_MEMBYTE_LAST = 0x87,
kD1755_OTP_ISET_USB = 0xa5,
kDIALOG_OTP_ISET_BAT = 0xac,
kD1755_OTP_USB_900_LIMIT = 0xbf,
kD1755_OTP_USB_500_LIMIT = 0xc0,
kD1755_TEST_MODE = 0xe0,
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0xf << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0x0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = (0x1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (0x2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ACC_ID = (0x3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BRICK_ID = (0x6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN7 = (0x7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (0xb << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_IN = (0xe << 0),
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 4),
kDIALOG_ADC_CONTROL_ADC_REF_EN = (1 << 5),
kDIALOG_ADC_CONTROL_AUTO_VDD_OUT_EN = (1 << 6),
kDIALOG_ADC_CONTROL_TBAT_ISRC_EN = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = kDIALOG_ADC_CONTROL_TBAT_ISRC_EN,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 10,
kDIALOG_ADC_FULL_SCALE_MV = 2500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kD1755_ACTIVE1_SPECIAL = (1 << 2),
kD1755_SPECIAL_HIB_CHG = (1 << 2),
};
enum {
kD1755_CHIP_ID_MRC_MASK = (15 << 0),
kD1755_CHIP_ID_MRC_AA = (0 << 0),
kD1755_CHIP_ID_MRC_AB = (1 << 0),
kD1755_CHIP_ID_MRC_AC = (2 << 0),
kD1755_CHIP_ID_MRC_AD = (3 << 0),
kD1755_CHIP_ID_MRC_AE = (4 << 0),
kD1755_CHIP_ID_PROG = (1 << 4),
kD1755_CHIP_ID_PID_MASK = (7 << 5),
};
enum {
kD1755_EVENT_A_BUTTON1 = (1 << 0),
kD1755_EVENT_A_BUTTON2 = (1 << 1),
kD1755_EVENT_A_BUTTON3 = (1 << 2),
kD1755_EVENT_A_VBUS_DET = (1 << 3),
kD1755_EVENT_A_VHP_DET = (1 << 4),
kD1755_EVENT_A_ACC_DET = (1 << 5),
kD1755_EVENT_A_VBUS_EXT = (1 << 6),
kD1755_EVENT_A_VDD_LOW = (1 << 7),
};
// EVENT_B events are assumed volatile (lost over sleep/wake)
enum {
kD1755_EVENT_B_SWI = (1 << 0),
kD1755_EVENT_B_CHG_PRE = (1 << 1),
kD1755_EVENT_B_CHG_FAST = (1 << 2),
kD1755_EVENT_B_CHG_END = (1 << 3),
kD1755_EVENT_B_TBAT = (1 << 4),
kD1755_EVENT_B_EOMC = (1 << 5),
kD1755_EVENT_B_FW_OV = (1 << 6),
kDIALOG_EVENT_B_HIB = (1 << 7),
};
enum {
kD1755_EVENT_C_GPIO1 = (1 << 0),
kD1755_EVENT_C_GPIO2 = (1 << 1),
kD1755_EVENT_C_GPIO3 = (1 << 2),
kD1755_EVENT_C_GPIO4 = (1 << 3),
kD1755_EVENT_C_GPIO5 = (1 << 4),
kD1755_EVENT_C_GPIO6 = (1 << 5),
kD1755_EVENT_C_GPIO7 = (1 << 6),
kD1755_EVENT_C_GPIO8 = (1 << 7),
};
enum {
kD1755_EVENT_D_ALARM = (1 << 0),
kD1755_EVENT_D_VHP_REM = (1 << 4),
kD1755_EVENT_D_VBUS_REM = (1 << 6),
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 3,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_110 = 4,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_120 = 5,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_350 = 6,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_400 = 7,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_450 = 8,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 9,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_550 = 10,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_600 = 11,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_700 = 12,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_900 = 13,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1100 = 12,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1300 = 15,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 15,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_VBUS_CHG_BUCK_EN = (1 << 7),
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3f,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 20,
kDIALOG_CHARGE_CONTROL_MAX = 1260,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0x78,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kD1755_TEST_MODE_TEST_EN = (1 << 0),
kD1755_TEST_MODE_RESET_PMU = (1 << 1),
kDIALOG_OTP_ISET_BAT_SHIFT = 0,
};
enum {
kDIALOG_SYS_CONTROL_STANDBY = (1 << 0),
kDIALOG_SYS_CONTROL_HIBERNATE = (1 << 1),
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_SWI_EN = (1 << 4),
kD1755_SYS_CONTROL_PRO_FET_DIS = (1 << 5),
kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND = (1 << 6),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND
| kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = kDIALOG_SYS_CONTROL_HIBERNATE
| kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND | kD1755_SYS_CONTROL_PRO_FET_DIS,
};
enum {
kDIALOG_FAULT_LOG_WDOG = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 4)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_BOOST = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_RESET_IN_1 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
};
enum {
kD1755_STATUS_A_BUTTON1 = (1 << 0),
kD1755_STATUS_A_BUTTON2 = (1 << 1),
kD1755_STATUS_A_BUTTON3 = (1 << 2),
kD1755_STATUS_A_VBUS_DET = (1 << 3),
kD1755_STATUS_A_VHP_DET = (1 << 4),
kD1755_STATUS_A_ACC_DET = (1 << 5),
kD1755_STATUS_A_VBUS_EXT = (1 << 6),
kD1755_STATUS_A_VDD_LOW = (1 << 7),
};
enum {
kD1755_STATUS_B_CHG_ATT = (1 << 0),
kD1755_STATUS_B_CHG_PRE = (1 << 1),
kD1755_STATUS_B_CHG_FAST = (1 << 2),
kD1755_STATUS_B_CHG_END = (1 << 3),
kD1755_STATUS_B_TBAT = (1 << 4),
kD1755_STATUS_B_CHG_TO = (1 << 5),
kD1755_STATUS_B_FW_OV = (1 << 6),
};
enum {
kD1755_STATUS_C_GPIO1 = (1 << 0),
kD1755_STATUS_C_GPIO2 = (1 << 1),
kD1755_STATUS_C_GPIO3 = (1 << 2),
kD1755_STATUS_C_GPIO4 = (1 << 3),
kD1755_STATUS_C_GPIO5 = (1 << 4),
kD1755_STATUS_C_GPIO6 = (1 << 5),
kD1755_STATUS_C_GPIO7 = (1 << 6),
kD1755_STATUS_C_GPIO8 = (1 << 7),
};
enum {
kD1755_EVENT_C_GPIO_FW_DETECT = kD1755_EVENT_C_GPIO7
};
enum {
kD1755_EVENT_A_WAKEMASK = kD1755_EVENT_A_BUTTON1
| kD1755_EVENT_A_BUTTON2
| kD1755_EVENT_A_BUTTON3
| kD1755_EVENT_A_VBUS_DET
| kD1755_EVENT_A_VHP_DET
| kD1755_EVENT_A_ACC_DET,
kD1755_EVENT_B_WAKEMASK = 0,
kD1755_EVENT_C_WAKEMASK = kD1755_EVENT_C_GPIO_FW_DETECT,
kD1755_EVENT_D_WAKEMASK = kD1755_EVENT_D_ALARM
| kD1755_EVENT_D_VHP_REM
| kD1755_EVENT_D_VBUS_REM,
};
enum {
kDIALOG_EVENT_HOLD_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1755_EVENT_A_BUTTON2),
kDIALOG_EVENT_MENU_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1755_EVENT_A_BUTTON1),
kDIALOG_EVENT_RINGER_BUTTON_MASK= EVENT_FLAG_MAKE(0, kD1755_EVENT_A_BUTTON3),
kDIALOG_EVENT_A_BUTTONS = (kD1755_EVENT_A_BUTTON2 |
kD1755_EVENT_A_BUTTON1 |
kD1755_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS_MASK = EVENT_FLAG_MAKE(0, kDIALOG_EVENT_A_BUTTONS),
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_EVENT_HOLD_BUTTON_MASK,
kDIALOG_EVENT_ALARM_MASK = EVENT_FLAG_MAKE(3, kD1755_EVENT_D_ALARM),
kDIALOG_EVENT_ACC_DET_MASK = EVENT_FLAG_MAKE(0, kD1755_EVENT_A_ACC_DET),
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD1755_EVENT_A_VBUS_DET),
kDIALOG_EVENT_VHP_DET_MASK = EVENT_FLAG_MAKE(0, kD1755_EVENT_A_VHP_DET),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(1, kD1755_EVENT_B_EOMC),
kDIALOG_EVENT_HIB_MASK = EVENT_FLAG_MAKE(1, kDIALOG_EVENT_B_HIB),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(1, kD1755_EVENT_B_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(1, kD1755_EVENT_B_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(2, kD1755_EVENT_C_GPIO8),
kD1755_EVENT_D_VBUS_REM_MASK = EVENT_FLAG_MAKE(3, kD1755_EVENT_D_VBUS_REM),
/*
kDIALOG_EVENT_WAKE_MASK = ((kD1755_EVENT_A_WAKEMASK << 0)
| (kD1755_EVENT_B_WAKEMASK << 8)
| (kD1755_EVENT_C_WAKEMASK << 16)
| (kD1755_EVENT_D_WAKEMASK << 24)),
kDIALOG_EVENT_PWRSUPPLY_MASK
= (((kD1755_EVENT_A_VBUS_DET | kD1755_EVENT_A_VHP_DET) << 0)
| (kD1755_EVENT_C_GPIO_FW_DETECT << 16)
| ((kD1755_EVENT_D_VHP_REM | kD1755_EVENT_D_VBUS_REM) << 24)),
*/
// not on D1755
kDIALOG_EVENT_ON_MASK = 0,
kDIALOG_EVENT_LDO2_EN_MASK = 0,
kDIALOG_EVENT_GPIO9_MASK = 0,
kDIALOG_EVENT_GPIO10_MASK = 0,
kDIALOG_EVENT_GPIO11_MASK = 0,
kDIALOG_EVENT_GPIO12_MASK = 0,
kDIALOG_EVENT_GPIO13_MASK = 0,
kDIALOG_EVENT_GPIO14_MASK = 0,
kDIALOG_EVENT_GPIO15_MASK = 0,
kDIALOG_EVENT_GPIO16_MASK = 0,
kDIALOG_EVENT_GPIO17_MASK = 0,
kDIALOG_EVENT_GPIO18_MASK = 0,
kDIALOG_EVENT_HOLD_DBL_MASK = 0,
kDIALOG_EVENT_MENU_DBL_MASK = 0,
kDIALOG_EVENT_RINGER_DBL_MASK = 0,
};
#define kDIALOG_EVENT_GPIOn_MASK(n) EVENT_FLAG_MAKE(2, (1 << (n)))
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static static const eventRegisters kDialogEventIntMasks = {
~kD1755_EVENT_A_WAKEMASK,
~kD1755_EVENT_B_WAKEMASK,
~kD1755_EVENT_C_WAKEMASK,
~kD1755_EVENT_D_WAKEMASK
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD1755_EVENT_A_WAKEMASK & ~kDIALOG_EVENT_A_BUTTONS,
kD1755_EVENT_B_WAKEMASK,
kD1755_EVENT_C_WAKEMASK,
kD1755_EVENT_D_WAKEMASK
};
// All events that do defer shutdown
static const eventRegisters kDialogEventRestartMask = {
kDIALOG_EVENT_HOLD_BUTTON_MASK | kDIALOG_EVENT_ACC_DET_MASK,
0,
0,
kD1755_EVENT_D_ALARM
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD1755_EVENT_A_VBUS_DET | kD1755_EVENT_A_VHP_DET,
0,
kD1755_EVENT_C_GPIO_FW_DETECT,
kD1755_EVENT_D_VHP_REM | kD1755_EVENT_D_VBUS_REM
};
static const eventRegisters kDialogEventUSBMask = {
kD1755_EVENT_A_VBUS_DET,
0,
0,
kD1755_EVENT_D_VBUS_REM
};
static const eventRegisters kDialogEventFWMask = {
kD1755_EVENT_A_VHP_DET,
0,
kD1755_EVENT_C_GPIO_FW_DETECT,
kD1755_EVENT_D_VHP_REM
};
enum {
kDialogEventPwrsupplyCount = 5,
kDialogEventUSBCount = 2,
kDialogEventFWCount = 3,
};
enum {
kDIALOG_SYS_CONFIG_RESET_TIMER_MASK = (3 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_4S = (0 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_6S = (1 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_8S = (2 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_10S = (3 << 3),
kDIALOG_SYS_CONFIG_WDOG_MODE_100MS = (0 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_250MS = (1 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_500MS = (2 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_1000MS = (3 << 1),
kDIALOG_SYS_CONFIG_WDOG_EN = (1 << 0),
kDIALOG_SYS_CONFIG_WDOG_ACTIVE = 0,
};
enum {
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD1755_STATUS_A_VBUS_DET),
kDIALOG_STATUS_ACC_DET_MASK = STATUS_FLAG_MAKE(0, kD1755_STATUS_A_ACC_DET),
// kDIALOG_STATUS_FW_MASK = ((kD1755_STATUS_A_VHP_DET << 0) | (kD1755_EVENT_C_GPIO_FW_DETECT << 16)),
// kDIALOG_STATUS_CHARGING_MASK = ((kD1755_STATUS_B_CHG_PRE | kD1755_STATUS_B_CHG_FAST) << 8),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(1, kD1755_STATUS_B_CHG_TO),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD1755_STATUS_B_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(1, kD1755_STATUS_B_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(1, kD1755_STATUS_B_CHG_ATT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(2, (1 << (gpio)))
kDIALOG_STATUS_HOLD_BUTTON_MASK = STATUS_FLAG_MAKE(0, kD1755_STATUS_A_BUTTON2),
kDIALOG_STATUS_MENU_BUTTON_MASK = STATUS_FLAG_MAKE(0, kD1755_STATUS_A_BUTTON1),
kDIALOG_STATUS_RINGER_BUTTON_MASK = STATUS_FLAG_MAKE(0, kD1755_STATUS_A_BUTTON3),
};
static const statusRegisters kDialogStatusFWMask = {kD1755_STATUS_A_VHP_DET, 0, kD1755_EVENT_C_GPIO_FW_DETECT, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD1755_STATUS_B_CHG_PRE | kD1755_STATUS_B_CHG_FAST, 0, 0};
enum {
kDIALOG_SYS_GPIO_DIRECTION_MASK = (7 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (0 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (1 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (2 << 5),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_OUTPUT_32KHZ = (1 << 2),
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_MASK) \
== kDIALOG_SYS_GPIO_DIRECTION_OUT)
enum {
kDIALOG_WLED_CONTROL_WLED_ENABLE1 = (1 << 0),
kDIALOG_WLED_CONTROL_WLED_ENABLE2 = (1 << 1),
kDIALOG_WLED_CONTROL_WLED_RAMP_EN = (1 << 2),
kDIALOG_WLED_CONTROL_WLED_SWI_EN = (1 << 3),
kDIALOG_WLED_CONTROL_BOOST_FREQ = (1 << 4),
kDIALOG_WLED_CONTROL_BOOST_ILIMIT_710 = (0 << 5),
kDIALOG_WLED_CONTROL_BOOST_ILIMIT_1000 = (1 << 5),
kDIALOG_WLED_OPTIONS_DEFAULT = kDIALOG_WLED_CONTROL_BOOST_ILIMIT_710,
kDIALOG_WLED_OPTIONS_xWI_EN = kDIALOG_WLED_CONTROL_WLED_SWI_EN,
kDIALOG_WLED_OPTIONS_MASK = (kDIALOG_WLED_CONTROL_WLED_RAMP_EN|
kDIALOG_WLED_CONTROL_BOOST_FREQ|
kDIALOG_WLED_CONTROL_BOOST_ILIMIT_1000),
};
enum {
kDIALOG_RTC_COUNT_A_SEC_MASK = (0x3f),
kDIALOG_RTC_COUNT_A_MONITOR = (1 << 6),
};
enum {
kDIALOG_RTC_ALARM_E_YEAR_MASK = (0x3f),
kDIALOG_RTC_ALARM_E_ALARM_ON = (1 << 6)
};
enum {
kDIALOG_BUCK_CONTROL_BUCK1_GO = (1 << 6),
kDIALOG_BUCK_CONTROL_BUCK1_SWI_EN = (1 << 7)
};
enum {
kDIALOG_BUCK_CONTROL2_HIB_CLK = (1 << 7),
};
#define NUM_LDOS 12
static const struct ldo_params ldo_1755[NUM_LDOS] = {
{ 2500, 50, 0x15, 0x1f, 0x1, kD1755_LDO1, kD1755_ACTIVE1, 0x08 }, // LDO1
{ 1500, 50, 0x24, 0x3f, 0x0, kD1755_LDO2, kD1755_ACTIVE1, 0x10 }, // LDO2
{ 2500, 50, 0x10, 0x1f, 0x0, kD1755_LDO3, kD1755_ACTIVE1, 0x20 }, // LDO3
{ 1800, 50, 0x1e, 0x1f, 0x0, kD1755_LDO4, kD1755_ACTIVE1, 0x40 }, // LDO4
{ 2500, 50, 0x16, 0x1f, 0x2, kD1755_LDO5, kD1755_ACTIVE1, 0x80 }, // LDO5
{ 2500, 50, 0x16, 0x1f, 0x4, kD1755_LDO6, kD1755_ACTIVE2, 0x01 }, // LDO6
{ 1500, 100,0x1f, 0x1f, 0x0, kD1755_LDO7, kD1755_ACTIVE2, 0x02 }, // LDO7
{ 2000, 50, 0x1f, 0x1f, 0x0, kD1755_LDO8, kD1755_ACTIVE2, 0x04 }, // LDO8
{ 1200, 25, 0x0c, 0x0f, 0x0, kD1755_LDO9, kD1755_ACTIVE2, 0x80 }, // LDO9
{ 1700, 50, 0x1a, 0x1f, 0x0, kD1755_LDO10, kD1755_ACTIVE2, 0x10 }, // LDO10
{ 1700, 50, 0x1a, 0x1f, 0x0, kD1755_LDO11, kD1755_ACTIVE2, 0x20 }, // LDO11
{ 0, 0, 0, 0, 0x0, 0, kD1755_ACTIVE2, 0x40 }, // 12 - WDIG_EN
};
#define LDOP ldo_1755
#define WLED_ISET_BITS (8)
drivers/dialog/pmu/d1815.h
+677
View File
@@ -0,0 +1,677 @@
#define PMU_HAS_SWI 1
#define PMU_HAS_DWI 0
#define PMU_HAS_REG_BANK 0
#define PMU_HAS_LCM_LDO 1
#define PMU_HAS_BIST_ADC 1
#define PMU_HAS_VIB 1
#define PMU_HAS_WLED 1
enum {
kDIALOG_ADDR_R = 0xe8,
kDIALOG_ADDR_W = 0xe9,
kDIALOG_REG_BYTES = 1,
};
enum {
kDIALOG_EVENT_COUNT = 6,
kDIALOG_STATUS_COUNT = 5,
kDIALOG_HIBERNATE_COUNT = 3,
kDIALOG_CHIPID_COUNT = 1,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_GPIO_COUNT = 10,
};
#include "dCommon.h"
enum {
kDIALOG_CHIP_ID = 0x00,
kDIALOG_EVENT_A = 0x01,
kDIALOG_EVENT_B = 0x02,
kDIALOG_EVENT_C = 0x03,
kDIALOG_EVENT_D = 0x04,
kDIALOG_EVENT_E = 0x05,
kDIALOG_EVENT_F = 0x06,
kDIALOG_STATUS_A = 0x07,
kDIALOG_STATUS_B = 0x08,
kDIALOG_STATUS_C = 0x09,
kDIALOG_STATUS_D = 0x0a,
kDIALOG_STATUS_E = 0x0b,
kDIALOG_IRQ_MASK_A = 0x0c,
kDIALOG_IRQ_MASK_B = 0x0d,
kDIALOG_IRQ_MASK_C = 0x0e,
kDIALOG_IRQ_MASK_D = 0x0f,
kDIALOG_IRQ_MASK_E = 0x10,
kDIALOG_IRQ_MASK_F = 0x11,
kDIALOG_SYS_CONTROL = 0x12,
kDIALOG_FAULT_LOG = 0x13,
kD1815_ACTIVE1 = 0x14,
kD1815_ACTIVE2 = 0x15,
kD1815_ACTIVE3 = 0x16,
kDIALOG_LCM_ACTIVE = kD1815_ACTIVE3,
kD1815_STANDBY1 = 0x17,
kDIALOG_STANDBY = kD1815_STANDBY1,
kD1815_HIBERNATE1 = 0x18,
kD1815_HIBERNATE2 = 0x19,
kD1815_HIBERNATE3 = 0x1a,
kD1815_BUCK1 = 0x1b,
kDIALOG_BUCK1 = kD1815_BUCK1,
kD1815_BUCK2 = 0x1c,
kD1815_LDO1 = 0x1d,
kD1815_LDO2 = 0x1e,
kD1815_LDO3 = 0x1f,
kD1815_LDO4 = 0x20,
kD1815_LDO5 = 0x21,
kD1815_LDO6 = 0x22,
kD1815_LDO7 = 0x23,
kD1815_LDO8 = 0x24,
kD1815_LDO9 = 0x25,
kD1815_LDO10 = 0x26,
kD1815_LDO11 = 0x27,
kD1815_LDO12 = 0x28,
kDIALOG_BUCK_CONTROL = 0x29,
kDIALOG_BUCK_CONTROL2 = 0x2a,
kDIALOG_CHARGE_BUCK_CONTROL = 0x2b,
kDIALOG_CHARGE_CONTROL_A = 0x2c,
kDIALOG_CHARGE_CONTROL_B = 0x2d,
kDIALOG_CHARGE_CONTROL_C = 0x2e,
kDIALOG_CHARGE_TIME = 0x2f,
kDIALOG_CHARGE_CONTROL_ICHG_BAT = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_HIB = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_TIME = kDIALOG_CHARGE_CONTROL_C,
kDIALOG_OTP_ISET_BAT = kDIALOG_CHARGE_CONTROL_A, // not a real OTP register
kDIALOG_ADC_CONTROL = 0x30,
kDIALOG_ADC_LSB = 0x31,
kDIALOG_ADC_MSB = 0x32,
kDIALOG_ADC_BIST_CONTROL = 0x33,
kD1815_ADC_T_ISET = 0x34,
kDIALOG_ICHG_AVG = 0x35,
kDIALOG_TBAT_0 = 0x38,
kDIALOG_ICHG_TBAT_0 = 0x39,
kDIALOG_TBAT_1 = 0x3a,
kDIALOG_ICHG_TBAT_1 = 0x3b,
kDIALOG_TBAT_2 = 0x3c,
kDIALOG_ICHG_TBAT_2 = 0x3d,
kDIALOG_TBAT_3 = 0x3e,
kDIALOG_ICHG_TBAT_3 = 0x3f,
kDIALOG_TBAT_4 = 0x40,
kDIALOG_ICHG_TBAT_4 = 0x41,
kDIALOG_TBAT_MAX = 0x42,
kDIALOG_ICHG_TBAT_NUM = 5,
kDIALOG_T_OFFSET_MSB = 0x43,
kDIALOG_T_OFFSET_LSB = 0x44,
kDIALOG_RTC_ALARM_A = 0x46,
kDIALOG_RTC_ALARM_B = 0x47,
kDIALOG_RTC_ALARM_C = 0x48,
kDIALOG_RTC_ALARM_D = 0x49,
kDIALOG_RTC_CONTROL = 0x4a,
kDIALOG_RTC_TIMEZONE = 0x4b,
kDIALOG_UPCOUNT_A = 0x4c,
kDIALOG_UPCOUNT_B = 0x4d,
kDIALOG_UPCOUNT_C = 0x4e,
kDIALOG_UPCOUNT_D = 0x4f,
kD1815_SYS_GPIO_1 = 0x50,
kDIALOG_SYS_GPIO_REG_START = kD1815_SYS_GPIO_1,
kD1815_SYS_GPIO_2 = 0x51,
kD1815_SYS_GPIO_3 = 0x52,
kD1815_SYS_GPIO_4 = 0x53,
kD1815_SYS_GPIO_5 = 0x54,
kD1815_SYS_GPIO_6 = 0x55,
kD1815_SYS_GPIO_7 = 0x56,
kD1815_SYS_GPIO_8 = 0x57,
kD1815_SYS_GPIO_TEMP = 0x58,
kD1815_SYS_GPIO_SPARE = 0x59,
kD1815_SYS_GPIO_DEB1 = 0x5a,
kDIALOG_SYS_GPIO_DEB_REG_START = kD1815_SYS_GPIO_DEB1,
kD1815_SYS_GPIO_DEB2 = 0x5b,
kD1815_SYS_GPIO_DEB3 = 0x5c,
kD1815_SYS_GPIO_DEB4 = 0x5d,
kD1815_SYS_GPIO_DEB6 = 0x5e,
kDIALOG_LDO_CONTROL = 0x5f,
kDIALOG_WLED_ISET = 0x66,
kDIALOG_WLED_ISET2 = 0x67,
kDIALOG_WLED_CONTROL = 0x68,
kDIALOG_WLED_OPTIONS = kDIALOG_WLED_CONTROL,
kD1815_LCM_CONTROL1 = 0x6a,
kD1815_LCM_CONTROL2 = 0x6b,
kD1815_LCM_CONTROL3 = 0x6c,
kDIALOG_LCM_BOOST = kD1815_LCM_CONTROL3,
kDIALOG_VIB_CTRL = 0x6e,
kDIALOG_VIB_VSET = 0x6f,
kD1815_BUTTON1 = 0x78,
kD1815_BUTTON2 = 0x79,
kD1815_BUTTON3 = 0x7a,
kDIALOG_SYS_CONFIG = 0x7b,
kD1815_BUCK1_PRE1 = 0x7c,
kDIALOG_BUCK1_PRE1 = kD1815_BUCK1_PRE1,
kD1815_BUCK1_PRE2 = 0x7d,
kD1815_BUCK1_PRE3 = 0x7e,
kD1815_BUCK1_SEL = 0x7f,
kDIALOG_BUCK1_SEL = kD1815_BUCK1_SEL,
kDIALOG_MEMBYTE0 = 0x80,
kDIALOG_MEMBYTE_LAST = 0xa7,
kDIALOG_BUTTON_DBL = 0xAD,
};
enum {
kD1815_CHIP_ID_MRC_MASK = (0xf << 0),
kD1815_CHIP_ID_MRC_A0 = (0 << 0),
kD1815_CHIP_ID_MRC_A1 = (1 << 0),
};
enum {
kD1815_EVENT_A_BUTTON1 = (1 << 0),
kD1815_EVENT_A_BUTTON2 = (1 << 1),
kD1815_EVENT_A_BUTTON3 = (1 << 2),
kD1815_EVENT_A_VBUS_DET = (1 << 3),
kD1815_EVENT_A_FW_DET = (1 << 4),
kD1815_EVENT_A_ACC_DET = (1 << 5),
kD1815_EVENT_A_VBUS_EXT = (1 << 6),
kD1815_EVENT_A_VDD_LOW = (1 << 7),
};
// EVENT_B events are assumed volatile (lost over sleep/wake)
enum {
kD1815_EVENT_B_SWI = (1 << 0),
kD1815_EVENT_B_CHG_PRE = (1 << 1),
kD1815_EVENT_B_CHG_FAST = (1 << 2),
kD1815_EVENT_B_CHG_END = (1 << 3),
kD1815_EVENT_B_TBAT = (1 << 4),
kD1815_EVENT_B_EOMC = (1 << 5),
kD1815_EVENT_B_FW_OV = (1 << 6),
kDIALOG_EVENT_B_HIB = (1 << 7),
};
enum {
kD1815_EVENT_C_GPIO1 = (1 << 0),
kD1815_EVENT_C_GPIO2 = (1 << 1),
kD1815_EVENT_C_GPIO3 = (1 << 2),
kD1815_EVENT_C_GPIO4 = (1 << 3),
kD1815_EVENT_C_GPIO5 = (1 << 4),
kD1815_EVENT_C_GPIO6 = (1 << 5),
kD1815_EVENT_C_GPIO7 = (1 << 6),
kD1815_EVENT_C_GPIO8 = (1 << 7),
};
enum {
kD1815_EVENT_E_ALARM = (1 << 0),
kD1815_EVENT_E_FW_REM = (1 << 4),
kD1815_EVENT_E_VBUS_REM = (1 << 6),
};
enum {
kD1815_EVENT_F_GPIO9 = (1 << 0),
kD1815_EVENT_F_GPIO10 = (1 << 1),
kD1815_EVENT_F_BTN1_DBL = (1 << 2),
kD1815_EVENT_F_BTN2_DBL = (1 << 3),
kD1815_EVENT_F_BTN3_DBL = (1 << 4),
};
enum {
kD1815_STATUS_A_BUTTON1 = (1 << 0),
kD1815_STATUS_A_BUTTON2 = (1 << 1),
kD1815_STATUS_A_BUTTON3 = (1 << 2),
kD1815_STATUS_A_VBUS_DET = (1 << 3),
kD1815_STATUS_A_FW_DET = (1 << 4),
kD1815_STATUS_A_ACC_DET = (1 << 5),
kD1815_STATUS_A_VBUS_EXT = (1 << 6),
kD1815_STATUS_A_VDD_LOW = (1 << 7),
};
enum {
kD1815_STATUS_B_CHG_ATT = (1 << 0),
kD1815_STATUS_B_CHG_PRE = (1 << 1),
kD1815_STATUS_B_CHG_FAST = (1 << 2),
kD1815_STATUS_B_CHG_END = (1 << 3),
kD1815_STATUS_B_TBAT = (1 << 4),
kD1815_STATUS_B_CHG_TO = (1 << 5),
kD1815_STATUS_B_FW_OV = (1 << 6),
};
enum {
kD1815_STATUS_C_GPIO1 = (1 << 0),
kD1815_STATUS_C_GPIO2 = (1 << 1),
kD1815_STATUS_C_GPIO3 = (1 << 2),
kD1815_STATUS_C_GPIO4 = (1 << 3),
kD1815_STATUS_C_GPIO5 = (1 << 4),
kD1815_STATUS_C_GPIO6 = (1 << 5),
kD1815_STATUS_C_GPIO7 = (1 << 6),
kD1815_STATUS_C_GPIO8 = (1 << 7),
};
enum {
kD1815_STATUS_E_GPIO9 = (1 << 0),
kD1815_STATUS_E_GPIO10 = (1 << 1),
};
enum {
kDIALOG_EVENT_HOLD_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1815_EVENT_A_BUTTON2),
kDIALOG_EVENT_MENU_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1815_EVENT_A_BUTTON1),
kDIALOG_EVENT_RINGER_BUTTON_MASK= EVENT_FLAG_MAKE(0, kD1815_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS = (kD1815_EVENT_A_BUTTON2 |
kD1815_EVENT_A_BUTTON1 |
kD1815_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS_MASK = EVENT_FLAG_MAKE(0, kDIALOG_EVENT_BUTTONS),
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_EVENT_HOLD_BUTTON_MASK,
kDIALOG_EVENT_ALARM_MASK = EVENT_FLAG_MAKE(4, kD1815_EVENT_E_ALARM),
kDIALOG_EVENT_ACC_DET_MASK = EVENT_FLAG_MAKE(0, kD1815_EVENT_A_ACC_DET),
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD1815_EVENT_A_VBUS_DET),
kDIALOG_EVENT_VHP_DET_MASK = EVENT_FLAG_MAKE(0, kD1815_STATUS_A_FW_DET),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(1, kD1815_EVENT_B_EOMC),
kDIALOG_EVENT_HIB_MASK = EVENT_FLAG_MAKE(1, kDIALOG_EVENT_B_HIB),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(1, kD1815_STATUS_B_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(1, kD1815_STATUS_B_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(2, kD1815_EVENT_C_GPIO8),
kDIALOG_EVENT_GPIO9_MASK = EVENT_FLAG_MAKE(5, kD1815_EVENT_F_GPIO9),
kDIALOG_EVENT_GPIO10_MASK = EVENT_FLAG_MAKE(5, kD1815_EVENT_F_GPIO10),
kDIALOG_EVENT_HOLD_DBL_MASK = EVENT_FLAG_MAKE(5, kD1815_EVENT_F_BTN2_DBL),
kDIALOG_EVENT_MENU_DBL_MASK = EVENT_FLAG_MAKE(5, kD1815_EVENT_F_BTN1_DBL),
kDIALOG_EVENT_RINGER_DBL_MASK = EVENT_FLAG_MAKE(5, kD1815_EVENT_F_BTN3_DBL),
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO11_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO12_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO13_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO14_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO15_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO16_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO17_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO18_MASK = kDIALOG_NOTEXIST_MASK,
/*
kDIALOG_EVENT_WAKE_MASK = ((kD1815_EVENT_A_WAKEMASK << 0)
| (kD1815_EVENT_B_WAKEMASK << 8)
| (kD1815_EVENT_C_WAKEMASK << 16)
| (kD1815_EVENT_D_WAKEMASK << 24)),
kDIALOG_EVENT_BUTTONS_MASK = (kDIALOG_EVENT_HOLD_BUTTON_MASK |
kDIALOG_EVENT_MENU_BUTTON_MASK |
kDIALOG_EVENT_RINGER_BUTTON_MASK),
kDIALOG_EVENT_PWRSUPPLY_MASK
= (((kD1815_EVENT_A_VBUS_DET | kD1815_STATUS_A_FW_DET) << 0)
| (kD1815_EVENT_C_GPIO_FW_DETECT << 16)
| ((kD1815_EVENT_D_VHP_REM | kD1815_EVENT_D_VBUS_REM) << 24)),
*/
// not on D1755
/*
kDIALOG_EVENT_ON_MASK = 0,
kDIALOG_EVENT_LDO2_EN_MASK = 0,
*/
};
enum {
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD1815_STATUS_A_VBUS_DET),
kDIALOG_STATUS_FW_MASK = STATUS_FLAG_MAKE(0, kD1815_STATUS_A_FW_DET),
kDIALOG_STATUS_ACC_DET_MASK = STATUS_FLAG_MAKE(0, kD1815_STATUS_A_ACC_DET),
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(1, kD1815_STATUS_B_CHG_PRE | kD1815_STATUS_B_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(1, kD1815_STATUS_B_CHG_TO),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD1815_STATUS_B_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(1, kD1815_STATUS_B_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(1, kD1815_STATUS_B_CHG_ATT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(((gpio) < 8) ? 2 : 5, (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {kD1815_STATUS_A_FW_DET, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD1815_STATUS_B_CHG_PRE | kD1815_STATUS_B_CHG_FAST, 0, 0, 0};
enum {
kD1815_EVENT_A_WAKEMASK = kD1815_EVENT_A_BUTTON1 | kD1815_EVENT_A_BUTTON2 | kD1815_EVENT_A_BUTTON3 | kD1815_EVENT_A_VBUS_DET | kD1815_STATUS_A_FW_DET | kD1815_EVENT_A_ACC_DET,
kD1815_EVENT_B_WAKEMASK = kDIALOG_EVENT_B_HIB | kD1815_EVENT_B_TBAT | kD1815_EVENT_B_CHG_END,
kD1815_EVENT_C_WAKEMASK = kD1815_EVENT_C_GPIO1 | kD1815_EVENT_C_GPIO2 | kD1815_EVENT_C_GPIO3 | kD1815_EVENT_C_GPIO4 | kD1815_EVENT_C_GPIO5 | kD1815_EVENT_C_GPIO6 | kD1815_EVENT_C_GPIO7 | kD1815_EVENT_C_GPIO8,
kD1815_EVENT_D_WAKEMASK = 0,
kD1815_EVENT_E_WAKEMASK = kD1815_EVENT_E_ALARM | kD1815_EVENT_E_FW_REM | kD1815_EVENT_E_VBUS_REM,
kD1815_EVENT_F_WAKEMASK = kD1815_EVENT_F_GPIO9 | kD1815_EVENT_F_GPIO10,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
(UInt8)~kD1815_EVENT_A_WAKEMASK,
(UInt8)~kD1815_EVENT_B_WAKEMASK,
(UInt8)~kD1815_EVENT_C_WAKEMASK,
(UInt8)~kD1815_EVENT_D_WAKEMASK,
(UInt8)~kD1815_EVENT_E_WAKEMASK,
(UInt8)~kD1815_EVENT_F_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD1815_EVENT_A_WAKEMASK & ~kDIALOG_EVENT_BUTTONS,
kD1815_EVENT_B_WAKEMASK,
kD1815_EVENT_C_WAKEMASK,
kD1815_EVENT_D_WAKEMASK,
kD1815_EVENT_E_WAKEMASK,
kD1815_EVENT_F_WAKEMASK
};
// All events that defer shutdown
static const eventRegisters kDialogEventRestartMask = {
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_HOLD_BUTTON_MASK, 0) | EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ACC_DET_MASK, 0),
0,
0,
0,
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ALARM_MASK, 4),
0
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD1815_EVENT_A_VBUS_DET | kD1815_EVENT_A_FW_DET,
0,
0,
0,
kD1815_EVENT_E_FW_REM | kD1815_EVENT_E_VBUS_REM,
0,
};
static const eventRegisters kDialogEventUSBMask = {
kD1815_EVENT_A_VBUS_DET,
0,
0,
0,
kD1815_EVENT_E_VBUS_REM,
0,
};
static const eventRegisters kDialogEventFWMask = {
kD1815_EVENT_A_FW_DET,
0,
0,
0,
kD1815_EVENT_E_FW_REM,
0,
};
enum {
kDialogEventPwrsupplyCount = 4,
kDialogEventUSBCount = 2,
kDialogEventFWCount = 2,
};
enum {
kDIALOG_SYS_CONTROL_STANDBY = (1 << 0),
kDIALOG_SYS_CONTROL_HIBERNATE = (1 << 1),
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_SWI_EN = (1 << 4),
kD1815_SYS_CONTROL_PRO_FET_DIS = (1 << 5),
kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND = (1 << 6),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND
| kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = kDIALOG_SYS_CONTROL_HIBERNATE,
};
enum {
kDIALOG_FAULT_LOG_WDOG = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RESET_IN_1 = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 4)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_BOOST = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
};
enum {
kD1815_ACTIVE3_LCM_BOOST_EN = (1 << 3),
kD1815_ACTIVE3_LCM_LDO1_EN = (1 << 4),
kD1815_ACTIVE3_LCM_LDO2_EN = (1 << 5),
kDIALOG_LCM_ACTIVE_BOOST_EN = kD1815_ACTIVE3_LCM_BOOST_EN,
kDIALOG_LCM_ACTIVE_MASK = (kD1815_ACTIVE3_LCM_LDO1_EN|
kD1815_ACTIVE3_LCM_LDO2_EN),
};
enum {
kDIALOG_BUCK_CONTROL_BUCK1_GO = (1 << 6),
kDIALOG_BUCK_CONTROL_BUCK1_SWI_EN = (1 << 7)
};
enum {
kDIALOG_BUCK_CONTROL2_HIB_CLK = (1 << 7),
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_50 = 0x00,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x05,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x0f,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_300 = 0x11,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_400 = 0x13,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_450 = 0x14,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x15,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_600 = 0x17,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_700 = 0x18,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_900 = 0x19,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x1a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0x1f,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0x1f,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_VBUS_CHG_BUCK_EN = (1 << 7),
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3f,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_A_CHG_SUSP = (1 << 6),
kDIALOG_CHARGE_CONTROL_A_CHG_HIB = (1 << 7),
kDIALOG_CHARGE_CONTROL_CHG_HIB = kDIALOG_CHARGE_CONTROL_A_CHG_HIB,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 30,
kDIALOG_CHARGE_CONTROL_MAX = 1890,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0xF0,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x07,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0xf << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0x0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = (0x1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (0x2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ACC_ID = (0x3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT = (0x5 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BRICK_ID = (0x6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN7 = (0x7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (0x8 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_IN = (0x9 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_NTC0 = (0xa << 0),
kDIALOG_ADC_CONTROL_MUX_NUM_NTC = 5,
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = (0xf << 0),
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 4),
kDIALOG_ADC_CONTROL_ADC_REF_EN = (1 << 5),
kDIALOG_ADC_CONTROL_AUTO_VDD_OUT_EN = (1 << 6),
kDIALOG_ADC_CONTROL_TBAT_ISRC_EN = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 12,
kDIALOG_ADC_FULL_SCALE_MV = 2500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kDIALOG_BIST_ADC_CTRL_MUX_SEL_MASK = (15 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK1 = (0 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO1 = (1 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO2 = (2 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO3 = (3 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO4 = (4 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO5 = (5 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO6 = (6 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO7 = (7 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO8 = (8 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO9 = (9 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO10 = (10 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO11 = (11 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO12 = (12 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK2 = (13 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IBAT_IN_OFF = (14 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IBAT_OUT_OFF = (15 << 0),
kDIALOG_BIST_ADC_CTRL_BIST_EN = (1 << 7),
kD1815_BIST_CONTROL_STD_USB_LIMIT = (1 << 4),
};
enum {
kDIALOG_RTC_CONTROL_MONITOR = (1 << 0),
kDIALOG_RTC_CONTROL_ALARM_EN = (1 << 6),
};
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_INPUT_WAKE = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (7 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (0 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = (2 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH= (3 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (4 << 5),
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_MASK) \
< kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH)
enum {
kDIALOG_WLED_CONTROL_WLED_ENABLE1 = (1 << 0),
kDIALOG_WLED_CONTROL_WLED_ENABLE2 = (1 << 1),
kDIALOG_WLED_CONTROL_WLED_RAMP_EN = (1 << 2),
kDIALOG_WLED_CONTROL_WLED_SWI_EN = (1 << 3),
kDIALOG_WLED_CONTROL_WLED_DITHER_EN = (1 << 4),
kDIALOG_WLED_CONTROL_WLED_DITH_RAMP_EN = (1 << 5),
kDIALOG_WLED_OPTIONS_DEFAULT = kDIALOG_WLED_CONTROL_WLED_DITHER_EN,
kDIALOG_WLED_OPTIONS_xWI_EN = kDIALOG_WLED_CONTROL_WLED_SWI_EN,
kDIALOG_WLED_OPTIONS_MASK = (kDIALOG_WLED_CONTROL_WLED_RAMP_EN|
kDIALOG_WLED_CONTROL_WLED_DITHER_EN|
kDIALOG_WLED_CONTROL_WLED_DITH_RAMP_EN),
};
#define WLED_ISET_BITS (11)
enum {
kDIALOG_VIB_CTRL_PWM_EN = (1 << 0),
kDIALOG_VIB_CTRL_BRAKE = (1 << 1),
kDIALOG_VIB_CTRL_PWM_CLK_MASK = (3 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_2MHZ = (0 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_1MHZ = (1 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_500KHZ = (2 << 2),
kDIALOG_VIB_VSET_MASK = (0x3f << 0),
};
enum {
kDIALOG_SYS_CONFIG_RESET_TIMER_MASK = (3 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_4S = (0 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_6S = (1 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_8S = (2 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_10S = (3 << 3),
kDIALOG_SYS_CONFIG_WDOG_MODE_100MS = (0 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_250MS = (1 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_500MS = (2 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_1000MS = (3 << 1),
kDIALOG_SYS_CONFIG_WDOG_EN = (1 << 0),
kDIALOG_SYS_CONFIG_WDOG_ACTIVE = 0,
};
enum {
kDIALOG_SWI_WLED_ISET = (1 << 12),
kDIALOG_SWI_BUCK1_VSEL = (6 << 12),
};
enum {
kDIALOG_BUTTON_DBL_CLICK_RATE_MASK = (7 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_50MS = (0 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_100MS = (1 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_150MS = (2 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_200MS = (3 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_250MS = (4 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_300MS = (5 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_350MS = (6 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_400MS = (7 << 0),
kD1815_BUTTON_DBL_BTN1_DBL_EN = (1 << 3),
kD1815_BUTTON_DBL_BTN2_DBL_EN = (1 << 4),
kD1815_BUTTON_DBL_BTN3_DBL_EN = (1 << 5),
kDIALOG_BUTTON_DBL_HOLD_DBL_EN = kD1815_BUTTON_DBL_BTN2_DBL_EN,
kDIALOG_BUTTON_DBL_MENU_DBL_EN = kD1815_BUTTON_DBL_BTN1_DBL_EN,
kDIALOG_BUTTON_DBL_RINGER_DBL_EN = kD1815_BUTTON_DBL_BTN3_DBL_EN,
};
#define NUM_LDOS 19
static const struct ldo_params ldo_1815[NUM_LDOS] = {
{ 2500, 50, 0x15, 0x1f, 0x1, kD1815_LDO1, kD1815_ACTIVE1, 0x04 }, // LDO1
{ 1650, 5, 0x1f, 0x1f, 0x0, kD1815_LDO2, kD1815_ACTIVE1, 0x08 }, // LDO2
{ 2500, 50, 0x10, 0x1f, 0x0, kD1815_LDO3, kD1815_ACTIVE1, 0x10 }, // LDO3
{ 1800, 50, 0x1e, 0x1f, 0x0, kD1815_LDO4, kD1815_ACTIVE1, 0x20 }, // LDO4
{ 2500, 50, 0x16, 0x1f, 0x2, kD1815_LDO5, kD1815_ACTIVE1, 0x40 }, // LDO5
{ 2500, 50, 0x16, 0x1f, 0x4, kD1815_LDO6, kD1815_ACTIVE1, 0x80 }, // LDO6
{ 1500, 100,0x1f, 0x1f, 0x0, kD1815_LDO7, kD1815_ACTIVE2, 0x01 }, // LDO7
{ 2000, 50, 0x1f, 0x1f, 0x0, kD1815_LDO8, kD1815_ACTIVE2, 0x02 }, // LDO8
{ 1200, 25, 0x0c, 0x0f, 0x0, kD1815_LDO9, kD1815_ACTIVE2, 0x04 }, // LDO9
{ 1700, 50, 0x1a, 0x1f, 0x8, kD1815_LDO10, kD1815_ACTIVE2, 0x08 }, // LDO10
{ 1700, 50, 0x1a, 0x1f, 0x0, kD1815_LDO11, kD1815_ACTIVE2, 0x10 }, // LDO11
{ 600, 25, 0x1c, 0x1f, 0x0, kD1815_LDO12, kD1815_ACTIVE2, 0x20 }, // LDO12
{ 0, 0, 0, 0, 0x0, 0, kD1815_ACTIVE3, 0x02 }, // 13 - WDIG_EN
{ 0, 0, 0, 0, 0x0, 0, kD1815_ACTIVE3, 0x01 }, // 14 - LDO9_DSW
{ 5000, 50, 0x14, 0x1f, 0x0, 0, kD1815_ACTIVE3, 0x10 }, // 15 - LCM_LDO1_EN
{ 5000, 50, 0x14, 0x1f, 0x0, 0, kD1815_ACTIVE3, 0x20 }, // 16 - LCM_LDO2_EN
{ 5000, 50, 0x1f, 0x1f, 0x0, 0, kD1815_ACTIVE3, 0x08 }, // 17 - LCM_BOOST_EN
{ 0, 0, 0, 0, 0x0, 0, kD1815_HIBERNATE1, 0x04 }, // 18 - set LDO1_EN in HIB
{ 0, 0, 0, 0, 0x0, 0, kD1815_HIBERNATE1, 0x80 }, // 19 - set LDO6_EN in HIB
};
#define LDOP ldo_1815
drivers/dialog/pmu/d1881.h
+800
View File
@@ -0,0 +1,800 @@
#define PMU_HAS_SWI 0
#define PMU_HAS_DWI 1
#define PMU_HAS_REG_BANK 1
#define PMU_HAS_BIST_ADC 1
#define PMU_HAS_LCM_LDO 1
#define PMU_HAS_VIB 1
#define PMU_HAS_WLED 1
enum {
kDIALOG_ADDR_R = 0xe9,
kDIALOG_ADDR_W = 0xe8,
kDIALOG_REG_BYTES = 1,
};
enum {
kDIALOG_EVENT_COUNT = 7,
kDIALOG_STATUS_COUNT = 6,
kDIALOG_HIBERNATE_COUNT = 4,
kDIALOG_CHIPID_COUNT = 1,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_GPIO_COUNT = 11,
};
#include "dCommon.h"
enum {
kDIALOG_BANK_COUNT = 2,
kDIALOG_BANK0_SHARED_COUNT = 0x57,
};
enum {
kDIALOG_CHIP_ID = 0x00,
kDIALOG_EVENT_A = 0x01,
kDIALOG_EVENT_B = 0x02,
kDIALOG_EVENT_C = 0x03,
kDIALOG_EVENT_D = 0x04,
kDIALOG_EVENT_E = 0x05,
kDIALOG_EVENT_F = 0x06,
kDIALOG_EVENT_G = 0x07,
kDIALOG_STATUS_A = 0x08,
kDIALOG_STATUS_B = 0x09,
kDIALOG_STATUS_C = 0x0a,
kDIALOG_STATUS_D = 0x0b,
kDIALOG_STATUS_E = 0x0c,
kDIALOG_STATUS_F = 0x0d,
kDIALOG_IRQ_MASK_A = 0x0e,
kDIALOG_IRQ_MASK_B = 0x0f,
kDIALOG_IRQ_MASK_C = 0x10,
kDIALOG_IRQ_MASK_D = 0x11,
kDIALOG_IRQ_MASK_E = 0x12,
kDIALOG_IRQ_MASK_F = 0x13,
kDIALOG_IRQ_MASK_G = 0x14,
kDIALOG_SYS_CONTROL = 0x15,
kDIALOG_SYS_CONTROL2 = 0x16,
kDIALOG_FAULT_LOG = 0x17,
kDIALOG_BANKSEL = 0x18,
kD1881_ACTIVE1 = 0x20,
kD1881_ACTIVE2 = 0x21,
kD1881_ACTIVE3 = 0x22,
kDIALOG_LCM_ACTIVE = kD1881_ACTIVE3,
kD1881_ACTIVE4 = 0x23,
kD1881_STANDBY1 = 0x24,
kDIALOG_STANDBY = kD1881_STANDBY1,
kD1881_HIBERNATE1 = 0x25,
kD1881_HIBERNATE2 = 0x26,
kD1881_HIBERNATE3 = 0x27,
kD1881_HIBERNATE4 = 0x28,
kD1881_BUCK0 = 0x29,
kDIALOG_BUCK0 = kD1881_BUCK0,
kD1881_BUCK1 = 0x2a,
kD1881_BUCK2 = 0x2b,
kDIALOG_BUCK2 = kD1881_BUCK2,
kD1881_BUCK3 = 0x2c,
kD1881_BUCK4 = 0x2d,
kD1881_LDO1 = 0x2e,
kD1881_LDO2 = 0x2f,
kD1881_LDO3 = 0x30,
kD1881_LDO4 = 0x31,
kD1881_LDO5 = 0x32,
kD1881_LDO6 = 0x33,
kD1881_LDO7 = 0x34,
kD1881_LDO8 = 0x35,
kD1881_LDO9 = 0x36,
kD1881_LDO10 = 0x37,
kD1881_LDO11 = 0x38,
kD1881_LDO12 = 0x39,
kDIALOG_BUCK_CONTROL1 = 0x3a,
kDIALOG_BUCK_CONTROL2 = 0x3b,
kDIALOG_BUCK_CONTROL3 = 0x3c,
kDIALOG_BUCK_CONTROL4 = 0x3d,
kDIALOG_BUCK_CONTROL_NUM = 4,
kDIALOG_CHARGE_BUCK_CONTROL = 0x3e,
kDIALOG_CHARGE_CONTROL_A = 0x3f,
kDIALOG_CHARGE_CONTROL_B = 0x40,
kDIALOG_CHARGE_CONTROL_C = 0x41,
kDIALOG_CHARGE_TIME = 0x42,
kDIALOG_CHARGE_CONTROL_ICHG_BAT = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_HIB = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_TIME = kDIALOG_CHARGE_CONTROL_C,
kDIALOG_CHARGE_CONTROL_EN = kDIALOG_CHARGE_CONTROL_B,
kDIALOG_OTP_ISET_BAT = kDIALOG_CHARGE_CONTROL_A, // not a real OTP register
kDIALOG_ADC_CONTROL = 0x43,
kDIALOG_ADC_LSB = 0x44,
kDIALOG_ADC_MSB = 0x45,
kDIALOG_ICHG_AVG = 0x47,
kDIALOG_TBAT_0 = 0x4a,
kDIALOG_ICHG_TBAT_0 = 0x4b,
kDIALOG_TBAT_1 = 0x4c,
kDIALOG_ICHG_TBAT_1 = 0x4d,
kDIALOG_TBAT_2 = 0x4e,
kDIALOG_ICHG_TBAT_2 = 0x4f,
kDIALOG_TBAT_3 = 0x50,
kDIALOG_ICHG_TBAT_3 = 0x51,
kDIALOG_TBAT_4 = 0x52,
kDIALOG_ICHG_TBAT_4 = 0x53,
kDIALOG_TBAT_MAX = 0x54,
kDIALOG_ICHG_TBAT_NUM = 5,
kDIALOG_T_OFFSET_MSB = 0x55,
kDIALOG_T_OFFSET_LSB = 0x56,
kDIALOG_RTC_ALARM_A = 0x57,
kDIALOG_RTC_ALARM_B = 0x58,
kDIALOG_RTC_ALARM_C = 0x59,
kDIALOG_RTC_ALARM_D = 0x5a,
kDIALOG_RTC_CONTROL = 0x5b,
kDIALOG_RTC_TIMEZONE = 0x5c,
kDIALOG_UPCOUNT_A = 0x5d,
kDIALOG_UPCOUNT_B = 0x5e,
kDIALOG_UPCOUNT_C = 0x5f,
kDIALOG_UPCOUNT_D = 0x60,
kD1881_SYS_GPIO_1 = 0x61,
kDIALOG_SYS_GPIO_REG_START = kD1881_SYS_GPIO_1,
kD1881_SYS_GPIO_2 = 0x62,
kD1881_SYS_GPIO_3 = 0x63,
kD1881_SYS_GPIO_4 = 0x64,
kD1881_SYS_GPIO_5 = 0x65,
kD1881_SYS_GPIO_6 = 0x66,
kD1881_SYS_GPIO_7 = 0x67,
kD1881_SYS_GPIO_8 = 0x68,
kD1881_SYS_GPIO_9 = 0x69,
kD1881_SYS_GPIO_10 = 0x6a,
kD1881_SYS_GPIO_11 = 0x6b,
kD1881_SYS_GPIO_DEB1 = 0x6c,
kD1881_SYS_GPIO_DEB2 = 0x6d,
kD1881_SYS_GPIO_DEB3 = 0x6e,
kD1881_SYS_GPIO_DEB4 = 0x6f,
kD1881_SYS_GPIO_DEB5 = 0x70,
kD1881_SYS_GPIO_DEB6 = 0x71,
kDIALOG_LDO_CONTROL = 0x72,
kDIALOG_WLED_ISET = 0x78,
kDIALOG_WLED_ISET2 = 0x79,
kDIALOG_WLED_CONTROL = 0x7a,
kDIALOG_WLED_CONTROL2 = 0x7b,
kDIALOG_WLED_DWI_CONTROL = kDIALOG_WLED_CONTROL,
kDIALOG_WLED_OPTIONS = kDIALOG_WLED_CONTROL,
kD1881_LCM_CONTROL1 = 0x7c,
kD1881_LCM_CONTROL2 = 0x7d,
kD1881_LCM_CONTROL3 = 0x7e,
kD1881_LCM_BST_CONTROL = 0x7f,
kDIALOG_LCM_BOOST = kD1881_LCM_BST_CONTROL,
kDIALOG_VIB_CTRL = 0x80,
kDIALOG_VIB_VSET = 0x81,
kDIALOG_TDEV1_RISE = 0x82,
kDIALOG_TDEV1_FALL = 0x83,
kDIALOG_TDEV2_RISE = 0x84,
kDIALOG_TDEV2_FALL = 0x85,
kDIALOG_TDEV3_RISE = 0x86,
kDIALOG_TDEV3_FALL = 0x87,
kDIALOG_TDEV4_RISE = 0x88,
kDIALOG_TDEV4_FALL = 0x89,
kDIALOG_TLDO9_RISE = 0x8a,
kDIALOG_TLDO5_RISE = 0x8b,
kDIALOG_TCBUCK_RISE = 0x8c,
kDIALOG_TCHG_RISE = 0x8d,
kDIALOG_TBUCK0_RISE = 0x8e,
kDIALOG_TBUCK2_RISE = 0x8f,
kDIALOG_TBUCK3_RISE = 0x90,
kDIALOG_TBUCK4_RISE = 0x91,
kDIALOG_TISENSE_HYST = 0x92,
kD1881_BUTTON1 = 0x93,
kD1881_BUTTON2 = 0x94,
kD1881_BUTTON3 = 0x95,
kDIALOG_SYS_CONFIG = 0x96,
kD1881_BUCK3_HIB = 0x97,
kD1881_BUCK4_HIB = 0x98,
kD1881_GPIO_SOFTHIB1 = 0x99,
kD1881_GPIO_SOFTHIB2 = 0x9a,
kDIALOG_BUTTON_DBL = 0x9b,
kDIALOG_MEMBYTE0 = 0xa0,
kDIALOG_MEMBYTE_LAST = 0xc7,
// Bank 1 Test Registers
kD1881_TEST_MODE = 0xe0,
kDIALOG_APP_TMUX = 0x15c,
kDIALOG_BIST_ADC_CTRL = 0x15d,
kDIALOG_BIST_ADC_LSB = 0x15e,
kDIALOG_BIST_ADC_MSB = 0x15f,
};
enum {
kD1881_CHIP_ID_MRC_MASK = (0xf << 0),
kD1881_CHIP_ID_MRC_A0 = (0 << 0),
kD1881_CHIP_ID_MRC_A1 = (1 << 0),
kD1881_CHIP_ID_MRC_B1 = (6 << 0),
};
enum {
kD1881_EVENT_A_BUTTON1 = (1 << 0),
kD1881_EVENT_A_BUTTON2 = (1 << 1),
kD1881_EVENT_A_BUTTON3 = (1 << 2),
kD1881_EVENT_A_VCENTER_DET = (1 << 3),
kD1881_EVENT_A_FW_DET = (1 << 4),
kD1881_EVENT_A_ACC_DET = (1 << 5),
kD1881_EVENT_A_VBUS_EXT_DET = (1 << 6),
kD1881_EVENT_A_VDD_LOW = (1 << 7),
};
// EVENT_B events are assumed volatile (lost over sleep/wake)
enum {
kD1881_EVENT_B_DWI_TO = (1 << 0),
kD1881_EVENT_B_CHG_PRE = (1 << 1),
kD1881_EVENT_B_CHG_FAST = (1 << 2),
kD1881_EVENT_B_CHG_END = (1 << 3),
kD1881_EVENT_B_TBAT = (1 << 4),
kD1881_EVENT_B_EOMC = (1 << 5),
kD1881_EVENT_B_FW_OV = (1 << 6),
kDIALOG_EVENT_B_HIB = (1 << 7),
};
enum {
kD1881_EVENT_C_GPIO1 = (1 << 0),
kD1881_EVENT_C_GPIO2 = (1 << 1),
kD1881_EVENT_C_GPIO3 = (1 << 2),
kD1881_EVENT_C_GPIO4 = (1 << 3),
kD1881_EVENT_C_GPIO5 = (1 << 4),
kD1881_EVENT_C_GPIO6 = (1 << 5),
kD1881_EVENT_C_GPIO7 = (1 << 6),
kD1881_EVENT_C_GPIO8 = (1 << 7),
};
enum {
kD1881_EVENT_D_GPIO9 = (1 << 0),
kD1881_EVENT_D_GPIO10 = (1 << 1),
kD1881_EVENT_D_GPIO11 = (1 << 2),
kD1881_EVENT_D_BTN1_DBL = (1 << 3),
kD1881_EVENT_D_BTN2_DBL = (1 << 4),
kD1881_EVENT_D_BTN3_DBL = (1 << 5),
kD1881_EVENT_D_CHG_BUCK_FLG = (1 << 6),
kD1881_EVENT_D_VBUS_OV = (1 << 7),
};
enum {
kD1881_EVENT_F_ALARM = (1 << 0),
kD1881_EVENT_F_FW_REM = (1 << 4),
kD1881_EVENT_F_VBUS_REM = (1 << 6),
};
enum {
kD1881_STATUS_A_BUTTON1 = (1 << 0),
kD1881_STATUS_A_BUTTON2 = (1 << 1),
kD1881_STATUS_A_BUTTON3 = (1 << 2),
kD1881_STATUS_A_VCENTER_DET = (1 << 3),
kD1881_STATUS_A_FW_DET = (1 << 4),
kD1881_STATUS_A_ACC_DET = (1 << 5),
kD1881_STATUS_A_VBUS_EXT_DET = (1 << 6),
kD1881_STATUS_A_VDD_LOW = (1 << 7),
};
enum {
kD1881_STATUS_B_CHG_ATT = (1 << 0),
kD1881_STATUS_B_CHG_PRE = (1 << 1),
kD1881_STATUS_B_CHG_FAST = (1 << 2),
kD1881_STATUS_B_CHG_END = (1 << 3),
kD1881_STATUS_B_TBAT = (1 << 4),
kD1881_STATUS_B_CHG_TO = (1 << 5),
kD1881_STATUS_B_FW_OV = (1 << 6),
};
enum {
kD1881_STATUS_C_GPIO1 = (1 << 0),
kD1881_STATUS_C_GPIO2 = (1 << 1),
kD1881_STATUS_C_GPIO3 = (1 << 2),
kD1881_STATUS_C_GPIO4 = (1 << 3),
kD1881_STATUS_C_GPIO5 = (1 << 4),
kD1881_STATUS_C_GPIO6 = (1 << 5),
kD1881_STATUS_C_GPIO7 = (1 << 6),
kD1881_STATUS_C_GPIO8 = (1 << 7),
};
enum {
kD1881_STATUS_D_GPIO9 = (1 << 0),
kD1881_STATUS_D_GPIO10 = (1 << 1),
kD1881_STATUS_D_GPIO11 = (1 << 2),
kD1881_STATUS_D_PROT_FET_ON = (1 << 3),
kD1881_STATUS_D_CHG_BUCK_FLG = (1 << 6),
kD1881_STATUS_D_VBUS_OV = (1 << 7),
};
enum {
kDIALOG_EVENT_HOLD_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1881_EVENT_A_BUTTON2),
kDIALOG_EVENT_MENU_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1881_EVENT_A_BUTTON1),
kDIALOG_EVENT_RINGER_BUTTON_MASK= EVENT_FLAG_MAKE(0, kD1881_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS = (kD1881_EVENT_A_BUTTON2 |
kD1881_EVENT_A_BUTTON1 |
kD1881_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS_MASK = EVENT_FLAG_MAKE(0, kDIALOG_EVENT_BUTTONS),
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_EVENT_HOLD_BUTTON_MASK,
kDIALOG_EVENT_ALARM_MASK = EVENT_FLAG_MAKE(5, kD1881_EVENT_F_ALARM),
kDIALOG_EVENT_ACC_DET_MASK = EVENT_FLAG_MAKE(0, kD1881_EVENT_A_ACC_DET),
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD1881_EVENT_A_VBUS_EXT_DET),
kDIALOG_EVENT_VHP_DET_MASK = EVENT_FLAG_MAKE(0, kD1881_STATUS_A_FW_DET),
kDIALOG_EVENT_VBUS_REM_MASK = EVENT_FLAG_MAKE(5, kD1881_EVENT_F_VBUS_REM),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(1, kD1881_EVENT_B_EOMC),
kDIALOG_EVENT_HIB_MASK = EVENT_FLAG_MAKE(1, kDIALOG_EVENT_B_HIB),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(1, kD1881_EVENT_B_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(1, kD1881_EVENT_B_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(2, kD1881_EVENT_C_GPIO8),
kDIALOG_EVENT_GPIO9_MASK = EVENT_FLAG_MAKE(3, kD1881_EVENT_D_GPIO9),
kDIALOG_EVENT_GPIO10_MASK = EVENT_FLAG_MAKE(3, kD1881_EVENT_D_GPIO10),
kDIALOG_EVENT_GPIO11_MASK = EVENT_FLAG_MAKE(3, kD1881_EVENT_D_GPIO11),
kDIALOG_EVENT_HOLD_DBL_MASK = EVENT_FLAG_MAKE(3, kD1881_EVENT_D_BTN2_DBL),
kDIALOG_EVENT_MENU_DBL_MASK = EVENT_FLAG_MAKE(3, kD1881_EVENT_D_BTN1_DBL),
kDIALOG_EVENT_RINGER_DBL_MASK = EVENT_FLAG_MAKE(3, kD1881_EVENT_D_BTN3_DBL),
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO12_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO13_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO14_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO15_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO16_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO17_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO18_MASK = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD1881_STATUS_A_VCENTER_DET),
kDIALOG_STATUS_VBUS_MASK = STATUS_FLAG_MAKE(0, kD1881_STATUS_A_VBUS_EXT_DET),
kDIALOG_STATUS_FW_MASK = STATUS_FLAG_MAKE(0, kD1881_STATUS_A_FW_DET),
kDIALOG_STATUS_ACC_DET_MASK = STATUS_FLAG_MAKE(0, kD1881_STATUS_A_ACC_DET),
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(1, kD1881_STATUS_B_CHG_PRE | kD1881_STATUS_B_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(1, kD1881_STATUS_B_CHG_TO),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD1881_STATUS_B_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(1, kD1881_STATUS_B_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(1, kD1881_STATUS_B_CHG_ATT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(2 + ((gpio)/8), (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {kD1881_STATUS_A_FW_DET, 0, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD1881_STATUS_B_CHG_PRE | kD1881_STATUS_B_CHG_FAST, 0, 0, 0, 0};
enum {
kD1881_EVENT_A_WAKEMASK = (kD1881_EVENT_A_BUTTON1 |
kD1881_EVENT_A_BUTTON2 |
kD1881_EVENT_A_BUTTON3 |
kD1881_EVENT_A_VBUS_EXT_DET |
kD1881_STATUS_A_FW_DET |
kD1881_EVENT_A_ACC_DET),
kD1881_EVENT_B_WAKEMASK = 0,
kD1881_EVENT_C_WAKEMASK = 0,
kD1881_EVENT_D_WAKEMASK = 0,
kD1881_EVENT_E_WAKEMASK = 0,
kD1881_EVENT_F_WAKEMASK = (kD1881_EVENT_F_ALARM |
kD1881_EVENT_F_FW_REM |
kD1881_EVENT_F_VBUS_REM),
kD1881_EVENT_G_WAKEMASK = 0,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
~kD1881_EVENT_A_WAKEMASK,
~kD1881_EVENT_B_WAKEMASK,
~kD1881_EVENT_C_WAKEMASK,
~kD1881_EVENT_D_WAKEMASK,
~kD1881_EVENT_E_WAKEMASK,
~kD1881_EVENT_F_WAKEMASK,
~kD1881_EVENT_G_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD1881_EVENT_A_WAKEMASK & ~kDIALOG_EVENT_BUTTONS,
kD1881_EVENT_B_WAKEMASK,
kD1881_EVENT_C_WAKEMASK,
kD1881_EVENT_D_WAKEMASK,
kD1881_EVENT_E_WAKEMASK,
kD1881_EVENT_F_WAKEMASK,
kD1881_EVENT_G_WAKEMASK,
};
// All events that defer shutdown
static const eventRegisters kDialogEventRestartMask = {
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_HOLD_BUTTON_MASK, 0) | EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ACC_DET_MASK, 0),
0,
0,
0,
0,
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ALARM_MASK, 5),
0,
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD1881_EVENT_A_VBUS_EXT_DET | kD1881_EVENT_A_VCENTER_DET | kD1881_EVENT_A_FW_DET,
0,
0,
0,
0,
kD1881_EVENT_F_FW_REM | kD1881_EVENT_F_VBUS_REM,
0,
};
static const eventRegisters kDialogEventUSBMask = {
// only include VCENTER_DET; VBUS can come and go while charger still usable
kD1881_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
0,
0,
};
static const eventRegisters kDialogEventFWMask = {
kD1881_EVENT_A_FW_DET,
0,
0,
0,
0,
kD1881_EVENT_F_FW_REM,
0,
};
enum {
kDialogEventPwrsupplyCount = 5,
kDialogEventUSBCount = 1,
kDialogEventFWCount = 2,
};
enum {
kDIALOG_LCM_ACTIVE_BOOST_EN = (1 << 1),
kDIALOG_LCM_ACTIVE_MASK = (1 << 2) | (1 << 3) | (1 << 4),
};
enum {
kDIALOG_SYS_CONTROL_STANDBY = (1 << 0),
kDIALOG_SYS_CONTROL_HIBERNATE = (1 << 1),
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_SOFT_HIB = (1 << 3),
kDIALOG_SYS_CONTROL_HIB_CLK = (1 << 4),
kDIALOG_SYS_CONTROL_PRO_FET_DIS = (1 << 5),
kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND = (1 << 6),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND
| kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = kDIALOG_SYS_CONTROL_HIBERNATE,
};
enum {
kDIALOG_SYS_CONTROL2_DWI_EN = (1 << 0),
kDIALOG_SYS_CONTROL2_DWI_TEST_EN = (1 << 1),
kDIALOG_SYS_CONTROL2_HIB_32K = (1 << 4),
};
enum {
kDIALOG_FAULT_LOG_WDOG = FAULTLOG_FLAG_MAKE(0, (1 << 6)),
kDIALOG_FAULT_LOG_RESET_IN_1 = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 4)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_BOOST = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_BUCK_CONTROL_DWI_EN = (1 << 4),
kD1881_BUCK_CONTROL_CONT_MASK = (3 << 0),
kD1881_BUCK_CONTROL_CONT_SLEEP = (0 << 0),
kD1881_BUCK_CONTROL_CONT_AUTO = (1 << 0),
kD1881_BUCK_CONTROL_CONT_SYNC = (2 << 0),
kD1881_BUCK_CONTROL_CONT_PRE_SYNC = (3 << 0),
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MIN = 0x00,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x03,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x0d,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_300 = 0x17,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_400 = 0x21,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x2b,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_600 = 0x3f,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_700 = 0x3f,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_900 = 0x53,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x5d,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0xc1,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MAX = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0xff,
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_MIN = 70,
kDIALOG_CHARGE_BUCK_CONTROL_STEP_PER_100MA = 10,
kDIALOG_CHARGE_BUCK_CONTROL_MAX = 2620,
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3f,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_A_CHG_SUSP = (1 << 6),
kDIALOG_CHARGE_CONTROL_A_CHG_HIB = (1 << 7),
kDIALOG_CHARGE_CONTROL_CHG_HIB = kDIALOG_CHARGE_CONTROL_A_CHG_HIB,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 30,
kDIALOG_CHARGE_CONTROL_MAX = 1890,
};
enum {
kDIALOG_CHARGE_CONTROL_B_ALT_USB_DIS = (1 << 6),
kDIALOG_CHARGE_CONTROL_B_CHG_BUCK_EN = (1 << 7),
kDIALOG_CHARGE_BUCK_CONTROL_ISET_VBUS_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_B_CHG_BUCK_EN,
kDIALOG_CHARGE_CONTROL_ALT_USB_DIS = kDIALOG_CHARGE_CONTROL_B_ALT_USB_DIS,
kDIALOG_CHARGE_CONTROL_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_B_CHG_BUCK_EN,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0xF0,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x07,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0x1f << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0x0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = (0x1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (0x2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ACC_ID = (0x3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT = (0x5 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BRICK_ID = (0x6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN7 = (0x7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (0x8 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_IN = (0x9 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_NTC0 = (0xa << 0),
kDIALOG_ADC_CONTROL_MUX_NUM_NTC = 5,
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = (0xf << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_IN_OFF = (16 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT_OFF= (17 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LDO9_TEMP = (18 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LDO5_TEMP = (19 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_TEMP = (20 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CHG_TEMP = (21 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK0_TEMP = (22 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK2_TEMP = (23 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK3_TEMP = (24 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK4_TEMP = (25 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_START = kDIALOG_ADC_CONTROL_MUX_SEL_LDO9_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_END = kDIALOG_ADC_CONTROL_MUX_SEL_BUCK4_TEMP,
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 5),
kDIALOG_ADC_CONTROL_ADC_REF_EN = (1 << 6),
kDIALOG_ADC_CONTROL_AUTO_VDD_OUT_EN = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 12,
kDIALOG_ADC_FULL_SCALE_MV = 2500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kDIALOG_BIST_ADC_CTRL_MUX_SEL_MASK = (0x3f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO1 = (0x00 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO1 = (0x01 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO2 = (0x02 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO2 = (0x03 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO3 = (0x04 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO3 = (0x05 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO4 = (0x06 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO4 = (0x07 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO5 = (0x08 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO5 = (0x09 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO6 = (0x0a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO6 = (0x0b << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO7 = (0x0c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO7 = (0x0d << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO8 = (0x0e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO8 = (0x0f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO9 = (0x10 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO9 = (0x11 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO10 = (0x12 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO10 = (0x13 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO11 = (0x14 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO11 = (0x15 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO12 = (0x16 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO12 = (0x17 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM1 = (0x18 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM1 = (0x19 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM2 = (0x1a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM2 = (0x1b << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM3 = (0x1c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM3 = (0x1d << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VRTC = (0x1e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IRTC = (0x1f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUF_ON = (0x20 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IBUF_ON = (0x21 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK0 = (0x22 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK1 = (0x24 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK2 = (0x26 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK3 = (0x28 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK4 = (0x2a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VOUT_LED = (0x2c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBOOST_LCM = (0x2e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_A = (0x30 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_B = (0x32 << 0),
kDIALOG_BIST_ADC_CTRL_AUTO_RUN = (1 << 6),
kDIALOG_BIST_ADC_CTRL_MAN_CONV = (1 << 7),
};
enum {
kDIALOG_APP_TMUX_SEL_MASK = (7 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_0 = (0 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_1 = (1 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_2 = (2 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_3 = (3 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_4 = (4 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_5 = (5 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_6 = (6 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_7 = (7 << 0),
KDIALOG_APP_TMUX_EN = (1 << 7),
};
enum {
kDIALOG_RTC_CONTROL_MONITOR = (1 << 0),
kDIALOG_RTC_CONTROL_ALARM_EN = (1 << 6),
};
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_INPUT_WAKE = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (7 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (0 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = (2 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (3 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (4 << 5),
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_MASK) \
< kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH)
enum {
kDIALOG_WLED_CONTROL_WLED_ENABLE1 = (1 << 0),
kDIALOG_WLED_CONTROL_WLED_ENABLE2 = (1 << 1),
kDIALOG_WLED_CONTROL_WLED_RAMP_EN = (1 << 2),
kDIALOG_WLED_CONTROL_WLED_DWI_EN = (1 << 3),
kDIALOG_WLED_CONTROL_WLED_DITH_EN = (1 << 4),
kDIALOG_WLED_CONTROL_WLED_DITH_RAMP_EN = (1 << 5),
kDIALOG_WLED_OPTIONS_DEFAULT = kDIALOG_WLED_CONTROL_WLED_DITH_EN,
kDIALOG_WLED_OPTIONS_xWI_EN = kDIALOG_WLED_CONTROL_WLED_DWI_EN,
kDIALOG_WLED_OPTIONS_MASK = (kDIALOG_WLED_CONTROL_WLED_RAMP_EN|
kDIALOG_WLED_CONTROL_WLED_DITH_EN|
kDIALOG_WLED_CONTROL_WLED_DITH_RAMP_EN),
};
#define WLED_ISET_BITS (11)
enum {
kDIALOG_VIB_CTRL_PWM_EN = (1 << 0),
kDIALOG_VIB_CTRL_BRAKE = (1 << 1),
kDIALOG_VIB_CTRL_PWM_CLK_MASK = (3 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_2MHZ = (0 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_1MHZ = (1 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_500KHZ = (2 << 2),
kDIALOG_VIB_VSET_MASK = (0x3f << 0),
};
enum {
kDIALOG_SYS_CONFIG_WDOG_EN = (1 << 0),
kDIALOG_SYS_CONFIG_WDOG_MODE_100MS = (0 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_250MS = (1 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_500MS = (2 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_1000MS = (3 << 1),
kDIALOG_SYS_CONFIG_RESET_TIMER_MASK = (3 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_4S = (0 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_6S = (1 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_8S = (2 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_10S = (3 << 3),
kDIALOG_SYS_CONFIG_WDOG_ACTIVE = (1 << 5),
};
enum {
kDIALOG_BUTTON_DBL_CLICK_RATE_MASK = (7 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_50MS = (0 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_100MS = (1 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_150MS = (2 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_200MS = (3 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_250MS = (4 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_300MS = (5 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_350MS = (6 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_400MS = (7 << 0),
kD1815_BUTTON_DBL_BTN1_DBL_EN = (1 << 3),
kD1815_BUTTON_DBL_BTN2_DBL_EN = (1 << 4),
kD1815_BUTTON_DBL_BTN3_DBL_EN = (1 << 5),
kDIALOG_BUTTON_DBL_HOLD_DBL_EN = kD1815_BUTTON_DBL_BTN2_DBL_EN,
kDIALOG_BUTTON_DBL_MENU_DBL_EN = kD1815_BUTTON_DBL_BTN1_DBL_EN,
kDIALOG_BUTTON_DBL_RINGER_DBL_EN = kD1815_BUTTON_DBL_BTN3_DBL_EN,
};
#define NUM_LDOS 23
static const struct ldo_params ldo_1881[NUM_LDOS] = {
{ 2500, 50, 0x15, 0x1f, 0x1, kD1881_LDO1, kD1881_ACTIVE1, 0x20 }, // LDO1
{ 1650, 5, 0x1f, 0x1f, 0x0, kD1881_LDO2, kD1881_ACTIVE1, 0x40 }, // LDO2
{ 2500, 50, 0x10, 0x1f, 0x0, kD1881_LDO3, kD1881_ACTIVE1, 0x80 }, // LDO3
{ 1800, 50, 0x1e, 0x1f, 0x0, kD1881_LDO4, kD1881_ACTIVE2, 0x01 }, // LDO4
{ 2500, 50, 0x16, 0x1f, 0x0, kD1881_LDO5, kD1881_ACTIVE2, 0x02 }, // LDO5
{ 2500, 50, 0x16, 0x1f, 0x2, kD1881_LDO6, kD1881_ACTIVE2, 0x04 }, // LDO6
{ 1500, 100,0x16, 0x1f, 0x0, kD1881_LDO7, kD1881_ACTIVE2, 0x08 }, // LDO7
{ 2000, 50, 0x1f, 0x1f, 0x0, kD1881_LDO8, kD1881_ACTIVE2, 0x10 }, // LDO8
{ 1200, 100,0x12, 0x1f, 0x0, kD1881_LDO9, kD1881_ACTIVE2, 0x20 }, // LDO9
{ 2500, 50, 0x15, 0x1f, 0x4, kD1881_LDO10, kD1881_ACTIVE2, 0x40 }, // LDO10
{ 1700, 50, 0x1a, 0x1f, 0x0, kD1881_LDO11, kD1881_ACTIVE2, 0x80 }, // LDO11
{ 600, 25, 0x1c, 0x1f, 0x0, kD1881_LDO12, kD1881_ACTIVE3, 0x01 }, // LDO12
{ 5000, 50, 0x0a, 0x1f, 0x0, kD1881_LCM_CONTROL1, kD1881_ACTIVE3, 0x04 }, // LCM1_LDO
{ 5000, 50, 0x05, 0x1f, 0x0, kD1881_LCM_CONTROL2, kD1881_ACTIVE3, 0x08 }, // LCM2_LDO
{ 5000, 50, 0x00, 0x1f, 0x0, kD1881_LCM_CONTROL3, kD1881_ACTIVE3, 0x10 }, // LCM3_LDO
{ 5000, 50, 0x1f, 0x1f, 0x0, kD1881_LCM_BST_CONTROL, kD1881_ACTIVE3, 0x02 }, // LCM_BOOST
{ 0, 0, 0, 0, 0x0, 0, kD1881_ACTIVE3, 0x20 }, // 17 - WLED_BST_EN
{ 0, 0, 0, 0, 0x0, 0, kD1881_ACTIVE4, 0x10 }, // 18 - DSP_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1881_ACTIVE4, 0x20 }, // 19 - CPU1V2_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1881_ACTIVE4, 0x40 }, // 20 - WDIG_EN
{ 0, 0, 0, 0, 0x0, 0, kD1881_ACTIVE4, 0x80 }, // 21 - CPU1V8_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1881_HIBERNATE1, 0x20 }, // 22 - set LDO1_EN in HIB
{ 0, 0, 0, 0, 0x0, 0, kD1881_HIBERNATE2, 0x04 }, // 23 - set LDO6_EN in HIB
};
#define LDOP ldo_1881
drivers/dialog/pmu/d1946.h
+851
View File
@@ -0,0 +1,851 @@
#define PMU_HAS_SWI 0
#define PMU_HAS_DWI 1
#define PMU_HAS_REG_BANK 1
#define PMU_HAS_BIST_ADC 1
#define PMU_HAS_LCM_LDO 1
#define PMU_HAS_WLED 1
enum {
kDIALOG_ADDR_R = 0x79,
kDIALOG_ADDR_W = 0x78,
kDIALOG_REG_BYTES = 1,
};
enum {
kDIALOG_EVENT_COUNT = 9,
kDIALOG_STATUS_COUNT = 6,
kDIALOG_HIBERNATE_COUNT = 4,
kDIALOG_CHIPID_COUNT = 1,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_GPIO_COUNT = 18,
};
#include "dCommon.h"
enum {
kDIALOG_BANK_COUNT = 3,
kDIALOG_BANK0_SHARED_COUNT = 0x57,
};
enum {
kDIALOG_CHIP_ID = 0x00,
kDIALOG_EVENT_A = 0x01,
kDIALOG_EVENT_B = 0x02,
kDIALOG_EVENT_C = 0x03,
kDIALOG_EVENT_D = 0x04,
kDIALOG_EVENT_E = 0x05,
kDIALOG_EVENT_F = 0x06,
kDIALOG_EVENT_G = 0x07,
kDIALOG_EVENT_H = 0x08,
kDIALOG_EVENT_K = 0x09,
kDIALOG_STATUS_A = 0x0a,
kDIALOG_STATUS_B = 0x0b,
kDIALOG_STATUS_C = 0x0c,
kDIALOG_STATUS_D = 0x0d,
kDIALOG_STATUS_E = 0x0e,
kDIALOG_STATUS_F = 0x0f,
kDIALOG_STATUS_G = 0x10,
kDIALOG_STATUS_H = 0x11,
kDIALOG_IRQ_MASK_A = 0x12,
kDIALOG_IRQ_MASK_B = 0x13,
kDIALOG_IRQ_MASK_C = 0x14,
kDIALOG_IRQ_MASK_D = 0x15,
kDIALOG_IRQ_MASK_E = 0x16,
kDIALOG_IRQ_MASK_F = 0x17,
kDIALOG_IRQ_MASK_G = 0x18,
kDIALOG_IRQ_MASK_H = 0x19,
kDIALOG_IRQ_MASK_K = 0x1a,
kDIALOG_SYS_CONTROL = 0x1b,
kDIALOG_SYS_CONTROL2 = 0x1c,
kDIALOG_FAULT_LOG = 0x1d,
kDIALOG_BANKSEL = 0x1e,
kD1946_ACTIVE1 = 0x20,
kD1946_ACTIVE2 = 0x21,
kD1946_ACTIVE3 = 0x22,
kDIALOG_LCM_ACTIVE = kD1946_ACTIVE3,
kD1946_ACTIVE4 = 0x23,
kD1946_STANDBY1 = 0x24,
kDIALOG_STANDBY = kD1946_STANDBY1,
kD1946_HIBERNATE1 = 0x25,
kD1946_HIBERNATE2 = 0x26,
kD1946_HIBERNATE3 = 0x27,
kD1946_HIBERNATE4 = 0x28,
kD1946_BUCK0 = 0x29,
kDIALOG_BUCK0 = kD1946_BUCK0,
kD1946_BUCK1 = 0x2a,
kD1946_BUCK2 = 0x2b,
kDIALOG_BUCK2 = kD1946_BUCK2,
kD1946_BUCK3 = 0x2c,
kD1946_BUCK4 = 0x2d,
kD1946_BUCK5 = 0x2e,
kD1946_LDO1 = 0x2f,
kD1946_LDO2 = 0x30,
kD1946_LDO3 = 0x31,
kD1946_LDO4 = 0x32,
kD1946_LDO5 = 0x33,
kD1946_LDO6 = 0x34,
kD1946_LDO7 = 0x35,
kD1946_LDO8 = 0x36,
kD1946_LDO9 = 0x37,
kD1946_LDO10 = 0x38,
kD1946_LDO11 = 0x39,
kD1946_LDO12 = 0x3a,
kDIALOG_BUCK_DWI = 0x3b,
kDIALOG_CHARGE_BUCK_CONTROL = 0x3d,
kDIALOG_CHARGE_BUCK_CONTROL_B = 0x3e,
kDIALOG_CHARGE_CONTROL_A = 0x3f,
kDIALOG_CHARGE_CONTROL_B = 0x40,
kDIALOG_CHARGE_CONTROL_C = 0x41,
kDIALOG_CHARGE_TIME = 0x42,
kDIALOG_CHARGE_CONTROL_ICHG_BAT = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_HIB = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_TIME = kDIALOG_CHARGE_CONTROL_C,
kDIALOG_CHARGE_CONTROL_EN = kDIALOG_CHARGE_CONTROL_B,
kDIALOG_OTP_ISET_BAT = kDIALOG_CHARGE_CONTROL_A, // not a real OTP register
kDIALOG_ADC_CONTROL = 0x43,
kDIALOG_ADC_LSB = 0x44,
kDIALOG_ADC_MSB = 0x45,
kDIALOG_ICHG_AVG = 0x47,
kDIALOG_TBAT_0 = 0x4a,
kDIALOG_ICHG_TBAT_0 = 0x4b,
kDIALOG_TBAT_1 = 0x4c,
kDIALOG_ICHG_TBAT_1 = 0x4d,
kDIALOG_TBAT_2 = 0x4e,
kDIALOG_ICHG_TBAT_2 = 0x4f,
kDIALOG_TBAT_3 = 0x50,
kDIALOG_ICHG_TBAT_3 = 0x51,
kDIALOG_TBAT_4 = 0x52,
kDIALOG_ICHG_TBAT_4 = 0x53,
kDIALOG_TBAT_MAX = 0x54,
kDIALOG_ICHG_TBAT_NUM = 5,
kDIALOG_T_OFFSET_MSB = 0x55,
kDIALOG_T_OFFSET_LSB = 0x56,
kDIALOG_RTC_ALARM_A = 0x57,
kDIALOG_RTC_ALARM_B = 0x58,
kDIALOG_RTC_ALARM_C = 0x59,
kDIALOG_RTC_ALARM_D = 0x5a,
kDIALOG_RTC_CONTROL = 0x5b,
kDIALOG_RTC_TIMEZONE = 0x5c,
kDIALOG_UPCOUNT_A = 0x5d,
kDIALOG_UPCOUNT_B = 0x5e,
kDIALOG_UPCOUNT_C = 0x5f,
kDIALOG_UPCOUNT_D = 0x60,
kD1946_SYS_GPIO_1 = 0x61,
kDIALOG_SYS_GPIO_REG_START = kD1946_SYS_GPIO_1,
kD1946_SYS_GPIO_2 = 0x62,
kD1946_SYS_GPIO_3 = 0x63,
kD1946_SYS_GPIO_4 = 0x64,
kD1946_SYS_GPIO_5 = 0x65,
kD1946_SYS_GPIO_6 = 0x66,
kD1946_SYS_GPIO_7 = 0x67,
kD1946_SYS_GPIO_8 = 0x68,
kD1946_SYS_GPIO_9 = 0x69,
kD1946_SYS_GPIO_10 = 0x6a,
kD1946_SYS_GPIO_11 = 0x6b,
kD1946_SYS_GPIO_12 = 0x6c,
kD1946_SYS_GPIO_13 = 0x6d,
kD1946_SYS_GPIO_14 = 0x6e,
kD1946_SYS_GPIO_15 = 0x6f,
kD1946_SYS_GPIO_16 = 0x70,
kD1946_SYS_GPIO_17 = 0x71,
kD1946_SYS_GPIO_18 = 0x72,
kD1946_SYS_GPIO_DEB1 = 0x73,
kD1946_SYS_GPIO_DEB2 = 0x74,
kD1946_SYS_GPIO_DEB3 = 0x75,
kD1946_SYS_GPIO_DEB4 = 0x76,
kD1946_SYS_GPIO_DEB5 = 0x77,
kD1946_SYS_GPIO_DEB6 = 0x78,
kD1946_SYS_GPIO_DEB7 = 0x79,
kD1946_SYS_GPIO_DEB8 = 0x7a,
kD1946_SYS_GPIO_DEB9 = 0x7b,
kDIALOG_LDO_CONTROL = 0x7c,
kD1946_BUTTON1 = 0x7d,
kD1946_BUTTON2 = 0x7e,
kD1946_BUTTON3 = 0x7f,
kDIALOG_SYS_CONFIG = 0x80,
kD1946_LCM_CONTROL1 = 0x81,
kD1946_LCM_CONTROL2 = 0x82,
kD1946_LCM_CONTROL3 = 0x83,
kD1946_LCM_BST_CONTROL = 0x84,
kDIALOG_LCM_BOOST = kD1946_LCM_BST_CONTROL,
kD1946_BUCK3_HIB = 0x9a,
kD1946_BUCK4_HIB = 0x9b,
kD1946_GPIO_SOFTHIB1 = 0x9c,
kD1946_GPIO_SOFTHIB2 = 0x9d,
kD1946_GPIO_SOFTHIB3 = 0x9e,
kDIALOG_BUTTON_DBL = 0x9f,
kDIALOG_MEMBYTE0 = 0xa0,
kDIALOG_MEMBYTE_LAST = 0xc7,
kDIALOG_WLED_ISET = 0xd0,
kDIALOG_WLED_ISET2 = 0xd1,
kDIALOG_WLED_CONTROL = 0xd2,
kDIALOG_WLED_CONTROL2 = 0xd3,
kDIALOG_WLED_DWI_CONTROL = kDIALOG_WLED_CONTROL2,
kDIALOG_WLED_OPTIONS = kDIALOG_WLED_CONTROL2,
// Bank 1 Test Registers
kD1946_WLED_CONTROL5 = 0xa5,
kD1946_BUCK_CONTROL1 = 0xab,
kD1946_BUCK_CONTROL3 = 0xad,
// Bank 2 Test Registers
kD1946_TEST_MODE = 0xd0,
kDIALOG_APP_TMUX = 0x15c,
kDIALOG_BIST_ADC_CTRL = 0x15d,
kDIALOG_BIST_ADC_LSB = 0x15e,
kDIALOG_BIST_ADC_MSB = 0x15f,
};
enum {
kD1946_CHIP_ID_MRC_MASK = (0xf << 0),
kD1946_CHIP_ID_MRC_A0 = (0 << 0),
kD1946_CHIP_ID_MRC_A1 = (1 << 0),
};
enum {
kD1946_EVENT_A_BUTTON1 = (1 << 0),
kD1946_EVENT_A_BUTTON2 = (1 << 1),
kD1946_EVENT_A_BUTTON3 = (1 << 2),
kD1946_EVENT_A_VCENTER_DET = (1 << 3),
kD1946_EVENT_A_FW_DET = (1 << 4),
kD1946_EVENT_A_ACC_DET = (1 << 5),
kD1946_EVENT_A_VBUS_EXT_DET = (1 << 6),
kD1946_EVENT_A_VDD_LOW = (1 << 7),
};
// EVENT_B events are assumed volatile (lost over sleep/wake)
enum {
kD1946_EVENT_B_DWI_TO = (1 << 0),
kD1946_EVENT_B_CHG_PRE = (1 << 1),
kD1946_EVENT_B_CHG_FAST = (1 << 2),
kD1946_EVENT_B_CHG_END = (1 << 3),
kD1946_EVENT_B_TBAT = (1 << 4),
kD1946_EVENT_B_EOMC = (1 << 5),
kD1946_EVENT_B_FW_OV = (1 << 6),
kDIALOG_EVENT_B_HIB = (1 << 7),
};
enum {
kD1946_EVENT_C_GPIO1 = (1 << 0),
kD1946_EVENT_C_GPIO2 = (1 << 1),
kD1946_EVENT_C_GPIO3 = (1 << 2),
kD1946_EVENT_C_GPIO4 = (1 << 3),
kD1946_EVENT_C_GPIO5 = (1 << 4),
kD1946_EVENT_C_GPIO6 = (1 << 5),
kD1946_EVENT_C_GPIO7 = (1 << 6),
kD1946_EVENT_C_GPIO8 = (1 << 7),
};
enum {
kD1946_EVENT_D_GPIO9 = (1 << 0),
kD1946_EVENT_D_GPIO10 = (1 << 1),
kD1946_EVENT_D_GPIO11 = (1 << 2),
kD1946_EVENT_D_GPIO12 = (1 << 3),
kD1946_EVENT_D_GPIO13 = (1 << 4),
kD1946_EVENT_D_GPIO14 = (1 << 5),
kD1946_EVENT_D_GPIO15 = (1 << 6),
kD1946_EVENT_D_GPIO16 = (1 << 7),
};
enum {
kD1946_EVENT_E_GPIO17 = (1 << 0),
kD1946_EVENT_E_GPIO18 = (1 << 1),
kD1946_EVENT_E_ACC_B_DET = (1 << 2),
kD1946_EVENT_E_BTN1_DBL = (1 << 3),
kD1946_EVENT_E_BTN2_DBL = (1 << 4),
kD1946_EVENT_E_BTN3_DBL = (1 << 5),
kD1946_EVENT_E_CHG_BUCK_FLG = (1 << 6),
kD1946_EVENT_E_VBUS_OV = (1 << 7),
};
enum {
kD1946_EVENT_G_ALARM = (1 << 0),
kD1946_EVENT_G_FW_REM = (1 << 4),
kD1946_EVENT_G_VBUS_REM = (1 << 6),
};
enum {
kD1946_EVENT_K_VBUS_B_DET = (1 << 3),
kD1946_EVENT_K_CHG_BUCK_B_FLG = (1 << 5),
kD1946_EVENT_K_VBUS_B_EXT = (1 << 6),
kD1946_EVENT_K_VBUS_B_REM = (1 << 7),
};
enum {
kD1946_STATUS_A_BUTTON1 = (1 << 0),
kD1946_STATUS_A_BUTTON2 = (1 << 1),
kD1946_STATUS_A_BUTTON3 = (1 << 2),
kD1946_STATUS_A_VCENTER_DET = (1 << 3),
kD1946_STATUS_A_FW_DET = (1 << 4),
kD1946_STATUS_A_ACC_DET = (1 << 5),
kD1946_STATUS_A_VBUS_EXT_DET = (1 << 6),
kD1946_STATUS_A_VDD_LOW = (1 << 7),
};
enum {
kD1946_STATUS_B_CHG_ATT = (1 << 0),
kD1946_STATUS_B_CHG_PRE = (1 << 1),
kD1946_STATUS_B_CHG_FAST = (1 << 2),
kD1946_STATUS_B_CHG_END = (1 << 3),
kD1946_STATUS_B_TBAT = (1 << 4),
kD1946_STATUS_B_CHG_TO = (1 << 5),
kD1946_STATUS_B_FW_OV = (1 << 6),
};
enum {
kD1946_STATUS_C_GPIO1 = (1 << 0),
kD1946_STATUS_C_GPIO2 = (1 << 1),
kD1946_STATUS_C_GPIO3 = (1 << 2),
kD1946_STATUS_C_GPIO4 = (1 << 3),
kD1946_STATUS_C_GPIO5 = (1 << 4),
kD1946_STATUS_C_GPIO6 = (1 << 5),
kD1946_STATUS_C_GPIO7 = (1 << 6),
kD1946_STATUS_C_GPIO8 = (1 << 7),
};
enum {
kD1946_STATUS_D_GPIO9 = (1 << 0),
kD1946_STATUS_D_GPIO10 = (1 << 1),
kD1946_STATUS_D_GPIO11 = (1 << 2),
kD1946_STATUS_D_GPIO12 = (1 << 3),
kD1946_STATUS_D_GPIO13 = (1 << 4),
kD1946_STATUS_D_GPIO14 = (1 << 5),
kD1946_STATUS_D_GPIO15 = (1 << 6),
kD1946_STATUS_D_GPIO16 = (1 << 7),
};
enum {
kD1946_STATUS_E_GPIO17 = (1 << 0),
kD1946_STATUS_E_GPIO18 = (1 << 1),
kD1946_STATUS_E_ACC_B_DET = (1 << 2),
kD1946_STATUS_E_PROT_FET_ON = (1 << 3),
kD1946_STATUS_E_PROT_FET_B_ON = (1 << 5),
kD1946_STATUS_E_CHG_BUCK_FLG = (1 << 6),
kD1946_STATUS_E_VBUS_OV = (1 << 7),
};
enum {
kD1946_STATUS_H_CHG_B_ATT = (1 << 0),
kD1946_STATUS_H_VBUS_B_OV = (1 << 1),
kD1946_STATUS_H_VCENTER_B_DET = (1 << 3),
kD1946_STATUS_H_CHG_BUCK_B_FLG = (1 << 5),
kD1946_STATUS_H_VBUS_B_EXT_DET = (1 << 6),
};
enum {
kDIALOG_EVENT_HOLD_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1946_EVENT_A_BUTTON2),
kDIALOG_EVENT_MENU_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1946_EVENT_A_BUTTON1),
kDIALOG_EVENT_RINGER_BUTTON_MASK= EVENT_FLAG_MAKE(0, kD1946_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS = (kD1946_EVENT_A_BUTTON2 |
kD1946_EVENT_A_BUTTON1 |
kD1946_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS_MASK = EVENT_FLAG_MAKE(0, kDIALOG_EVENT_BUTTONS),
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_EVENT_HOLD_BUTTON_MASK,
kDIALOG_EVENT_ALARM_MASK = EVENT_FLAG_MAKE(6, kD1946_EVENT_G_ALARM),
kDIALOG_EVENT_ACC_DET_MASK = EVENT_FLAG_MAKE(0, kD1946_EVENT_A_ACC_DET),
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD1946_EVENT_A_VBUS_EXT_DET),
kDIALOG_EVENT_VHP_DET_MASK = EVENT_FLAG_MAKE(0, kD1946_STATUS_A_FW_DET),
kDIALOG_EVENT_VBUS_REM_MASK = EVENT_FLAG_MAKE(6, kD1946_EVENT_G_VBUS_REM),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(1, kD1946_EVENT_B_EOMC),
kDIALOG_EVENT_HIB_MASK = EVENT_FLAG_MAKE(1, kDIALOG_EVENT_B_HIB),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(1, kD1946_EVENT_B_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(1, kD1946_EVENT_B_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(2, kD1946_EVENT_C_GPIO8),
kDIALOG_EVENT_GPIO9_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO9),
kDIALOG_EVENT_GPIO10_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO10),
kDIALOG_EVENT_GPIO11_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO11),
kDIALOG_EVENT_GPIO12_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO12),
kDIALOG_EVENT_GPIO13_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO13),
kDIALOG_EVENT_GPIO14_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO14),
kDIALOG_EVENT_GPIO15_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO15),
kDIALOG_EVENT_GPIO16_MASK = EVENT_FLAG_MAKE(3, kD1946_EVENT_D_GPIO16),
kDIALOG_EVENT_GPIO17_MASK = EVENT_FLAG_MAKE(4, kD1946_EVENT_E_GPIO17),
kDIALOG_EVENT_GPIO18_MASK = EVENT_FLAG_MAKE(4, kD1946_EVENT_E_GPIO18),
kDIALOG_EVENT_HOLD_DBL_MASK = EVENT_FLAG_MAKE(4, kD1946_EVENT_E_BTN2_DBL),
kDIALOG_EVENT_MENU_DBL_MASK = EVENT_FLAG_MAKE(4, kD1946_EVENT_E_BTN1_DBL),
kDIALOG_EVENT_RINGER_DBL_MASK = EVENT_FLAG_MAKE(4, kD1946_EVENT_E_BTN3_DBL),
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD1946_STATUS_A_VCENTER_DET),
kDIALOG_STATUS_VBUS_MASK = STATUS_FLAG_MAKE(0, kD1946_STATUS_A_VBUS_EXT_DET),
kDIALOG_STATUS_FW_MASK = STATUS_FLAG_MAKE(0, kD1946_STATUS_A_FW_DET),
kDIALOG_STATUS_ACC_DET_MASK = STATUS_FLAG_MAKE(0, kD1946_STATUS_A_ACC_DET),
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(1, kD1946_STATUS_B_CHG_PRE | kD1946_STATUS_B_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(1, kD1946_STATUS_B_CHG_TO),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD1946_STATUS_B_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(1, kD1946_STATUS_B_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(1, kD1946_STATUS_B_CHG_ATT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(2 + ((gpio)/8), (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {kD1946_STATUS_A_FW_DET, 0, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD1946_STATUS_B_CHG_PRE | kD1946_STATUS_B_CHG_FAST, 0, 0, 0, 0};
enum {
kD1946_EVENT_A_WAKEMASK = (kD1946_EVENT_A_BUTTON1 |
kD1946_EVENT_A_BUTTON2 |
kD1946_EVENT_A_BUTTON3 |
kD1946_EVENT_A_VBUS_EXT_DET |
kD1946_STATUS_A_FW_DET |
kD1946_EVENT_A_ACC_DET),
kD1946_EVENT_B_WAKEMASK = 0,
kD1946_EVENT_C_WAKEMASK = 0,
kD1946_EVENT_D_WAKEMASK = 0,
kD1946_EVENT_E_WAKEMASK = 0,
kD1946_EVENT_F_WAKEMASK = 0,
kD1946_EVENT_G_WAKEMASK = (kD1946_EVENT_G_ALARM |
kD1946_EVENT_G_FW_REM |
kD1946_EVENT_G_VBUS_REM),
kD1946_EVENT_H_WAKEMASK = 0,
kD1946_EVENT_K_WAKEMASK = 0,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
~kD1946_EVENT_A_WAKEMASK,
~kD1946_EVENT_B_WAKEMASK,
~kD1946_EVENT_C_WAKEMASK,
~kD1946_EVENT_D_WAKEMASK,
~kD1946_EVENT_E_WAKEMASK,
~kD1946_EVENT_F_WAKEMASK,
~kD1946_EVENT_G_WAKEMASK,
~kD1946_EVENT_H_WAKEMASK,
~kD1946_EVENT_K_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD1946_EVENT_A_WAKEMASK & ~kDIALOG_EVENT_BUTTONS,
kD1946_EVENT_B_WAKEMASK,
kD1946_EVENT_C_WAKEMASK,
kD1946_EVENT_D_WAKEMASK,
kD1946_EVENT_E_WAKEMASK,
kD1946_EVENT_F_WAKEMASK,
kD1946_EVENT_G_WAKEMASK,
kD1946_EVENT_H_WAKEMASK,
kD1946_EVENT_K_WAKEMASK,
};
// All events that defer shutdown
static const eventRegisters kDialogEventRestartMask = {
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_HOLD_BUTTON_MASK, 0) | EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ACC_DET_MASK, 0),
0,
0,
0,
0,
0,
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ALARM_MASK, 6),
0,
0,
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD1946_EVENT_A_VBUS_EXT_DET | kD1946_EVENT_A_FW_DET | kD1946_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
0,
kD1946_EVENT_G_FW_REM | kD1946_EVENT_G_VBUS_REM,
0,
0,
};
static const eventRegisters kDialogEventUSBMask = {
// only include VCENTER_DET; VBUS can come and go while charger still usable
kD1946_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
0,
0,
0,
0,
};
static const eventRegisters kDialogEventFWMask = {
kD1946_EVENT_A_FW_DET,
0,
0,
0,
0,
0,
kD1946_EVENT_G_FW_REM,
0,
0,
};
// XXXKW
enum {
kDialogEventPwrsupplyCount = 5,
kDialogEventUSBCount = 1,
kDialogEventFWCount = 2,
};
enum {
kDIALOG_LCM_ACTIVE_BOOST_EN = (1 << 1),
kDIALOG_LCM_ACTIVE_MASK = (1 << 2) | (1 << 3) | (1 << 4),
};
enum {
kDIALOG_SYS_CONTROL_STANDBY = (1 << 0),
kDIALOG_SYS_CONTROL_HIBERNATE = (1 << 1),
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_SOFT_HIB = (1 << 3),
kDIALOG_SYS_CONTROL_HIB_CLK = (1 << 4),
kDIALOG_SYS_CONTROL_PRO_FET_DIS = (1 << 5),
kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND = (1 << 6),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND
| kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = kDIALOG_SYS_CONTROL_HIBERNATE,
};
enum {
kDIALOG_SYS_CONTROL2_DWI_EN = (1 << 0),
kDIALOG_SYS_CONTROL2_DWI_TEST_EN = (1 << 1),
kDIALOG_SYS_CONTROL2_HIB_32K = (1 << 4),
kDIALOG_SYS_CONTROL2_BAT_PWR_SUSPEND = (1 << 7),
};
enum {
kDIALOG_FAULT_LOG_WDOG = FAULTLOG_FLAG_MAKE(0, (1 << 6)),
kDIALOG_FAULT_LOG_RESET_IN_1 = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 4)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_BOOST = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_BUCK_DWI_BUCK0 = (1 << 0),
kDIALOG_BUCK_DWI_BUCK1 = (1 << 1),
kDIALOG_BUCK_DWI_BUCK2 = (1 << 2),
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MIN = 0x00,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x02,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x0a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_300 = 0x12,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_400 = 0x1a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x22,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_600 = 0x2a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_700 = 0x32,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_900 = 0x42,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_975 = 0x48,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x4a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1450 = 0x6e,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1500 = 0x72,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0x9a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2100 = 0xa2,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MAX = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0xff,
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_MIN = 75,
kDIALOG_CHARGE_BUCK_CONTROL_STEP_PER_100MA = 8,
kDIALOG_CHARGE_BUCK_CONTROL_MAX = 3262,
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3f,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_A_CHG_SUSP = (1 << 6),
kDIALOG_CHARGE_CONTROL_A_CHG_HIB = (1 << 7),
kDIALOG_CHARGE_CONTROL_CHG_HIB = kDIALOG_CHARGE_CONTROL_A_CHG_HIB,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 40,
kDIALOG_CHARGE_CONTROL_MAX = 2520,
};
enum {
kDIALOG_CHARGE_CONTROL_B_ALT_USB_DIS = (1 << 6),
kDIALOG_CHARGE_CONTROL_B_CHG_BUCK_EN = (1 << 7),
kDIALOG_CHARGE_BUCK_CONTROL_ISET_VBUS_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_B_CHG_BUCK_EN,
kDIALOG_CHARGE_CONTROL_ALT_USB_DIS = kDIALOG_CHARGE_CONTROL_B_ALT_USB_DIS,
kDIALOG_CHARGE_CONTROL_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_B_CHG_BUCK_EN,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0xF0,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x07,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0x1f << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0x0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = (0x1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (0x2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ACC_ID = (0x3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT = (0x5 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BRICK_ID = (0x6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN7 = (0x7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (0x8 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_IN = (0x9 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_NTC0 = (0xa << 0),
kDIALOG_ADC_CONTROL_MUX_NUM_NTC = 5,
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS_A = (15 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = kDIALOG_ADC_CONTROL_MUX_SEL_VBUS_A,
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_IN_OFF = (16 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT_OFF= (17 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK5_TEMP = (18 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LDO9_TEMP = (19 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_B_TEMP= (20 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CHG_TEMP = (21 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK0_TEMP = (22 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK2_TEMP = (23 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK3_TEMP = (24 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK4_TEMP = (25 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_A_TEMP= (26 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS_B = (27 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_START = kDIALOG_ADC_CONTROL_MUX_SEL_BUCK5_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_END = kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_A_TEMP,
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 5),
kDIALOG_ADC_CONTROL_ADC_REF_EN = (1 << 6),
kDIALOG_ADC_CONTROL_AUTO_VDD_OUT_EN = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 12,
kDIALOG_ADC_FULL_SCALE_MV = 2500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kDIALOG_BIST_ADC_CTRL_MUX_SEL_MASK = (0x3f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO1 = (0x00 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO1 = (0x01 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO2 = (0x02 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO2 = (0x03 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO3 = (0x04 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO3 = (0x05 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO4 = (0x06 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO4 = (0x07 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO5 = (0x08 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO5 = (0x09 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO6 = (0x0a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO6 = (0x0b << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO7 = (0x0c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO7 = (0x0d << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO8 = (0x0e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO8 = (0x0f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO9 = (0x10 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO9 = (0x11 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO10 = (0x12 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO10 = (0x13 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO11 = (0x14 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO11 = (0x15 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO12 = (0x16 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO12 = (0x17 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM1 = (0x18 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM1 = (0x19 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM2 = (0x1a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM2 = (0x1b << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM3 = (0x1c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM3 = (0x1d << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VRTC = (0x1e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IRTC = (0x1f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUF_ON = (0x20 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IBUF_ON = (0x21 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK0 = (0x22 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK1 = (0x24 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK2 = (0x26 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK3 = (0x28 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK4 = (0x2a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VOUT_LED = (0x2c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBOOST_LCM = (0x2e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_A = (0x30 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_B = (0x32 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK5 = (0x34 << 0),
kDIALOG_BIST_ADC_CTRL_AUTO_RUN = (1 << 6),
kDIALOG_BIST_ADC_CTRL_MAN_CONV = (1 << 7),
};
enum {
kDIALOG_APP_TMUX_SEL_MASK = (7 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_0 = (0 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_1 = (1 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_2 = (2 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_3 = (3 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_4 = (4 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_5 = (5 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_6 = (6 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_7 = (7 << 0),
KDIALOG_APP_TMUX_EN = (1 << 7),
};
enum {
kDIALOG_RTC_CONTROL_MONITOR = (1 << 0),
kDIALOG_RTC_CONTROL_ALARM_EN = (1 << 6),
};
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_INPUT_WAKE = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (7 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (0 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = (2 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (3 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (4 << 5),
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_MASK) \
< kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH)
enum {
kDIALOG_WLED_CONTROL_WLED_ENABLE1 = (1 << 0),
kDIALOG_WLED_CONTROL_WLED_ENABLE2 = (1 << 1),
kDIALOG_WLED_CONTROL_WLED_ENABLE3 = (1 << 2),
kDIALOG_WLED_CONTROL_WLED_ENABLE4 = (1 << 3),
kDIALOG_WLED_CONTROL_WLED_ENABLE5 = (1 << 4),
kDIALOG_WLED_CONTROL_WLED_ENABLE6 = (1 << 5),
};
enum {
kDIALOG_WLED_CONTROL2_WLED_RAMP_EN = (1 << 2),
kDIALOG_WLED_CONTROL2_WLED_DWI_EN = (1 << 3),
kDIALOG_WLED_CONTROL2_WLED_DITH_EN = (1 << 4),
kDIALOG_WLED_CONTROL2_WLED_DITH_RAMP_EN = (1 << 5),
kDIALOG_WLED_CONTROL_WLED_DWI_EN = kDIALOG_WLED_CONTROL2_WLED_DWI_EN,
kDIALOG_WLED_OPTIONS_DEFAULT = kDIALOG_WLED_CONTROL2_WLED_DITH_EN,
kDIALOG_WLED_OPTIONS_xWI_EN = kDIALOG_WLED_CONTROL2_WLED_DWI_EN,
kDIALOG_WLED_OPTIONS_MASK = (kDIALOG_WLED_CONTROL2_WLED_RAMP_EN|
kDIALOG_WLED_CONTROL2_WLED_DITH_EN|
kDIALOG_WLED_CONTROL2_WLED_DITH_RAMP_EN),
};
#define WLED_ISET_BITS (11)
#define NUM_LDOS 23
static const struct ldo_params ldo_1946[NUM_LDOS] = {
{ 2500, 50, 0x0a, 0x1f, 0x1, kD1946_LDO1, kD1946_ACTIVE1, 0x20 }, // LDO1
{ 1650, 5, 0x0a, 0x1f, 0x0, kD1946_LDO2, kD1946_ACTIVE1, 0x40 }, // LDO2
{ 2500, 50, 0x0a, 0x1f, 0x0, kD1946_LDO3, kD1946_ACTIVE1, 0x80 }, // LDO3
{ 1800, 50, 0x18, 0x1f, 0x0, kD1946_LDO4, kD1946_ACTIVE2, 0x01 }, // LDO4
{ 2500, 50, 0x0a, 0x1f, 0x0, kD1946_LDO5, kD1946_ACTIVE2, 0x02 }, // LDO5
{ 2500, 50, 0x10, 0x1f, 0x2, kD1946_LDO6, kD1946_ACTIVE2, 0x04 }, // LDO6
{ 1500, 100,0x0a, 0x1f, 0x0, kD1946_LDO7, kD1946_ACTIVE2, 0x08 }, // LDO7
{ 2000, 50, 0x16, 0x1f, 0x0, kD1946_LDO8, kD1946_ACTIVE2, 0x10 }, // LDO8
{ 1200, 100,0x00, 0x1f, 0x0, kD1946_LDO9, kD1946_ACTIVE2, 0x20 }, // LDO9
{ 2500, 50, 0x0a, 0x1f, 0x4, kD1946_LDO10, kD1946_ACTIVE2, 0x40 }, // LDO10
{ 1700, 50, 0x17, 0x1f, 0x0, kD1946_LDO11, kD1946_ACTIVE2, 0x80 }, // LDO11
{ 600, 25, 0x14, 0x1f, 0x0, kD1946_LDO12, kD1946_ACTIVE3, 0x01 }, // LDO12
{ 5000, 50, 0x0c, 0x1f, 0x0, kD1946_LCM_CONTROL1, kD1946_ACTIVE3, 0x04 }, // LCM1_LDO
{ 5000, 50, 0x05, 0x1f, 0x0, kD1946_LCM_CONTROL2, kD1946_ACTIVE3, 0x08 }, // LCM2_LDO
{ 5000, 50, 0x00, 0x1f, 0x0, kD1946_LCM_CONTROL3, kD1946_ACTIVE3, 0x10 }, // LCM3_LDO
{ 5000, 50, 0x1f, 0x1f, 0x0, kD1946_LCM_BST_CONTROL, kD1946_ACTIVE3, 0x02 }, // LCM_BOOST
{ 0, 0, 0, 0, 0x0, 0, kD1946_ACTIVE3, 0x20 }, // 17 - WLED_BST_EN
{ 0, 0, 0, 0, 0x0, 0, kD1946_ACTIVE4, 0x10 }, // 18 - DSP_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1946_ACTIVE4, 0x20 }, // 19 - CPU1V2_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1946_ACTIVE4, 0x40 }, // 20 - WDIG_EN
{ 0, 0, 0, 0, 0x0, 0, kD1946_ACTIVE4, 0x80 }, // 21 - CPU1V8_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1946_HIBERNATE1, 0x20 }, // 22 - set LDO1_EN in HIB
{ 0, 0, 0, 0, 0x0, 0, kD1946_HIBERNATE2, 0x04 }, // 23 - set LDO6_EN in HIB
};
#define LDOP ldo_1946
enum {
kDIALOG_SYS_CONFIG_WDOG_EN = (1 << 0),
kDIALOG_SYS_CONFIG_WDOG_MODE_100MS = (0 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_250MS = (1 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_500MS = (2 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_1000MS = (3 << 1),
kDIALOG_SYS_CONFIG_RESET_TIMER_MASK = (3 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_4S = (0 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_6S = (1 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_8S = (2 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_10S = (3 << 3),
kDIALOG_SYS_CONFIG_WDOG_ACTIVE = (1 << 5),
};
enum {
kDIALOG_BUTTON_DBL_CLICK_RATE_MASK = (7 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_50MS = (0 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_100MS = (1 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_150MS = (2 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_200MS = (3 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_250MS = (4 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_300MS = (5 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_350MS = (6 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_400MS = (7 << 0),
kD1946_BUTTON_DBL_BTN1_DBL_EN = (1 << 3),
kD1946_BUTTON_DBL_BTN2_DBL_EN = (1 << 4),
kD1946_BUTTON_DBL_BTN3_DBL_EN = (1 << 5),
kDIALOG_BUTTON_DBL_HOLD_DBL_EN = kD1946_BUTTON_DBL_BTN2_DBL_EN,
kDIALOG_BUTTON_DBL_MENU_DBL_EN = kD1946_BUTTON_DBL_BTN1_DBL_EN,
kDIALOG_BUTTON_DBL_RINGER_DBL_EN = kD1946_BUTTON_DBL_BTN3_DBL_EN,
};
drivers/dialog/pmu/d1972.h
+913
View File
@@ -0,0 +1,913 @@
/*
* Copyright (C) 2011 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*/
#ifndef __DIALOG_D1972_H
#define __DIALOG_D1972_H
#define PMU_HAS_SWI 0
#define PMU_HAS_DWI 1
#define PMU_HAS_LCM_LDO 1
#define PMU_HAS_REG_BANK 1
#define PMU_HAS_BIST_ADC 1
#define PMU_HAS_CHG_ABCC_FLAG 1
#define PMU_HAS_VIB 1
#define PMU_HAS_WLED 1
enum {
kDIALOG_ADDR_R = 0xe9,
kDIALOG_ADDR_W = 0xe8,
kDIALOG_REG_BYTES = 1,
};
enum {
kDIALOG_EVENT_COUNT = 9,
kDIALOG_STATUS_COUNT = 8,
kDIALOG_HIBERNATE_COUNT = 4,
kDIALOG_CHIPID_COUNT = 1,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_GPIO_COUNT = 12,
};
#include "dCommon.h"
enum {
kDIALOG_BANK_COUNT = 2,
kDIALOG_BANK0_SHARED_COUNT = 0x5e,
};
enum {
// Bank 0 registers
kDIALOG_CHIP_ID = 0x00,
kDIALOG_EVENT_A = 0x01,
kDIALOG_EVENT_B = 0x02,
kDIALOG_EVENT_C = 0x03,
kDIALOG_EVENT_D = 0x04,
kDIALOG_EVENT_E = 0x05,
kDIALOG_EVENT_F = 0x06,
kDIALOG_EVENT_G = 0x07,
kDIALOG_EVENT_H = 0x08,
kDIALOG_EVENT_I = 0x09,
kDIALOG_STATUS_A = 0x0a,
kDIALOG_STATUS_B = 0x0b,
kDIALOG_STATUS_C = 0x0c,
kDIALOG_STATUS_D = 0x0d,
kDIALOG_STATUS_E = 0x0e,
kDIALOG_STATUS_F = 0x0f,
kDIALOG_STATUS_G = 0x10,
kDIALOG_STATUS_H = 0x11,
kDIALOG_STATUS_GPIO_1_8 = kDIALOG_STATUS_C,
kDIALOG_STATUS_GPIO_9_16 = kDIALOG_STATUS_D,
kDIALOG_STATUS_GPIO_17_24 = 0,
kDIALOG_IRQ_MASK_A = 0x12,
kDIALOG_IRQ_MASK_B = 0x13,
kDIALOG_IRQ_MASK_C = 0x14,
kDIALOG_IRQ_MASK_D = 0x15,
kDIALOG_IRQ_MASK_E = 0x16,
kDIALOG_IRQ_MASK_F = 0x17,
kDIALOG_IRQ_MASK_G = 0x18,
kDIALOG_IRQ_MASK_H = 0x19,
kDIALOG_IRQ_MASK_I = 0x1a,
kDIALOG_SYS_CONTROL = 0x1b,
kDIALOG_SYS_CONTROL2 = 0x1c,
kDIALOG_FAULT_LOG = 0x1d,
kDIALOG_BANKSEL = 0x1e,
kD1972_ACTIVE1 = 0x20,
kD1972_ACTIVE2 = 0x21,
kD1972_ACTIVE3 = 0x22,
kDIALOG_LCM_ACTIVE = kD1972_ACTIVE3,
kD1972_ACTIVE4 = 0x23,
kD1972_STANDBY = 0x24,
kDIALOG_STANDBY = kD1972_STANDBY,
kD1972_HIBERNATE1 = 0x25,
kD1972_HIBERNATE2 = 0x26,
kD1972_HIBERNATE3 = 0x27,
kD1972_HIBERNATE4 = 0x28,
kD1972_BUCK0 = 0x29,
kDIALOG_BUCK0 = kD1972_BUCK0,
kD1972_BUCK2 = 0x2a,
kDIALOG_BUCK2 = kD1972_BUCK2,
kD1972_BUCK3 = 0x2b,
kD1972_BUCK4 = 0x2c,
kD1972_LDO1 = 0x2d,
kD1972_LDO2 = 0x2e,
kD1972_LDO3 = 0x2f,
kD1972_LDO4 = 0x30,
kD1972_LDO5 = 0x31,
kD1972_LDO6 = 0x32,
kD1972_LDO7 = 0x33,
kD1972_LDO8 = 0x34,
kD1972_LDO9 = 0x35,
kD1972_LDO10 = 0x36,
kD1972_LDO11 = 0x37,
kD1972_LDO12 = 0x38,
kD1972_LDO16 = 0x39,
kD1972_BUCK_CTRL1 = 0x3a,
kD1972_BUCK_CTRL2 = 0x3b,
kD1972_BUCK_CTRL3 = 0x3c,
kD1972_BUCK_CTRL4 = 0x3d,
kD1972_BUCK_CTRL5 = 0x3e,
kDIALOG_CHARGE_BUCK_CONTROL = 0x3f,
kDIALOG_CHARGE_BUCK_CONTROL_B = 0x40,
kDIALOG_CHARGE_BUCK_STATUS = 0x41,
kDIALOG_CHARGE_CONTROL_A = 0x42,
kDIALOG_CHARGE_CONTROL_B = 0x43,
kDIALOG_CHARGE_CONTROL_C = 0x44,
kDIALOG_CHARGE_STATUS = 0x45,
kDIALOG_CHARGE_CONTROL_D = 0x46,
kDIALOG_CHARGE_TIME = 0x47,
kDIALOG_CHARGE_CONTROL_ICHG_BAT = kDIALOG_CHARGE_CONTROL_B,
kDIALOG_CHARGE_CONTROL_HIB = kDIALOG_CHARGE_CONTROL_B,
kDIALOG_CHARGE_CONTROL_TIME = kDIALOG_CHARGE_CONTROL_D,
kDIALOG_CHARGE_CONTROL_EN = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_OTP_ISET_BAT = kDIALOG_CHARGE_CONTROL_B,
kDIALOG_ADC_CONTROL = 0x48,
kDIALOG_ADC_LSB = 0x49,
kDIALOG_ADC_MSB = 0x4a,
kDIALOG_ADC_TEMP_CTRL = 0x4b,
kDIALOG_ICHG_AVG = 0x4c,
kDIALOG_VCC_MAIN_MON = 0x4d,
kDIALOG_ICHG_END = 0x4e,
kDIALOG_TBAT_0 = 0x4f,
kDIALOG_ICHG_TBAT_0 = 0x50,
kDIALOG_TBAT_1 = 0x51,
kDIALOG_ICHG_TBAT_1 = 0x52,
kDIALOG_TBAT_2 = 0x53,
kDIALOG_ICHG_TBAT_2 = 0x54,
kDIALOG_TBAT_3 = 0x55,
kDIALOG_ICHG_TBAT_3 = 0x56,
kDIALOG_TBAT_4 = 0x57,
kDIALOG_ICHG_TBAT_4 = 0x58,
kDIALOG_TBAT_MAX = 0x59,
kDIALOG_ICHG_TBAT_NUM = 5,
kDIALOG_T_OFFSET_MSB = 0x5A,
kDIALOG_T_OFFSET_LSB = 0x5B,
kD1972_IBUSCAL1 = 0x5c,
kD1972_IBUSCAL2 = 0x5d,
kDIALOG_RTC_ALARM_A = 0x5e,
kDIALOG_RTC_ALARM_B = 0x5f,
kDIALOG_RTC_ALARM_C = 0x60,
kDIALOG_RTC_ALARM_D = 0x61,
kDIALOG_RTC_CONTROL = 0x62,
kDIALOG_RTC_TIMEZONE = 0x63,
kDIALOG_UPCOUNT_A = 0x64,
kDIALOG_UPCOUNT_B = 0x65,
kDIALOG_UPCOUNT_C = 0x66,
kDIALOG_UPCOUNT_D = 0x67,
kD1972_SYS_GPIO_1 = 0x68,
kDIALOG_SYS_GPIO_REG_START = kD1972_SYS_GPIO_1,
kD1972_SYS_GPIO_2 = 0x69,
kD1972_SYS_GPIO_3 = 0x6a,
kD1972_SYS_GPIO_4 = 0x6b,
kD1972_SYS_GPIO_5 = 0x6c,
kD1972_SYS_GPIO_6 = 0x6d,
kD1972_SYS_GPIO_7 = 0x6e,
kD1972_SYS_GPIO_8 = 0x6f,
kD1972_SYS_GPIO_9 = 0x70,
kD1972_SYS_GPIO_10 = 0x71,
kD1972_SYS_GPIO_11 = 0x72,
kD1972_SYS_GPIO_12 = 0x73,
kD1972_SYS_GPIO_DEB1 = 0x74,
kD1972_SYS_GPIO_DEB2 = 0x75,
kD1972_SYS_GPIO_DEB3 = 0x76,
kD1972_SYS_GPIO_DEB4 = 0x77,
kD1972_SYS_GPIO_DEB5 = 0x78,
kD1972_SYS_GPIO_DEB6 = 0x79,
kDIALOG_LDO_CONTROL = 0x7a,
kDIALOG_WLED_ISET = 0x7b,
kDIALOG_WLED_ISET2 = 0x7c,
kDIALOG_WLED_CONTROL = 0x7d,
kDIALOG_WLED_CONTROL2 = 0x7e,
kDIALOG_WLED_DWI_CONTROL = kDIALOG_WLED_CONTROL,
kDIALOG_WLED_OPTIONS = kDIALOG_WLED_CONTROL,
kD1972_LCM_CONTROL1 = 0x7f,
kD1972_LCM_CONTROL2 = 0x80,
kD1972_LCM_CONTROL3 = 0x81,
kD1972_LCM_BST_CONTROL = 0x82,
kDIALOG_LCM_BOOST = kD1972_LCM_BST_CONTROL,
kDIALOG_VIB_CTRL = 0x83,
kDIALOG_VIB_VSET = 0x84,
kD1972_TDEV1_RISE = 0x85,
kD1972_TDEV1_FALL = 0x86,
kD1972_TDEV2_RISE = 0x87,
kD1972_TDEV2_FALL = 0x88,
kD1972_TDEV3_RISE = 0x89,
kD1972_TDEV3_FALL = 0x8a,
kD1972_TDEV4_RISE = 0x8b,
kD1972_TDEV4_FALL = 0x8c,
kD1972_TLDO5_RISE = 0x8d,
kD1972_TLDO16_RISE = 0x8e,
kD1972_TVCENTER_RISE = 0x8f,
kD1972_TLINCHG_RISE = 0x90,
kD1972_TBUCK0_RISE = 0x91,
kD1972_TBUCK2_RISE = 0x92,
kD1972_TBUCK3_RISE = 0x93,
kD1972_TBUCK4_RISE = 0x94,
kD1972_TISENSE_HYSE = 0x95,
kD1972_BUTTON1 = 0x96,
kD1972_BUTTON2 = 0x97,
kD1972_BUTTON3 = 0x98,
kDIALOG_SYS_CONFIG = 0x99,
kD1972_BUCK3_ALT = 0x9a,
kD1972_BUCK4_ALT = 0x9b,
kD1972_GPIO_SOFTHIB1 = 0x9c,
kD1972_GPIO_SOFTHIB2 = 0x9d,
kDIALOG_BUTTON_DBL = 0x9e,
kDIALOG_MEMBYTE0 = 0xa1,
kDIALOG_MEMBYTE_LAST = 0xc8,
kD1972_TEST_MODE = 0xdc,
kDIALOG_APP_TMUX = 0x15e,
kDIALOG_BIST_ADC_CTRL = 0x15f,
kDIALOG_BIST_ADC_LSB = 0x160,
kDIALOG_BIST_ADC_MSB = 0x161,
};
enum {
kD1972_CHIP_ID_MRC_MASK = (0xf << 0),
kD1972_CHIP_ID_MRC_A0 = (0 << 0),
kD1972_CHIP_ID_MRC_A1 = (1 << 0),
};
enum {
kD1972_EVENT_A_BUTTON1 = (1 << 0),
kD1972_EVENT_A_BUTTON2 = (1 << 1),
kD1972_EVENT_A_BUTTON3 = (1 << 2),
kD1972_EVENT_A_VCENTER_DET = (1 << 3),
kD1972_EVENT_A_FW_DET = (1 << 4),
kD1972_EVENT_A_ACC_DET = (1 << 5),
kD1972_EVENT_A_VBUS_EXT_DET = (1 << 6),
kD1972_EVENT_A_VDD_LOW = (1 << 7),
};
// EVENT_B events are assumed volatile (lost over sleep/wake)
enum {
kD1972_EVENT_B_DWI_TO = (1 << 0),
kD1972_EVENT_B_CHG_PRE = (1 << 1),
kD1972_EVENT_B_CHG_FAST = (1 << 2),
kD1972_EVENT_B_CHG_END = (1 << 3),
kD1972_EVENT_B_TBAT = (1 << 4),
kD1972_EVENT_B_EOMC = (1 << 5),
kD1972_EVENT_B_FW_OV = (1 << 6),
kDIALOG_EVENT_B_HIB = (1 << 7),
};
enum {
kD1972_EVENT_C_GPIO1 = (1 << 0),
kD1972_EVENT_C_GPIO2 = (1 << 1),
kD1972_EVENT_C_GPIO3 = (1 << 2),
kD1972_EVENT_C_GPIO4 = (1 << 3),
kD1972_EVENT_C_GPIO5 = (1 << 4),
kD1972_EVENT_C_GPIO6 = (1 << 5),
kD1972_EVENT_C_GPIO7 = (1 << 6),
kD1972_EVENT_C_GPIO8 = (1 << 7),
};
enum {
kD1972_EVENT_D_GPIO9 = (1 << 0),
kD1972_EVENT_D_GPIO10 = (1 << 1),
kD1972_EVENT_D_GPIO11 = (1 << 2),
kD1972_EVENT_D_GPIO12 = (1 << 3),
kD1972_EVENT_D_DPHP = (1 << 4),
kD1972_EVENT_D_CHG_ABCC_ACT = (1 << 5),
kD1972_EVENT_D_CHG_BUCK_FLG = (1 << 6),
kD1972_EVENT_D_VBUS_OV = (1 << 7),
};
enum {
kD1972_EVENT_E_TDEV1_FALL = (1 << 0),
kD1972_EVENT_E_TDEV1_RISE = (1 << 1),
kD1972_EVENT_E_TDEV2_FALL = (1 << 2),
kD1972_EVENT_E_TDEV2_RISE = (1 << 3),
kD1972_EVENT_E_TDEV3_FALL = (1 << 4),
kD1972_EVENT_E_TDEV3_RISE = (1 << 5),
kD1972_EVENT_E_TDEV4_FALL = (1 << 6),
kD1972_EVENT_E_TDEV4_RISE = (1 << 7),
};
enum {
kD1972_EVENT_F_ALARM = (1 << 0),
kD1972_EVENT_F_LDO1_OC = (1 << 1),
kD1972_EVENT_F_LDO5_OC = (1 << 2),
kD1972_EVENT_F_LDO6_OC = (1 << 3),
kD1972_EVENT_F_FW_DPHP_REM = (1 << 4),
kD1972_EVENT_F_LDO10_OC = (1 << 5),
kD1972_EVENT_F_VBUS_EXT_REM = (1 << 6),
kD1972_EVENT_F_VBUS_OC = (1 << 7),
};
enum {
kD1972_EVENT_G_TLDO5 = (1 << 0),
kD1972_EVENT_G_TLDO16 = (1 << 1),
kD1972_EVENT_G_TVCENTER = (1 << 2),
kD1972_EVENT_G_TLINCHG = (1 << 3),
kD1972_EVENT_G_TBUCK0 = (1 << 4),
kD1972_EVENT_G_TBUCK2 = (1 << 5),
kD1972_EVENT_G_TBUCK3 = (1 << 6),
kD1972_EVENT_G_TBUCK4 = (1 << 7),
};
enum {
kD1972_EVENT_H_EOMC_BIST = (1 << 0),
};
enum {
kD1972_EVENT_I_BTN1_DBL = (1 << 3),
kD1972_EVENT_I_BTN2_DBL = (1 << 4),
kD1972_EVENT_I_BTN3_DBL = (1 << 5),
};
enum {
kD1972_STATUS_A_BUTTON1 = (1 << 0),
kD1972_STATUS_A_BUTTON2 = (1 << 1),
kD1972_STATUS_A_BUTTON3 = (1 << 2),
kD1972_STATUS_A_VCENTER_DET = (1 << 3),
kD1972_STATUS_A_FW_DPHP_DET = (1 << 4),
kD1972_STATUS_A_ACC_DET = (1 << 5),
kD1972_STATUS_A_VBUS_EXT_DET = (1 << 6),
kD1972_STATUS_A_VDD_LOW = (1 << 7),
};
enum {
kD1972_STATUS_B_CHG_PRE = (1 << 1),
kD1972_STATUS_B_CHG_FAST = (1 << 2),
kD1972_STATUS_B_CHG_END = (1 << 3),
kD1972_STATUS_B_TBAT = (1 << 4),
kD1972_STATUS_B_FW_OV = (1 << 6),
};
enum {
kD1972_STATUS_C_GPIO1 = (1 << 0),
kD1972_STATUS_C_GPIO2 = (1 << 1),
kD1972_STATUS_C_GPIO3 = (1 << 2),
kD1972_STATUS_C_GPIO4 = (1 << 3),
kD1972_STATUS_C_GPIO5 = (1 << 4),
kD1972_STATUS_C_GPIO6 = (1 << 5),
kD1972_STATUS_C_GPIO7 = (1 << 6),
kD1972_STATUS_C_GPIO8 = (1 << 7),
};
enum {
kD1972_STATUS_D_GPIO9 = (1 << 0),
kD1972_STATUS_D_GPIO10 = (1 << 1),
kD1972_STATUS_D_GPIO11 = (1 << 2),
kD1972_STATUS_D_GPIO12 = (1 << 3),
kD1972_STATUS_D_DPHP = (1 << 4),
kD1972_STATUS_D_CHG_ABCC_ACT = (1 << 5),
kD1972_STATUS_D_CHG_BUCK_FLG = (1 << 6),
kD1972_STATUS_D_VBUS_OV = (1 << 7),
};
enum {
kD1972_STATUS_E_TDEV1_FALL = (1 << 0),
kD1972_STATUS_E_TDEV1_RISE = (1 << 1),
kD1972_STATUS_E_TDEV2_FALL = (1 << 2),
kD1972_STATUS_E_TDEV2_RISE = (1 << 3),
kD1972_STATUS_E_TDEV3_FALL = (1 << 4),
kD1972_STATUS_E_TDEV3_RISE = (1 << 5),
kD1972_STATUS_E_TDEV4_FALL = (1 << 6),
kD1972_STATUS_E_TDEV4_RISE = (1 << 7),
};
enum {
kD1972_STATUS_F_CHG_ATT = (1 << 0),
kD1972_STATUS_F_CPUA_EN_STAT = (1 << 1),
kD1972_STATUS_F_CPUB_EN_STAT = (1 << 2),
kD1972_STATUS_F_PROT_FET_ON = (1 << 3),
kD1972_STATUS_F_CHG_TO = (1 << 5),
kD1972_STATUS_F_VBUS_OC = (1 << 7),
};
enum {
kD1972_STATUS_G_TLDO5 = (1 << 0),
kD1972_STATUS_G_TLDO16 = (1 << 1),
kD1972_STATUS_G_TVCENTER = (1 << 2),
kD1972_STATUS_G_TLINCHG = (1 << 3),
kD1972_STATUS_G_TBUCK0 = (1 << 4),
kD1972_STATUS_G_TBUCK2 = (1 << 5),
kD1972_STATUS_G_TBUCK3 = (1 << 6),
kD1972_STATUS_G_TBUCK4 = (1 << 7),
};
enum {
kDIALOG_EVENT_HOLD_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1972_EVENT_A_BUTTON2),
kDIALOG_EVENT_MENU_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1972_EVENT_A_BUTTON1),
kDIALOG_EVENT_RINGER_BUTTON_MASK= EVENT_FLAG_MAKE(0, kD1972_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS = (kD1972_EVENT_A_BUTTON2 |
kD1972_EVENT_A_BUTTON1 |
kD1972_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS_MASK = EVENT_FLAG_MAKE(0, kDIALOG_EVENT_BUTTONS),
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_EVENT_HOLD_BUTTON_MASK,
kDIALOG_EVENT_ALARM_MASK = EVENT_FLAG_MAKE(5, kD1972_EVENT_F_ALARM),
kDIALOG_EVENT_ACC_DET_MASK = EVENT_FLAG_MAKE(0, kD1972_EVENT_A_ACC_DET),
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD1972_EVENT_A_VBUS_EXT_DET),
kDIALOG_EVENT_VHP_DET_MASK = EVENT_FLAG_MAKE(0, kD1972_EVENT_A_FW_DET),
kDIALOG_EVENT_VBUS_EXT_REM_MASK = EVENT_FLAG_MAKE(5, kD1972_EVENT_F_VBUS_EXT_REM),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(1, kD1972_EVENT_B_EOMC),
kDIALOG_EVENT_HIB_MASK = EVENT_FLAG_MAKE(1, kDIALOG_EVENT_B_HIB),
kDIALOG_EVENT_ABCC_MASK = EVENT_FLAG_MAKE(3, kD1972_EVENT_D_CHG_ABCC_ACT),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(1, kD1972_EVENT_B_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(1, kD1972_EVENT_B_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(2, kD1972_EVENT_C_GPIO8),
kDIALOG_EVENT_GPIO9_MASK = EVENT_FLAG_MAKE(3, kD1972_EVENT_D_GPIO9),
kDIALOG_EVENT_GPIO10_MASK = EVENT_FLAG_MAKE(3, kD1972_EVENT_D_GPIO10),
kDIALOG_EVENT_GPIO11_MASK = EVENT_FLAG_MAKE(3, kD1972_EVENT_D_GPIO11),
kDIALOG_EVENT_GPIO12_MASK = EVENT_FLAG_MAKE(3, kD1972_EVENT_D_GPIO12),
kDIALOG_EVENT_HOLD_DBL_MASK = EVENT_FLAG_MAKE(8, kD1972_EVENT_I_BTN2_DBL),
kDIALOG_EVENT_MENU_DBL_MASK = EVENT_FLAG_MAKE(8, kD1972_EVENT_I_BTN1_DBL),
kDIALOG_EVENT_RINGER_DBL_MASK = EVENT_FLAG_MAKE(8, kD1972_EVENT_I_BTN3_DBL),
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO13_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO14_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO15_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO16_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO17_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO18_MASK = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD1972_STATUS_A_VCENTER_DET),
kDIALOG_STATUS_VBUS_MASK = STATUS_FLAG_MAKE(0, kD1972_STATUS_A_VBUS_EXT_DET),
kDIALOG_STATUS_FW_MASK = STATUS_FLAG_MAKE(0, kD1972_STATUS_A_FW_DPHP_DET),
kDIALOG_STATUS_ACC_DET_MASK = STATUS_FLAG_MAKE(0, kD1972_STATUS_A_ACC_DET),
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(1, kD1972_STATUS_B_CHG_PRE | kD1972_STATUS_B_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(5, kD1972_STATUS_F_CHG_TO),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD1972_STATUS_B_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(1, kD1972_STATUS_B_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(5, kD1972_STATUS_F_CHG_ATT),
kDIALOG_STATUS_ABCC_MASK = STATUS_FLAG_MAKE(3, kD1972_STATUS_D_CHG_ABCC_ACT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(2 + ((gpio)/8), (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {kD1972_STATUS_A_FW_DPHP_DET, 0, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD1972_STATUS_B_CHG_PRE | kD1972_STATUS_B_CHG_FAST, 0, 0, 0, 0};
enum {
kD1972_EVENT_A_WAKEMASK = (kD1972_EVENT_A_BUTTON1 |
kD1972_EVENT_A_BUTTON2 |
kD1972_EVENT_A_BUTTON3 |
kD1972_EVENT_A_VBUS_EXT_DET |
kD1972_STATUS_A_FW_DPHP_DET |
kD1972_EVENT_A_ACC_DET),
kD1972_EVENT_B_WAKEMASK = 0,
kD1972_EVENT_C_WAKEMASK = 0,
kD1972_EVENT_D_WAKEMASK = 0,
kD1972_EVENT_E_WAKEMASK = 0,
kD1972_EVENT_F_WAKEMASK = (kD1972_EVENT_F_ALARM |
kD1972_EVENT_F_FW_DPHP_REM |
kD1972_EVENT_F_VBUS_EXT_REM),
kD1972_EVENT_G_WAKEMASK = 0,
kD1972_EVENT_H_WAKEMASK = 0,
kD1972_EVENT_I_WAKEMASK = 0,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
~kD1972_EVENT_A_WAKEMASK,
~kD1972_EVENT_B_WAKEMASK,
~kD1972_EVENT_C_WAKEMASK,
~kD1972_EVENT_D_WAKEMASK,
~kD1972_EVENT_E_WAKEMASK,
~kD1972_EVENT_F_WAKEMASK,
~kD1972_EVENT_G_WAKEMASK,
~kD1972_EVENT_H_WAKEMASK,
~kD1972_EVENT_I_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD1972_EVENT_A_WAKEMASK & ~kDIALOG_EVENT_BUTTONS,
kD1972_EVENT_B_WAKEMASK,
kD1972_EVENT_C_WAKEMASK,
kD1972_EVENT_D_WAKEMASK,
kD1972_EVENT_E_WAKEMASK,
kD1972_EVENT_F_WAKEMASK,
kD1972_EVENT_G_WAKEMASK,
kD1972_EVENT_H_WAKEMASK,
kD1972_EVENT_I_WAKEMASK,
};
// All events that defer shutdown
static const eventRegisters kDialogEventRestartMask = {
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_HOLD_BUTTON_MASK, 0) | EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ACC_DET_MASK, 0),
0,
0,
0,
0,
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ALARM_MASK, 5),
0,
0,
0,
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD1972_EVENT_A_VBUS_EXT_DET | kD1972_EVENT_A_FW_DET | kD1972_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
kD1972_EVENT_F_FW_DPHP_REM | kD1972_EVENT_F_VBUS_EXT_REM,
0,
0,
0,
};
static const eventRegisters kDialogEventUSBMask = {
// only include VCENTER_DET; VBUS can come and go while charger still usable
kD1972_EVENT_A_VCENTER_DET,
0,
0,
kD1972_EVENT_D_CHG_ABCC_ACT,
0,
0,
0,
0,
0,
};
static const eventRegisters kDialogEventFWMask = {
kD1972_EVENT_A_FW_DET,
0,
0,
0,
0,
kD1972_EVENT_F_FW_DPHP_REM,
0,
0,
0,
};
enum {
kDialogEventPwrsupplyCount = 5,
kDialogEventUSBCount = 2,
kDialogEventFWCount = 2,
};
enum {
kDIALOG_LCM_ACTIVE_BOOST_EN = (1 << 6),
kDIALOG_LCM_ACTIVE_MASK = (1 << 2) | (1 << 3) | (1 << 4),
};
enum {
kDIALOG_SYS_CONTROL_STANDBY = (1 << 0),
kDIALOG_SYS_CONTROL_HIBERNATE = (1 << 1),
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_SOFT_HIB = (1 << 3),
kDIALOG_SYS_CONTROL_HIB_CLK = (1 << 4),
kDIALOG_SYS_CONTROL_PRO_FET_DIS = (1 << 5),
kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND = (1 << 6),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND
| kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = kDIALOG_SYS_CONTROL_HIBERNATE,
};
enum {
kDIALOG_SYS_CONTROL2_DWI_EN = (1 << 0),
kDIALOG_SYS_CONTROL2_DWI_TEST_EN = (1 << 1),
kDIALOG_SYS_CONTROL2_HIB_32K = (1 << 4),
};
enum {
kDIALOG_FAULT_LOG_WDOG = FAULTLOG_FLAG_MAKE(0, (1 << 6)),
kDIALOG_FAULT_LOG_RESET_IN_1 = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 4)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_BOOST = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_BUCK_CONTROL_DWI_EN = (1 << 4),
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MIN = 0x00,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x03,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x0d,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x2b,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x5d,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0xc1,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MAX = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0xff,
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_MIN = 70,
kDIALOG_CHARGE_BUCK_CONTROL_STEP_PER_100MA = 10,
kDIALOG_CHARGE_BUCK_CONTROL_MAX = 2620,
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3f,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_B_CHG_SUSP = (1 << 6),
kDIALOG_CHARGE_CONTROL_B_CHG_HIB = (1 << 7),
kDIALOG_CHARGE_CONTROL_CHG_HIB = kDIALOG_CHARGE_CONTROL_B_CHG_HIB,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 30,
kDIALOG_CHARGE_CONTROL_MAX = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK * kDIALOG_CHARGE_CONTROL_STEP,
};
enum {
kDIALOG_CHARGE_CONTROL_C_ALT_USB_DIS = (1 << 6),
kDIALOG_CHARGE_CONTROL_C_CHG_BUCK_EN = (1 << 7),
kDIALOG_CHARGE_CONTROL_ALT_USB_DIS = kDIALOG_CHARGE_CONTROL_C_ALT_USB_DIS,
kDIALOG_CHARGE_CONTROL_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_C_CHG_BUCK_EN,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_VBUS_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_C_CHG_BUCK_EN,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0xF0,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x07,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0x1f << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0x0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = (0x1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (0x2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ACC_ID = (0x3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_LG = (0x5 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BRICK_ID = (0x6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN7 = (0x7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (0x8 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_HG = (0x9 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VIBUS = kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_HG,
kDIALOG_ADC_CONTROL_MUX_SEL_NTC0 = (0xa << 0),
kDIALOG_ADC_CONTROL_MUX_NUM_NTC = 5,
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = (0xf << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_HG_OFF = (16 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN__LG_OFF = (17 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LDO5_TEMP = (18 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LDO16_TEMP = (19 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VCENTER_TEMP = (20 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CHG_TEMP = (21 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK0_TEMP = (22 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK2_TEMP = (23 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK3_TEMP = (24 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK4_TEMP = (25 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_START = kDIALOG_ADC_CONTROL_MUX_SEL_LDO5_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_END = kDIALOG_ADC_CONTROL_MUX_SEL_BUCK4_TEMP,
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 5),
kDIALOG_ADC_CONTROL_ADC_REF_EN = (1 << 6),
kDIALOG_ADC_CONTROL_AUTO_VDD_OUT_EN = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 12,
kDIALOG_ADC_FULL_SCALE_MV = 2500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kDIALOG_BIST_ADC_CTRL_MUX_SEL_MASK = (0x3f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO1 = (0 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO1 = (1 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO2 = (2 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO2 = (3 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO3 = (4 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO3 = (5 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO4 = (6 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO4 = (7 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO5 = (8 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO5 = (9 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO6 = (10 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO6 = (11 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO7 = (12 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO7 = (13 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO8 = (14 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO8 = (15 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO9 = (16 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO9 = (17 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO10 = (18 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO10 = (19 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO11 = (20 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO11 = (21 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO12 = (22 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO12 = (23 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM1 = (24 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM1 = (25 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM2 = (26 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM2 = (27 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM3 = (28 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM3 = (29 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO16 = (30 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO16 = (31 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VRTC = (32 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IRTC = (33 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUF_ON = (34 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IBUF_ON = (35 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK0A = (36 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK0B = (38 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK0C = (40 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK2 = (42 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK3 = (44 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK4 = (46 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_CPUA_SW_S = (48 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_CPUB_SW_S = (50 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VOUT_LED = (52 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBOOST_LCM = (54 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_A = (56 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_B = (58 << 0),
kDIALOG_BIST_ADC_CTRL_AUTO_RUN = (1 << 6),
kDIALOG_BIST_ADC_CTRL_MAN_CONV = (1 << 7),
};
enum {
kDIALOG_APP_TMUX_SEL_MASK = (7 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_0 = (0 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_1 = (1 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_2 = (2 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_3 = (3 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_4 = (4 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_5 = (5 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_6 = (6 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_7 = (7 << 0),
KDIALOG_APP_TMUX_EN = (1 << 7),
};
enum {
kDIALOG_RTC_CONTROL_MONITOR = (1 << 0),
kDIALOG_RTC_CONTROL_ALARM_EN = (1 << 6),
};
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_INPUT_WAKE = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (7 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (0 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = (2 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (3 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (4 << 5),
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_MASK) \
< kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH)
enum {
kDIALOG_WLED_CONTROL_WLED_ENABLE1 = (1 << 0),
kDIALOG_WLED_CONTROL_WLED_ENABLE2 = (1 << 1),
kDIALOG_WLED_CONTROL_WLED_RAMP_EN = (1 << 2),
kDIALOG_WLED_CONTROL_WLED_DWI_EN = (1 << 3),
kDIALOG_WLED_CONTROL_WLED_DITH_EN = (1 << 4),
kDIALOG_WLED_CONTROL_WLED_DITH_RAMP_EN = (1 << 5),
kDIALOG_WLED_OPTIONS_DEFAULT = kDIALOG_WLED_CONTROL_WLED_DITH_EN,
kDIALOG_WLED_OPTIONS_xWI_EN = kDIALOG_WLED_CONTROL_WLED_DWI_EN,
kDIALOG_WLED_OPTIONS_MASK = (kDIALOG_WLED_CONTROL_WLED_RAMP_EN|
kDIALOG_WLED_CONTROL_WLED_DITH_EN|
kDIALOG_WLED_CONTROL_WLED_DITH_RAMP_EN),
};
#define WLED_ISET_BITS (11)
#define NUM_LDOS 23
static const struct ldo_params ldo_1972[NUM_LDOS] = {
{ 2500, 50, 0x15, 0x1f, 0x1, kD1972_LDO1, kD1972_ACTIVE1, 0x40 }, // LDO1
// LDO2 is funny and has a gap from 1.335V to 1.65V, only supporting the top part
{ 1490, 5, 0x3f, 0x3f, 0x0, kD1972_LDO2, kD1972_ACTIVE1, 0x80 }, // LDO2
{ 2500, 50, 0x10, 0x1f, 0x0, kD1972_LDO3, kD1972_ACTIVE2, 0x01 }, // LDO3
{ 1800, 50, 0x1e, 0x1f, 0x0, kD1972_LDO4, kD1972_ACTIVE2, 0x02 }, // LDO4
{ 2500, 50, 0x16, 0x1f, 0x0, kD1972_LDO5, kD1972_ACTIVE2, 0x04 }, // LDO5
{ 2500, 50, 0x16, 0x1f, 0x2, kD1972_LDO6, kD1972_ACTIVE2, 0x08 }, // LDO6
{ 1500, 100,0x16, 0x1f, 0x0, kD1972_LDO7, kD1972_ACTIVE2, 0x10 }, // LDO7
{ 2000, 50, 0x1f, 0x1f, 0x0, kD1972_LDO8, kD1972_ACTIVE2, 0x20 }, // LDO8
{ 1200, 100,0x12, 0x1f, 0x0, kD1972_LDO9, kD1972_ACTIVE2, 0x40 }, // LDO9
{ 2500, 50, 0x15, 0x1f, 0x4, kD1972_LDO10, kD1972_ACTIVE2, 0x80 }, // LDO10
{ 1700, 50, 0x1a, 0x1f, 0x0, kD1972_LDO11, kD1972_ACTIVE3, 0x01 }, // LDO11
{ 600, 25, 0x1c, 0x1f, 0x0, kD1972_LDO12, kD1972_ACTIVE3, 0x02 }, // LDO12
{ 5000, 50, 0x14, 0x1f, 0x0, kD1972_LCM_CONTROL1, kD1972_ACTIVE3, 0x04 }, // LCM1_LDO
{ 5000, 50, 0x14, 0x1f, 0x0, kD1972_LCM_CONTROL2, kD1972_ACTIVE3, 0x08 }, // LCM2_LDO
{ 5000, 50, 0x14, 0x1f, 0x0, kD1972_LCM_CONTROL3, kD1972_ACTIVE3, 0x10 }, // LCM3_LDO
{ 5000, 50, 0x1f, 0x1f, 0x0, kD1972_LCM_BST_CONTROL, kD1972_ACTIVE3, 0x40 }, // LCM_BOOST
{ 0, 0, 0, 0, 0x0, 0, kD1972_ACTIVE3, 0x80 }, // 17 - WLED_BST_EN
{ 0, 0, 0, 0, 0x0, 0, kD1972_ACTIVE4, 0x10 }, // 18 - DSP_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1972_ACTIVE4, 0x20 }, // 19 - CPU1V2_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1972_ACTIVE4, 0x40 }, // 20 - WDIG_EN
{ 0, 0, 0, 0, 0x0, 0, kD1972_ACTIVE4, 0x80 }, // 21 - CPU1V8_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1972_HIBERNATE1, 0x20 }, // 22 - set LDO1_EN in HIB
{ 0, 0, 0, 0, 0x0, 0, kD1972_HIBERNATE2, 0x08 }, // 23 - set LDO6_EN in HIB
};
#define LDOP ldo_1972
enum {
kDIALOG_VIB_CTRL_PWM_EN = (1 << 0),
kDIALOG_VIB_CTRL_BRAKE = (1 << 1),
kDIALOG_VIB_CTRL_PWM_CLK_MASK = (3 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_2MHZ = (0 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_1MHZ = (1 << 2),
kDIALOG_VIB_CTRL_PWM_CLK_500KHZ = (2 << 2),
kDIALOG_VIB_VSET_MASK = (0x3f << 0),
};
enum {
kDIALOG_SYS_CONFIG_WDOG_EN = (1 << 0),
kDIALOG_SYS_CONFIG_WDOG_MODE_100MS = (0 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_250MS = (1 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_500MS = (2 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_1000MS = (3 << 1),
kDIALOG_SYS_CONFIG_RESET_TIMER_MASK = (3 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_4S = (0 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_6S = (1 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_8S = (2 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_10S = (3 << 3),
kDIALOG_SYS_CONFIG_WDOG_ACTIVE = (1 << 5),
};
enum {
kDIALOG_BUTTON_DBL_CLICK_RATE_MASK = (7 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_50MS = (0 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_100MS = (1 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_150MS = (2 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_200MS = (3 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_250MS = (4 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_300MS = (5 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_350MS = (6 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_400MS = (7 << 0),
kD1972_BUTTON_DBL_BTN1_DBL_EN = (1 << 3),
kD1972_BUTTON_DBL_BTN2_DBL_EN = (1 << 4),
kD1972_BUTTON_DBL_BTN3_DBL_EN = (1 << 5),
kDIALOG_BUTTON_DBL_HOLD_DBL_EN = kD1972_BUTTON_DBL_BTN2_DBL_EN,
kDIALOG_BUTTON_DBL_MENU_DBL_EN = kD1972_BUTTON_DBL_BTN1_DBL_EN,
kDIALOG_BUTTON_DBL_RINGER_DBL_EN = kD1972_BUTTON_DBL_BTN3_DBL_EN,
};
#endif /* __DIALOG_D1972_H */
drivers/dialog/pmu/d1974.h
+866
View File
@@ -0,0 +1,866 @@
#define PMU_HAS_SWI 0
#define PMU_HAS_DWI 1
#define PMU_HAS_LCM_LDO 1
#define PMU_HAS_REG_BANK 1
#define PMU_HAS_BIST_ADC 1
#define PMU_HAS_CHG_ABCC_FLAG 1
#define PMU_HAS_WLED 1
enum {
kDIALOG_ADDR_R = 0x79,
kDIALOG_ADDR_W = 0x78,
kDIALOG_REG_BYTES = 1,
};
enum {
kDIALOG_EVENT_COUNT = 10,
kDIALOG_STATUS_COUNT = 10,
kDIALOG_HIBERNATE_COUNT = 4,
kDIALOG_CHIPID_COUNT = 1,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_GPIO_COUNT = 16,
};
#include "dCommon.h"
enum {
kDIALOG_BANK_COUNT = 3,
kDIALOG_BANK0_SHARED_COUNT = 0x59,
};
enum {
// Register Bank 0
kDIALOG_CHIP_ID = 0x00,
kDIALOG_EVENT_A = 0x01,
kDIALOG_EVENT_B = 0x02,
kDIALOG_EVENT_C = 0x03,
kDIALOG_EVENT_D = 0x04,
kDIALOG_EVENT_E = 0x05,
kDIALOG_EVENT_F = 0x06,
kDIALOG_EVENT_G = 0x07,
kDIALOG_EVENT_H = 0x08,
kDIALOG_EVENT_I = 0x09,
kDIALOG_EVENT_J = 0x0a,
kDIALOG_STATUS_A = 0x0b,
kDIALOG_STATUS_B = 0x0c,
kDIALOG_STATUS_C = 0x0d,
kDIALOG_STATUS_D = 0x0e,
kDIALOG_STATUS_E = 0x0f,
kDIALOG_STATUS_F = 0x10,
kDIALOG_STATUS_G = 0x11,
kDIALOG_STATUS_H = 0x12,
kDIALOG_STATUS_I = 0x13,
kDIALOG_STATUS_J = 0x14,
kDIALOG_IRQ_MASK_A = 0x15,
kDIALOG_IRQ_MASK_B = 0x16,
kDIALOG_IRQ_MASK_C = 0x17,
kDIALOG_IRQ_MASK_D = 0x18,
kDIALOG_IRQ_MASK_E = 0x19,
kDIALOG_IRQ_MASK_F = 0x1a,
kDIALOG_IRQ_MASK_G = 0x1b,
kDIALOG_IRQ_MASK_H = 0x1c,
kDIALOG_IRQ_MASK_I = 0x1d,
kDIALOG_IRQ_MASK_J = 0x1e,
kDIALOG_SYS_CONTROL = 0x1f,
kDIALOG_SYS_CONTROL2 = 0x20,
kDIALOG_FAULT_LOG = 0x21,
kDIALOG_BANKSEL = 0x22,
kD1974_ACTIVE1 = 0x23,
kD1974_ACTIVE2 = 0x24,
kD1974_ACTIVE3 = 0x25,
kDIALOG_LCM_ACTIVE = kD1974_ACTIVE3,
kD1974_ACTIVE4 = 0x26,
kD1974_STANDBY1 = 0x27,
kDIALOG_STANDBY = kD1974_STANDBY1,
kD1974_HIBERNATE1 = 0x28,
kD1974_HIBERNATE2 = 0x29,
kD1974_HIBERNATE3 = 0x2a,
kD1974_HIBERNATE4 = 0x2b,
kD1974_BUCK0 = 0x2c,
kDIALOG_BUCK0 = kD1974_BUCK0,
kD1974_BUCK2 = 0x2d,
kDIALOG_BUCK2 = kD1974_BUCK2,
kD1974_BUCK3 = 0x2e,
kD1974_BUCK4 = 0x2f,
kD1974_BUCK5 = 0x30,
kD1974_LDO1 = 0x31,
kD1974_LDO2 = 0x32,
kD1974_LDO3 = 0x33,
kD1974_LDO4 = 0x34,
kD1974_LDO5 = 0x35,
kD1974_LDO6 = 0x36,
kD1974_LDO7 = 0x37,
kD1974_LDO8 = 0x38,
kD1974_LDO9 = 0x39,
kD1974_LDO10 = 0x3a,
kD1974_LDO11 = 0x3b,
kD1974_LDO12 = 0x3c,
kDIALOG_BUCK_DWI = 0x3d,
kDIALOG_CHARGE_BUCK_CONTROL = 0x3e,
kDIALOG_CHARGE_CONTROL_A = 0x3f,
kDIALOG_CHARGE_CONTROL_B = 0x40,
kDIALOG_CHARGE_CONTROL_C = 0x41,
kDIALOG_CHARGE_CONTROL_D = 0x42,
kDIALOG_CHARGE_TIME = 0x43,
kDIALOG_CHARGE_CONTROL_ICHG_BAT = kDIALOG_CHARGE_CONTROL_B,
kDIALOG_CHARGE_CONTROL_HIB = kDIALOG_CHARGE_CONTROL_A,
kDIALOG_CHARGE_CONTROL_TIME = kDIALOG_CHARGE_CONTROL_D,
kDIALOG_CHARGE_CONTROL_EN = kDIALOG_CHARGE_CONTROL_C,
kDIALOG_OTP_ISET_BAT = kDIALOG_CHARGE_CONTROL_A, // not a real OTP register
kDIALOG_ADC_CONTROL = 0x44,
kDIALOG_ADC_LSB = 0x45,
kDIALOG_ADC_MSB = 0x46,
kDIALOG_ICHG_AVG = 0x47,
kDIALOG_TBAT_0 = 0x4c,
kDIALOG_ICHG_TBAT_0 = 0x4d,
kDIALOG_TBAT_1 = 0x4e,
kDIALOG_ICHG_TBAT_1 = 0x4f,
kDIALOG_TBAT_2 = 0x50,
kDIALOG_ICHG_TBAT_2 = 0x51,
kDIALOG_TBAT_3 = 0x52,
kDIALOG_ICHG_TBAT_3 = 0x53,
kDIALOG_TBAT_4 = 0x54,
kDIALOG_ICHG_TBAT_4 = 0x55,
kDIALOG_TBAT_MAX = 0x56,
kDIALOG_ICHG_TBAT_NUM = 5,
kDIALOG_T_OFFSET_MSB = 0x57,
kDIALOG_T_OFFSET_LSB = 0x58,
kD1974_IVBUS_GAIN = 0x59,
kDIALOG_RTC_ALARM_A = 0x5a,
kDIALOG_RTC_ALARM_B = 0x5b,
kDIALOG_RTC_ALARM_C = 0x5c,
kDIALOG_RTC_ALARM_D = 0x5d,
kDIALOG_RTC_CONTROL = 0x5e,
kDIALOG_RTC_TIMEZONE = 0x5f,
kDIALOG_UPCOUNT_A = 0x60,
kDIALOG_UPCOUNT_B = 0x61,
kDIALOG_UPCOUNT_C = 0x62,
kDIALOG_UPCOUNT_D = 0x63,
kD1974_SYS_GPIO_1 = 0x64,
kDIALOG_SYS_GPIO_REG_START = kD1974_SYS_GPIO_1,
kD1974_SYS_GPIO_2 = 0x65,
kD1974_SYS_GPIO_3 = 0x66,
kD1974_SYS_GPIO_4 = 0x67,
kD1974_SYS_GPIO_5 = 0x68,
kD1974_SYS_GPIO_6 = 0x69,
kD1974_SYS_GPIO_7 = 0x6a,
kD1974_SYS_GPIO_8 = 0x6b,
kD1974_SYS_GPIO_9 = 0x6c,
kD1974_SYS_GPIO_10 = 0x6d,
kD1974_SYS_GPIO_11 = 0x6e,
kD1974_SYS_GPIO_12 = 0x6f,
kD1974_SYS_GPIO_13 = 0x70,
kD1974_SYS_GPIO_14 = 0x71,
kD1974_SYS_GPIO_15 = 0x72,
kD1974_SYS_GPIO_16 = 0x73,
kD1974_SYS_GPIO_17 = 0x74,
kD1974_SYS_GPIO_DEB1 = 0x75,
kD1974_SYS_GPIO_DEB2 = 0x76,
kD1974_SYS_GPIO_DEB3 = 0x77,
kD1974_SYS_GPIO_DEB4 = 0x78,
kD1974_SYS_GPIO_DEB5 = 0x79,
kD1974_SYS_GPIO_DEB6 = 0x7a,
kD1974_SYS_GPIO_DEB7 = 0x7b,
kD1974_SYS_GPIO_DEB8 = 0x7c,
kD1974_SYS_GPIO_DEB9 = 0x7d,
kDIALOG_LDO_CONTROL = 0x7e,
kD1974_BUTTON1 = 0x7f,
kD1974_BUTTON2 = 0x80,
kD1974_BUTTON3 = 0x81,
kDIALOG_SYS_CONFIG = 0x82,
kD1974_LCM_CONTROL1 = 0x83,
kD1974_LCM_CONTROL2 = 0x84,
kD1974_LCM_CONTROL3 = 0x85,
kD1974_LCM_BST_CONTROL = 0x86,
kDIALOG_LCM_BOOST = kD1974_LCM_BST_CONTROL,
kD1974_BUCK3_HIB = 0xa1,
kD1974_BUCK4_HIB = 0xa2,
kD1974_GPIO_SOFTHIB1 = 0xa3,
kD1974_GPIO_SOFTHIB2 = 0xa4,
kD1974_GPIO_SOFTHIB3 = 0xa5,
kDIALOG_BUTTON_DBL = 0xa6,
kDIALOG_MEMBYTE0 = 0xa7,
kDIALOG_MEMBYTE_LAST = 0xce,
kDIALOG_WLED_ISET = 0xd3,
kDIALOG_WLED_ISET2 = 0xd4,
kDIALOG_WLED_CONTROL = 0xd5,
kDIALOG_WLED_CONTROL2 = 0xd6,
kDIALOG_WLED_DWI_CONTROL = kDIALOG_WLED_CONTROL2,
kDIALOG_WLED_OPTIONS = kDIALOG_WLED_CONTROL2,
// Register Bank 1
kDIALOG_APP_TMUX = 0x162,
kDIALOG_BIST_ADC_CTRL = 0x163,
kDIALOG_BIST_ADC_LSB = 0x164,
kDIALOG_BIST_ADC_MSB = 0x165,
kDIALOG_BIST_ADC0 = 0x166,
kDIALOG_BUCK_CTRL1 = 0x1b3,
kD1974_IVBUS_OFFS = 0x1fc,
// Bank 2 Test Registers
kD1974_TEST_MODE = 0x2d0,
};
enum {
kD1974_CHIP_ID_MRC_MASK = (0xf << 0),
kD1974_CHIP_ID_MRC_A0 = (0 << 0),
kD1974_CHIP_ID_MRC_A1 = (1 << 0),
kD1974_CHIP_ID_TRC_MASK = (0xf << 4),
kD1974_CHIP_ID_TRC_AK = (0xa << 4),
};
enum {
kD1974_EVENT_A_BUTTON1 = (1 << 0),
kD1974_EVENT_A_BUTTON2 = (1 << 1),
kD1974_EVENT_A_BUTTON3 = (1 << 2),
kD1974_EVENT_A_VCENTER_DET = (1 << 3),
kD1974_EVENT_A_FW_DET = (1 << 4),
kD1974_EVENT_A_ACC_DET = (1 << 5),
kD1974_EVENT_A_VBUS_EXT_DET = (1 << 6),
kD1974_EVENT_A_VDD_LOW = (1 << 7),
};
// EVENT_B events are assumed volatile (lost over sleep/wake)
enum {
kD1974_EVENT_B_CHG_PRE = (1 << 1),
kD1974_EVENT_B_CHG_FAST = (1 << 2),
kD1974_EVENT_B_CHG_END = (1 << 3),
kD1974_EVENT_B_TBAT = (1 << 4),
kD1974_EVENT_B_FW_OV = (1 << 6),
kDIALOG_EVENT_B_HIB = (1 << 7),
};
enum {
kD1974_EVENT_C_GPIO1 = (1 << 0),
kD1974_EVENT_C_GPIO2 = (1 << 1),
kD1974_EVENT_C_GPIO3 = (1 << 2),
kD1974_EVENT_C_GPIO4 = (1 << 3),
kD1974_EVENT_C_GPIO5 = (1 << 4),
kD1974_EVENT_C_GPIO6 = (1 << 5),
kD1974_EVENT_C_GPIO7 = (1 << 6),
kD1974_EVENT_C_GPIO8 = (1 << 7),
};
enum {
kD1974_EVENT_D_GPIO9 = (1 << 0),
kD1974_EVENT_D_GPIO10 = (1 << 1),
kD1974_EVENT_D_GPIO11 = (1 << 2),
kD1974_EVENT_D_GPIO12 = (1 << 3),
kD1974_EVENT_D_GPIO13 = (1 << 4),
kD1974_EVENT_D_GPIO14 = (1 << 5),
kD1974_EVENT_D_GPIO15 = (1 << 6),
kD1974_EVENT_D_GPIO16 = (1 << 7),
};
enum {
kD1974_EVENT_E_GPIO17 = (1 << 0),
kD1974_EVENT_E_BTN1_DBL = (1 << 3),
kD1974_EVENT_E_BTN2_DBL = (1 << 4),
kD1974_EVENT_E_BTN3_DBL = (1 << 5),
kD1974_EVENT_E_CHG_BUCK_FLG = (1 << 6),
kD1974_EVENT_E_VBUS_OV = (1 << 7),
};
enum {
kD1974_EVENT_H_ALARM = (1 << 0),
kD1974_EVENT_H_FW_REM = (1 << 4),
kD1974_EVENT_H_VBUS_REM = (1 << 6),
kD1974_EVENT_H_ABCC_FLAG = (1 << 7),
};
enum {
kD1974_EVENT_J_DWI_TO = (1 << 1),
kD1974_EVENT_J_EOMC = (1 << 2),
kD1974_EVENT_J_DPHP_DET = (1 << 4),
};
enum {
kD1974_STATUS_A_BUTTON1 = (1 << 0),
kD1974_STATUS_A_BUTTON2 = (1 << 1),
kD1974_STATUS_A_BUTTON3 = (1 << 2),
kD1974_STATUS_A_VCENTER_DET = (1 << 3),
kD1974_STATUS_A_FW_DET = (1 << 4),
kD1974_STATUS_A_ACC_DET = (1 << 5),
kD1974_STATUS_A_VBUS_EXT_DET = (1 << 6),
kD1974_STATUS_A_VDD_LOW = (1 << 7),
};
enum {
kD1974_STATUS_B_CHG_ATT = (1 << 0),
kD1974_STATUS_B_CHG_PRE = (1 << 1),
kD1974_STATUS_B_CHG_FAST = (1 << 2),
kD1974_STATUS_B_CHG_END = (1 << 3),
kD1974_STATUS_B_TBAT = (1 << 4),
kD1974_STATUS_B_CHG_TO = (1 << 5),
kD1974_STATUS_B_FW_OV = (1 << 6),
};
enum {
kD1974_STATUS_C_GPIO1 = (1 << 0),
kD1974_STATUS_C_GPIO2 = (1 << 1),
kD1974_STATUS_C_GPIO3 = (1 << 2),
kD1974_STATUS_C_GPIO4 = (1 << 3),
kD1974_STATUS_C_GPIO5 = (1 << 4),
kD1974_STATUS_C_GPIO6 = (1 << 5),
kD1974_STATUS_C_GPIO7 = (1 << 6),
kD1974_STATUS_C_GPIO8 = (1 << 7),
};
enum {
kD1974_STATUS_D_GPIO9 = (1 << 0),
kD1974_STATUS_D_GPIO10 = (1 << 1),
kD1974_STATUS_D_GPIO11 = (1 << 2),
kD1974_STATUS_D_GPIO12 = (1 << 3),
kD1974_STATUS_D_GPIO13 = (1 << 4),
kD1974_STATUS_D_GPIO14 = (1 << 5),
kD1974_STATUS_D_GPIO15 = (1 << 6),
kD1974_STATUS_D_GPIO16 = (1 << 7),
};
enum {
kD1974_STATUS_E_GPIO17 = (1 << 0),
kD1974_STATUS_E_CHG_BUCK_FLG = (1 << 6),
kD1974_STATUS_E_VBUS_OV = (1 << 7),
};
enum {
kD1974_STATUS_H_ABCC_FLAG = (1 << 7),
};
enum {
kD1974_BUCK4_CONT_MASK = (3 << 4),
kD1974_BUCK4_CONT_SLEEP = (0 << 4),
kD1974_BUCK4_CONT_AUTO = (1 << 4),
};
enum {
kDIALOG_EVENT_HOLD_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1974_EVENT_A_BUTTON2),
kDIALOG_EVENT_MENU_BUTTON_MASK = EVENT_FLAG_MAKE(0, kD1974_EVENT_A_BUTTON1),
kDIALOG_EVENT_RINGER_BUTTON_MASK= EVENT_FLAG_MAKE(0, kD1974_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS = (kD1974_EVENT_A_BUTTON2 |
kD1974_EVENT_A_BUTTON1 |
kD1974_EVENT_A_BUTTON3),
kDIALOG_EVENT_BUTTONS_MASK = EVENT_FLAG_MAKE(0, kDIALOG_EVENT_BUTTONS),
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_EVENT_HOLD_BUTTON_MASK,
kDIALOG_EVENT_ALARM_MASK = EVENT_FLAG_MAKE(7, kD1974_EVENT_H_ALARM),
kDIALOG_EVENT_ACC_DET_MASK = EVENT_FLAG_MAKE(0, kD1974_EVENT_A_ACC_DET),
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD1974_EVENT_A_VBUS_EXT_DET),
kDIALOG_EVENT_VHP_DET_MASK = EVENT_FLAG_MAKE(0, kD1974_STATUS_A_FW_DET),
kDIALOG_EVENT_VBUS_REM_MASK = EVENT_FLAG_MAKE(7, kD1974_EVENT_H_VBUS_REM),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(9, kD1974_EVENT_J_EOMC),
kDIALOG_EVENT_HIB_MASK = EVENT_FLAG_MAKE(1, kDIALOG_EVENT_B_HIB),
kDIALOG_EVENT_ABCC_MASK = EVENT_FLAG_MAKE(7, kD1974_EVENT_H_ABCC_FLAG),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(1, kD1974_EVENT_B_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(1, kD1974_EVENT_B_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(2, kD1974_EVENT_C_GPIO8),
kDIALOG_EVENT_GPIO9_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO9),
kDIALOG_EVENT_GPIO10_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO10),
kDIALOG_EVENT_GPIO11_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO11),
kDIALOG_EVENT_GPIO12_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO12),
kDIALOG_EVENT_GPIO13_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO13),
kDIALOG_EVENT_GPIO14_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO14),
kDIALOG_EVENT_GPIO15_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO15),
kDIALOG_EVENT_GPIO16_MASK = EVENT_FLAG_MAKE(3, kD1974_EVENT_D_GPIO16),
kDIALOG_EVENT_GPIO17_MASK = EVENT_FLAG_MAKE(4, kD1974_EVENT_E_GPIO17),
kDIALOG_EVENT_HOLD_DBL_MASK = EVENT_FLAG_MAKE(4, kD1974_EVENT_E_BTN2_DBL),
kDIALOG_EVENT_MENU_DBL_MASK = EVENT_FLAG_MAKE(4, kD1974_EVENT_E_BTN1_DBL),
kDIALOG_EVENT_RINGER_DBL_MASK = EVENT_FLAG_MAKE(4, kD1974_EVENT_E_BTN3_DBL),
kDIALOG_EVENT_GPIO18_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD1974_STATUS_A_VCENTER_DET),
kDIALOG_STATUS_VBUS_MASK = STATUS_FLAG_MAKE(0, kD1974_STATUS_A_VBUS_EXT_DET),
kDIALOG_STATUS_FW_MASK = STATUS_FLAG_MAKE(0, kD1974_STATUS_A_FW_DET),
kDIALOG_STATUS_ACC_DET_MASK = STATUS_FLAG_MAKE(0, kD1974_STATUS_A_ACC_DET),
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(1, kD1974_STATUS_B_CHG_PRE | kD1974_STATUS_B_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(1, kD1974_STATUS_B_CHG_TO),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD1974_STATUS_B_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(1, kD1974_STATUS_B_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(1, kD1974_STATUS_B_CHG_ATT),
kDIALOG_STATUS_ABCC_MASK = STATUS_FLAG_MAKE(7, kD1974_STATUS_H_ABCC_FLAG),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(2 + ((gpio)/8), (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {kD1974_STATUS_A_FW_DET, 0, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD1974_STATUS_B_CHG_PRE | kD1974_STATUS_B_CHG_FAST, 0, 0, 0, 0};
enum {
kD1974_EVENT_A_WAKEMASK = (kD1974_EVENT_A_BUTTON1 |
kD1974_EVENT_A_BUTTON2 |
kD1974_EVENT_A_BUTTON3 |
kD1974_EVENT_A_VBUS_EXT_DET |
kD1974_STATUS_A_FW_DET |
kD1974_EVENT_A_ACC_DET),
kD1974_EVENT_B_WAKEMASK = 0,
kD1974_EVENT_C_WAKEMASK = 0,
kD1974_EVENT_D_WAKEMASK = 0,
kD1974_EVENT_E_WAKEMASK = 0,
kD1974_EVENT_F_WAKEMASK = 0,
kD1974_EVENT_G_WAKEMASK = 0,
kD1974_EVENT_H_WAKEMASK = (kD1974_EVENT_H_ALARM |
kD1974_EVENT_H_FW_REM |
kD1974_EVENT_H_VBUS_REM),
kD1974_EVENT_I_WAKEMASK = 0,
kD1974_EVENT_J_WAKEMASK = 0,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
~kD1974_EVENT_A_WAKEMASK,
~kD1974_EVENT_B_WAKEMASK,
~kD1974_EVENT_C_WAKEMASK,
~kD1974_EVENT_D_WAKEMASK,
~kD1974_EVENT_E_WAKEMASK,
~kD1974_EVENT_F_WAKEMASK,
~kD1974_EVENT_G_WAKEMASK,
~kD1974_EVENT_H_WAKEMASK,
~kD1974_EVENT_I_WAKEMASK,
~kD1974_EVENT_J_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD1974_EVENT_A_WAKEMASK & ~kDIALOG_EVENT_BUTTONS,
kD1974_EVENT_B_WAKEMASK,
kD1974_EVENT_C_WAKEMASK,
kD1974_EVENT_D_WAKEMASK,
kD1974_EVENT_E_WAKEMASK,
kD1974_EVENT_F_WAKEMASK,
kD1974_EVENT_G_WAKEMASK,
kD1974_EVENT_H_WAKEMASK,
kD1974_EVENT_I_WAKEMASK,
kD1974_EVENT_J_WAKEMASK,
};
// All events that defer shutdown
static const eventRegisters kDialogEventRestartMask = {
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_HOLD_BUTTON_MASK, 0) | EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ACC_DET_MASK, 0),
0,
0,
0,
0,
0,
0,
EVENT_FLAG_GET_BIT_FOR_BYTE(kDIALOG_EVENT_ALARM_MASK, 7),
0,
0,
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD1974_EVENT_A_VBUS_EXT_DET | kD1974_EVENT_A_FW_DET | kD1974_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
0,
0,
kD1974_EVENT_H_FW_REM | kD1974_EVENT_H_VBUS_REM,
0,
0,
};
static const eventRegisters kDialogEventUSBMask = {
// only include VCENTER_DET; VBUS can come and go while charger still usable
kD1974_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
0,
0,
kD1974_EVENT_H_ABCC_FLAG,
0,
0,
};
static const eventRegisters kDialogEventFWMask = {
kD1974_EVENT_A_FW_DET,
0,
0,
0,
0,
0,
0,
kD1974_EVENT_H_FW_REM,
0,
0,
};
// XXXKW
enum {
kDialogEventPwrsupplyCount = 5,
kDialogEventUSBCount = 2,
kDialogEventFWCount = 2,
};
enum {
kDIALOG_LCM_ACTIVE_BOOST_EN = (1 << 1),
kDIALOG_LCM_ACTIVE_MASK = (1 << 2) | (1 << 3) | (1 << 4),
};
enum {
kDIALOG_SYS_CONTROL_STANDBY = (1 << 0),
kDIALOG_SYS_CONTROL_HIBERNATE = (1 << 1),
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_SOFT_HIB = (1 << 3),
kDIALOG_SYS_CONTROL_HIB_CLK = (1 << 4),
kDIALOG_SYS_CONTROL_PRO_FET_DIS = (1 << 5),
kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND = (1 << 6),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND
| kDIALOG_SYS_CONTROL_BUS_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = kDIALOG_SYS_CONTROL_HIBERNATE,
};
enum {
kDIALOG_SYS_CONTROL2_DWI_EN = (1 << 0),
kDIALOG_SYS_CONTROL2_DWI_TEST_EN = (1 << 1),
kDIALOG_SYS_CONTROL2_HIB_32K = (1 << 4),
};
enum {
kDIALOG_FAULT_LOG_WDOG = FAULTLOG_FLAG_MAKE(0, (1 << 6)),
kDIALOG_FAULT_LOG_RESET_IN_1 = FAULTLOG_FLAG_MAKE(0, (1 << 5)),
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 4)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_BOOST = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_BUCK_DWI_BUCK0 = (1 << 0),
kDIALOG_BUCK_DWI_BUCK1 = (1 << 1),
kDIALOG_BUCK_DWI_BUCK2 = (1 << 2),
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MIN = 0x00,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x02,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x0a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_250 = 0xe,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_300 = 0x12,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_350 = 0x16,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_400 = 0x1a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x22,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_600 = 0x2a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_700 = 0x32,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_750 = 0x36,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_900 = 0x42,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x4a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1500 = 0x72,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1900 = 0x92,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0x9a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2100 = 0xa2,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2200 = 0xaa,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2300 = 0xb2,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MAX = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0xff,
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_MIN = 75,
kDIALOG_CHARGE_BUCK_CONTROL_STEP_PER_100MA = 8,
kDIALOG_CHARGE_BUCK_CONTROL_MAX = 3262,
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3f,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_A_CHG_SUSP = (1 << 6),
kDIALOG_CHARGE_CONTROL_A_CHG_HIB = (1 << 7),
kDIALOG_CHARGE_CONTROL_CHG_HIB = kDIALOG_CHARGE_CONTROL_A_CHG_HIB,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 50,
kDIALOG_CHARGE_CONTROL_MAX = 3150,
};
enum {
kDIALOG_CHARGE_CONTROL_C_ALT_USB_DIS = (1 << 6),
kDIALOG_CHARGE_CONTROL_C_CHG_BUCK_EN = (1 << 7),
kDIALOG_CHARGE_CONTROL_ALT_USB_DIS = kDIALOG_CHARGE_CONTROL_C_ALT_USB_DIS,
kDIALOG_CHARGE_CONTROL_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_C_CHG_BUCK_EN,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_VBUS_CHG_BUCK_EN = kDIALOG_CHARGE_CONTROL_C_CHG_BUCK_EN,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0xF0,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x07,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0x1f << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0x0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = (0x1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (0x2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ACC_ID = (0x3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (0x4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT = (0x5 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BRICK_ID = (0x6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN7 = (0x7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (0x8 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VIBUS = (0x9 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_NTC0 = (0xa << 0),
kDIALOG_ADC_CONTROL_MUX_NUM_NTC = 9,
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = (19 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VIBUS_OFF = (20 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBAT_OUT_OFF= (21 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK5_TEMP = (22 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LDO9_TEMP = (23 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_B_TEMP= (24 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CHG_TEMP = (25 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK0_TEMP = (26 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK2_TEMP = (27 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK3_TEMP = (28 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_BUCK4_TEMP = (29 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_A_TEMP= (30 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_START = kDIALOG_ADC_CONTROL_MUX_SEL_BUCK5_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_END = kDIALOG_ADC_CONTROL_MUX_SEL_CBUCK_A_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN31 = (31 << 0),
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 5),
kDIALOG_ADC_CONTROL_ADC_REF_EN = (1 << 6),
kDIALOG_ADC_CONTROL_AUTO_VDD_OUT_EN = (1 << 7),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 12,
kDIALOG_ADC_FULL_SCALE_MV = 2500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kDIALOG_BIST_ADC_CTRL_MUX_SEL_MASK = (0x3f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO1 = (0x00 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO1 = (0x01 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO2 = (0x02 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO2 = (0x03 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO3 = (0x04 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO3 = (0x05 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO4 = (0x06 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO4 = (0x07 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO5 = (0x08 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO5 = (0x09 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO6 = (0x0a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO6 = (0x0b << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO7 = (0x0c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO7 = (0x0d << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO8 = (0x0e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO8 = (0x0f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO9 = (0x10 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO9 = (0x11 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO10 = (0x12 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO10 = (0x13 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO11 = (0x14 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO11 = (0x15 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLDO12 = (0x16 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILDO12 = (0x17 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM1 = (0x18 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM1 = (0x19 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM2 = (0x1a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM2 = (0x1b << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VLCM3 = (0x1c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_ILCM3 = (0x1d << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VRTC = (0x1e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IRTC = (0x1f << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUF_ON = (0x20 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_IBUF_ON = (0x21 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK0 = (0x22 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VOUT_WLEDB = (0x24 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK2 = (0x26 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK3 = (0x28 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK4 = (0x2a << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VOUT_WLEDA = (0x2c << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBOOST_LCM = (0x2e << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_A = (0x30 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_APP_MUX_B = (0x32 << 0),
kDIALOG_BIST_ADC_CTRL_MUX_SEL_VBUCK5 = (0x34 << 0),
kDIALOG_BIST_ADC_CTRL_AUTO_RUN = (1 << 6),
kDIALOG_BIST_ADC_CTRL_MAN_CONV = (1 << 7),
};
enum {
kDIALOG_APP_TMUX_SEL_MASK = (15 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_0 = (0 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_1 = (1 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_2 = (2 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_3 = (3 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_4 = (4 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_5 = (5 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_6 = (6 << 0),
kDIALOG_APP_TMUX_SEL_AMUX_7 = (7 << 0),
KDIALOG_APP_TMUX_EN = (1 << 7),
};
enum {
kDIALOG_RTC_CONTROL_MONITOR = (1 << 0),
kDIALOG_RTC_CONTROL_ALARM_EN = (1 << 6),
};
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_INPUT_WAKE = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (7 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (0 << 5),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = (2 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (3 << 5),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (4 << 5),
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_MASK) \
< kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH)
enum {
kDIALOG_WLED_CONTROL_WLED_ENABLE1 = (1 << 0),
kDIALOG_WLED_CONTROL_WLED_ENABLE2 = (1 << 1),
kDIALOG_WLED_CONTROL_WLED_ENABLE3 = (1 << 2),
kDIALOG_WLED_CONTROL_WLED_ENABLE4 = (1 << 3),
kDIALOG_WLED_CONTROL_WLED_ENABLE5 = (1 << 4),
kDIALOG_WLED_CONTROL_WLED_ENABLE6 = (1 << 5),
};
enum {
kDIALOG_WLED_CONTROL2_WLED_RAMP_EN = (1 << 2),
kDIALOG_WLED_CONTROL2_WLED_DWI_EN = (1 << 3),
kDIALOG_WLED_CONTROL2_WLED_DITH_EN = (1 << 4),
kDIALOG_WLED_CONTROL2_WLED_DITH_RAMP_EN = (1 << 5),
kDIALOG_WLED_CONTROL_WLED_DWI_EN = kDIALOG_WLED_CONTROL2_WLED_DWI_EN,
kDIALOG_WLED_OPTIONS_DEFAULT = kDIALOG_WLED_CONTROL2_WLED_DITH_EN,
kDIALOG_WLED_OPTIONS_xWI_EN = kDIALOG_WLED_CONTROL2_WLED_DWI_EN,
kDIALOG_WLED_OPTIONS_MASK = (kDIALOG_WLED_CONTROL2_WLED_RAMP_EN|
kDIALOG_WLED_CONTROL2_WLED_DITH_EN|
kDIALOG_WLED_CONTROL2_WLED_DITH_RAMP_EN),
};
#define WLED_ISET_BITS (11)
#define NUM_LDOS 23
static const struct ldo_params ldo_1974[NUM_LDOS] = {
{ 2500, 50, 0x0a, 0x1f, 0x1, kD1974_LDO1, kD1974_ACTIVE1, 0x20 }, // LDO1
{ 1650, 5, 0x0a, 0x1f, 0x0, kD1974_LDO2, kD1974_ACTIVE1, 0x40 }, // LDO2
{ 2500, 50, 0x0a, 0x1f, 0x0, kD1974_LDO3, kD1974_ACTIVE1, 0x80 }, // LDO3
{ 1800, 50, 0x18, 0x1f, 0x0, kD1974_LDO4, kD1974_ACTIVE2, 0x01 }, // LDO4
{ 2500, 50, 0x0a, 0x1f, 0x0, kD1974_LDO5, kD1974_ACTIVE2, 0x02 }, // LDO5
{ 2500, 50, 0x10, 0x1f, 0x2, kD1974_LDO6, kD1974_ACTIVE2, 0x04 }, // LDO6
{ 1500, 100,0x0a, 0x1f, 0x0, kD1974_LDO7, kD1974_ACTIVE2, 0x08 }, // LDO7
{ 2000, 50, 0x16, 0x1f, 0x0, kD1974_LDO8, kD1974_ACTIVE2, 0x10 }, // LDO8
{ 1200, 100,0x00, 0x1f, 0x0, kD1974_LDO9, kD1974_ACTIVE2, 0x20 }, // LDO9
{ 2500, 50, 0x0a, 0x1f, 0x4, kD1974_LDO10, kD1974_ACTIVE2, 0x40 }, // LDO10
{ 1700, 50, 0x17, 0x1f, 0x0, kD1974_LDO11, kD1974_ACTIVE2, 0x80 }, // LDO11
{ 600, 25, 0x14, 0x1f, 0x0, kD1974_LDO12, kD1974_ACTIVE3, 0x01 }, // LDO12
{ 5000, 50, 0x0c, 0x1f, 0x0, kD1974_LCM_CONTROL1, kD1974_ACTIVE3, 0x04 }, // LCM1_LDO
{ 5000, 50, 0x05, 0x1f, 0x0, kD1974_LCM_CONTROL2, kD1974_ACTIVE3, 0x08 }, // LCM2_LDO
{ 5000, 50, 0x00, 0x1f, 0x0, kD1974_LCM_CONTROL3, kD1974_ACTIVE3, 0x10 }, // LCM3_LDO
{ 5000, 50, 0x1f, 0x1f, 0x0, kD1974_LCM_BST_CONTROL, kD1974_ACTIVE3, 0x02 }, // LCM_BOOST
{ 0, 0, 0, 0, 0x0, 0, kD1974_ACTIVE3, 0x20 }, // 17 - WLED_BST_EN
{ 0, 0, 0, 0, 0x0, 0, kD1974_ACTIVE4, 0x10 }, // 18 - DSP_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1974_ACTIVE4, 0x20 }, // 19 - CPU1V2_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1974_ACTIVE4, 0x40 }, // 20 - WDIG_EN
{ 0, 0, 0, 0, 0x0, 0, kD1974_ACTIVE4, 0x80 }, // 21 - CPU1V8_SW_EN
{ 0, 0, 0, 0, 0x0, 0, kD1974_HIBERNATE1, 0x20 }, // 22 - set LDO1_EN in HIB
{ 0, 0, 0, 0, 0x0, 0, kD1974_HIBERNATE2, 0x04 }, // 23 - set LDO6_EN in HIB
};
#define LDOP ldo_1974
enum {
kDIALOG_SYS_CONFIG_WDOG_EN = (1 << 0),
kDIALOG_SYS_CONFIG_WDOG_MODE_100MS = (0 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_250MS = (1 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_500MS = (2 << 1),
kDIALOG_SYS_CONFIG_WDOG_MODE_1000MS = (3 << 1),
kDIALOG_SYS_CONFIG_RESET_TIMER_MASK = (3 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_4S = (0 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_6S = (1 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_8S = (2 << 3),
kDIALOG_SYS_CONFIG_RESET_TIMER_10S = (3 << 3),
kDIALOG_SYS_CONFIG_WDOG_ACTIVE = (1 << 5),
};
enum {
kDIALOG_BUTTON_DBL_CLICK_RATE_MASK = (7 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_50MS = (0 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_100MS = (1 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_150MS = (2 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_200MS = (3 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_250MS = (4 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_300MS = (5 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_350MS = (6 << 0),
kDIALOG_BUTTON_DBL_CLICK_RATE_400MS = (7 << 0),
kD1974_BUTTON_DBL_BTN1_DBL_EN = (1 << 3),
kD1974_BUTTON_DBL_BTN2_DBL_EN = (1 << 4),
kD1974_BUTTON_DBL_BTN3_DBL_EN = (1 << 5),
kDIALOG_BUTTON_DBL_HOLD_DBL_EN = kD1974_BUTTON_DBL_BTN2_DBL_EN,
kDIALOG_BUTTON_DBL_MENU_DBL_EN = kD1974_BUTTON_DBL_BTN1_DBL_EN,
kDIALOG_BUTTON_DBL_RINGER_DBL_EN = kD1974_BUTTON_DBL_BTN3_DBL_EN,
};
drivers/dialog/pmu/d2018.h
+1049
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2045.h
+1217
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2089.h
+1496
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2186.h
+1430
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2207.h
+1608
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2231.h
+773
View File
@@ -0,0 +1,773 @@
/*
* Copyright (C) 2014 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*
*/
#ifndef __DIALOG_D2231_H
#define __DIALOG_D2231_H
#define PMU_HAS_SWI 0
#define PMU_HAS_DWI 0
#define PMU_HAS_LCM_LDO 0
#define PMU_HAS_BIST_ADC 0
#define PMU_HAS_CHG_ABCC_FLAG 1
#define PMU_HAS_VIB 0
#define PMU_HAS_RAM 0
#define PMU_HAS_WLED 0
#define PMU_HAS_32K_RTC 0
#define PMU_HAS_ACCUMULATORS 1
#define PMU_HAS_SYS 0
#define PMU_HAS_WDT 0
#define PMU_HAS_CHARGER 1
#define PMU_HAS_ISET_BAT_2BYTES 1
enum {
kDIALOG_ADDR_R = 0xeb,
kDIALOG_ADDR_W = 0xea,
kDIALOG_REG_BYTES = 2,
};
enum {
kDIALOG_EVENT_COUNT = 6,
kDIALOG_STATUS_COUNT = 7,
kDIALOG_FAULTLOG_COUNT = 1,
kDIALOG_CHIPID_COUNT = 9,
kDIALOG_GPIO_COUNT = 6,
};
#include "dCommon.h"
enum {
kDIALOG_MASK_REV_CODE = 0x0000,
kDIALOG_TRIM_REL_CODE = 0x0001,
kDIALOG_PLATFORM_ID = 0x0002,
kDIALOG_PARITY = 0x0003,
kDIALOG_DEVICE_ID1 = 0x0004,
kDIALOG_DEVICE_ID2 = 0x0005,
kDIALOG_DEVICE_ID3 = 0x0006,
kDIALOG_DEVICE_ID4 = 0x0007,
kDIALOG_DEVICE_ID5 = 0x0008,
kDIALOG_CHIP_ID = kDIALOG_MASK_REV_CODE,
kDIALOG_SYS_CONTROL = 0x0010,
kDIALOG_SYS_CONFIG = 0x0020,
kD2231_SYS_CONF_B = 0x0021,
kD2231_SYS_CONF_C = 0x0022,
kD2231_BG_TRIM0 = 0x0023,
kD2231_BG_TRI1 = 0x0024,
kD2231_BG_CONFIG = 0x0025,
kD2231_COMP_TRIM = 0x0026,
kD2231_OSC_CTRL0 = 0x0027,
kD2231_OSC_TRIM = 0x0028,
kD2231_LDO_CORE_TRIM = 0x0029,
kD2231_ON_BUFFER_TRIM = 0x002a,
kD2231_SYS_CONF_E = 0x002b,
kD2231_SYS_CONF_F = 0x002c,
kDIALOG_FAULT_LOG = 0x0040,
// the event registers are named A-L but are numbered 0-5
kDIALOG_EVENT_A = 0x0050,
kDIALOG_EVENT_C = 0x0051,
kDIALOG_EVENT_D = 0x0052,
kDIALOG_EVENT_I = 0x0053,
kDIALOG_EVENT_J = 0x0054,
kDIALOG_EVENT_L = 0x0055,
// the status registers are named A-M but are numbered 0-6
kDIALOG_STATUS_A = 0x0060,
kDIALOG_STATUS_C = 0x0061,
kDIALOG_STATUS_D = 0x0062,
kDIALOG_STATUS_I = 0x0063,
kDIALOG_STATUS_J = 0x0064,
kDIALOG_STATUS_L = 0x0065,
kDIALOG_STATUS_M = 0x0066,
// the mask registers are named A-L but are numbered 0-5
kDIALOG_IRQ_MASK_A = 0x0070,
kDIALOG_IRQ_MASK_C = 0x0071,
kDIALOG_IRQ_MASK_D = 0x0072,
kDIALOG_IRQ_MASK_I = 0x0073,
kDIALOG_IRQ_MASK_J = 0x0074,
kDIALOG_IRQ_MASK_L = 0x0075,
// GPIO Control
kD2231_GPIO1 = 0x0170,
kDIALOG_SYS_GPIO_REG_START = kD2231_GPIO1,
kD2231_GPIO2 = 0x0171,
kD2231_GPIO3 = 0x0172,
kD2231_GPIO4 = 0x0173,
kD2231_GPIO5 = 0x0174,
kD2231_GPIO6 = 0x0175,
kD2231_GPIO_DEB1 = 0x0190,
kD2231_GPIO_DEB2 = 0x0191,
kD2231_GPIO_DEB3 = 0x0192,
// Temperature Sensor Control
kD2231_TVCENTER1_RISE = 0x01ac,
kD2231_TVCENTER2_RISE = 0x01ad,
kD2231_TCBUCK_RISE = 0x01ae,
kD2231_TLINCHG_RISE = 0x01af,
kD2231_TMID_DIE_RISE = 0x01b0,
kD2231_TLDO_VDDREF_CHG_RISE = 0x01b1,
kD2231_TVCENTER1_FALL = 0x01b2,
kD2231_TVCENTER2_FALL = 0x01b3,
kD2231_TCBUCK_FALL = 0x01b4,
kD2231_TLINCHG_FALL = 0x01b5,
kD2231_TMID_DIE_FALL = 0x01b6,
kD2231_TLDO_VDDREF_CHG_FALL = 0x01b7,
kDIALOG_T_OFFSET_MSB = 0x01b8,
kDIALOG_T_OFFSET_LSB = 0x01b9,
// Charging Control
kD2231_ISET_BUCK = 0x01ec,
kD2231_ISET_BUCK_SHADOW = 0x04ed,
kD2231_ISET_BUCK_LV_ABSMAX = 0x01ee,
kD2231_ISET_BUCK_HV_ABSMAX = 0x01ef,
kD2231_ISET_BUCK_ACTUAL = 0x01f0,
kD2231_ISET_BUCK_ALT = 0x01f1,
kDIALOG_CHARGE_BUCK_CONTROL = kD2231_ISET_BUCK,
kDIALOG_CHARGE_BUCK_STATUS = kD2231_ISET_BUCK_ACTUAL,
kD2231_ICHG_PRE_MSB = 0x01f2,
kD2231_ICHG_PRE_LSB = 0x01f3,
kD2231_ICHG_BAT_MSB = 0x01f4,
kD2231_ICHG_BAT_LSB = 0x01f5,
kD2231_ICHG_BAT_MAX_MSB = 0x01f6,
kD2231_ICHG_BAT_MAX_LSB = 0x01f7,
kD2231_CHG_VSET_MSB = 0x01f8,
kD2231_CHG_VSET_LSB = 0x01f9,
kD2231_CHG_VSET_ABSAX_MSB = 0x01fa,
kD2231_CHG_VSET_ABS_MAX_LSB = 0x01fb,
kD2231_CHG_CTRL_A = 0x01fc,
kD2231_CHG_CTRL_B = 0x01fd,
kD2231_CHG_CTRL_C = 0x01fe,
kD2231_CHG_CTRL_D = 0x01ff,
kD2231_CHG_TIME = 0x0200,
kD2231_CHG_TIME_PRE = 0x0201,
kDIALOG_CHARGE_CONTROL_ICHG_BAT_MSB = kD2231_ICHG_BAT_MSB,
kDIALOG_CHARGE_CONTROL_TIME = kD2231_CHG_CTRL_A,
kDIALOG_OTP_ISET_BAT_MSB = kD2231_ICHG_BAT_MAX_MSB,
kDIALOG_CHARGE_CONTROL_EN = kD2231_CHG_CTRL_B,
kD2231_ICHG_BAT_ACTUAL_MSB = 0x0203,
kD2231_ICHG_BAT_ACTUAL_LSB = 0x0204,
kDIALOG_CHARGE_STATUS_MSB = kD2231_ICHG_BAT_ACTUAL_MSB,
kD2231_CHG_VSET_TRIM = 0x0205,
kD2231_CHG_BAT_TRIM0 = 0x0206,
kD2231_CHG_BAT_TRIM1 = 0x0207,
kD2231_CHG_BAT_TRIM2 = 0x0208,
kD2231_CHG_BAT_TRIM3 = 0x0209,
kD2231_CHG_BAT_TRIM4 = 0x020a,
kD2231_CHG_BAT_TRIM5 = 0x020b,
kD2231_CHG_TRIM3 = 0x020c,
kD2231_CHG_TRIM4 = 0x020d,
kD2231_OVP_TRIM1 = 0x020e,
kD2231_OVP_TRIM3 = 0x0210,
kD2231_OVP_TRIM4 = 0x0211,
kD2231_OVP_TRIM6 = 0x0213,
kD2231_OVP_TRIM7 = 0x0214,
kD2231_OVP_TRIM9 = 0x0216,
kD2231_OVP_TRIM10 = 0x0217,
kD2231_OVP_TRIM11 = 0x0218,
kD2231_OVP_TRIM12 = 0x0219,
kD2231_OVP_TRIM13 = 0x021a,
kD2231_OVP_TRIM14 = 0x021b,
kD2231_OVP_ILIM_SET_MIN = 0x021c,
kD2231_OVP_DIGI_TRIM1 = 0x021d,
kD2231_OVP_DIGI_TRIM2 = 0x021e,
kD2231_OVP_DIGI_TRIM3 = 0x021f,
kD2231_ICHG_END = 0x0220,
kDIALOG_TBAT_0 = 0x0221,
kDIALOG_TBAT_1 = 0x0222,
kDIALOG_TBAT_2 = 0x0223,
kDIALOG_TBAT_3 = 0x0224,
kDIALOG_TBAT_4 = 0x0225,
kDIALOG_TBAT_MAX = 0x0226,
kD2231_TBAT_THYS_1_0 = 0x0227,
kD2231_TBAT_THYS_3_2 = 0x0228,
kD2231_TBAT_THYS_MAX_4 = 0x0229,
kD2231_ICHG_TBAT_MSB_0 = 0x022a,
kD2231_ICHG_TBAT_LSB_0 = 0x022b,
kD2231_ICHG_TBAT_MSB_1 = 0x022c,
kD2231_ICHG_TBAT_LSB_1 = 0x022d,
kD2231_ICHG_TBAT_MSB_2 = 0x022e,
kD2231_ICHG_TBAT_LSB_2 = 0x022f,
kD2231_ICHG_TBAT_MSB_3 = 0x0230,
kD2231_ICHG_TBAT_LSB_3 = 0x0231,
kD2231_ICHG_TBAT_MSB_4 = 0x0232,
kD2231_ICHG_TBAT_LSB_4 = 0x0233,
kD2231_ICHG_LOW_VBAT_0 = 0x0234,
kD2231_ICHG_LOW_VBAT_1 = 0x0235,
kD2231_ICHG_LOW_VBAT_2 = 0x0236,
kD2231_ICHG_LOW_VBAT_3 = 0x0237,
kD2231_ICHG_LOW_VBAT_4 = 0x0238,
kD2231_ICHG_LOW_VBAT_5 = 0x0239,
kD2231_ICHG_LOW_VBAT_6 = 0x023a,
kD2231_ICHG_LOW_VBAT_7 = 0x023b,
kD2231_ICHG_AVG = 0x023d,
kD2231_ICHG6A_AVG = 0x023d,
kDIALOG_ICHG_AVG = kD2231_ICHG_AVG,
kD2231_CHG_BUCK_MODE = 0x023e,
kD2231_CHG_BUCK_FSM_TRIM0 = 0x023f,
kD2231_CHG_BUCK_FSM_TRIM1 = 0x0240,
kD2231_CHG_BUCK_FSM_TRIM2 = 0x0241,
kD2231_CHG_BUCK_FSM_TRIM3 = 0x0242,
kD2231_CHG_BUCK_FSM_TRIM4 = 0x0243,
kD2231_CHG_BUCK_CLK_TRIM = 0x0244,
kD2231_CHG_BUCK_ANA_TRIM0 = 0x0245,
kD2231_CHG_BUCK_ANA_TRIM1 = 0x0246,
kD2231_CHG_BUCK_ANA_TRIM2 = 0x0247,
kD2231_CHG_BUCK_ANA_TRIM3 = 0x0248,
kD2231_CVT_CONTROL = 0x024c,
kD2231_CVT_ISET_0_MSB = 0x024d,
kD2231_CVT_ISET_0_LSB = 0x024e,
kD2231_CVT_ISET_1_MSB = 0x024f,
kD2231_CVT_ISET_1_LSB = 0x0250,
kD2231_CVT_ISET_2_MSB = 0x0251,
kD2231_CVT_ISET_2_LSB = 0x0252,
kD2231_CVT_ISET_3_MSB = 0x0253,
kD2231_CVT_ISET_3_LSB = 0x0254,
kD2231_CVT_ISET_4_MSB = 0x0255,
kD2231_CVT_ISET_4_LSB = 0x0256,
kD2231_CVT_ISET_5_MSB = 0x0257,
kD2231_CVT_ISET_5_LSB = 0x0258,
kD2231_CVT_ISET_6_MSB = 0x0259,
kD2231_CVT_ISET_6_LSB = 0x025a,
kD2231_CVT_ISET_7_MSB = 0x025b,
kD2231_CVT_ISET_7_LSB = 0x025c,
kD2231_CVT_VSET_0_MSB = 0x025d,
kD2231_CVT_VSET_0_LSB = 0x025e,
kD2231_CVT_VSET_1_MSB = 0x025f,
kD2231_CVT_VSET_1_LSB = 0x0260,
kD2231_CVT_VSET_2_MSB = 0x0261,
kD2231_CVT_VSET_2_LSB = 0x0262,
kD2231_CVT_VSET_3_MSB = 0x0263,
kD2231_CVT_VSET_3_LSB = 0x0264,
kD2231_CVT_VSET_4_MSB = 0x0265,
kD2231_CVT_VSET_4_LSB = 0x0266,
kD2231_CVT_VSET_5_MSB = 0x0267,
kD2231_CVT_VSET_5_LSB = 0x0268,
kD2231_CVT_VSET_6_MSB = 0x0269,
kD2231_CVT_VSET_6_LSB = 0x026a,
kD2231_CVT_VSET_7_MSB = 0x026b,
kD2231_CVT_VSET_7_LSB = 0x026c,
kD2231_CVT_CC_CV_1_TR1_SEL = 0x026d,
kD2231_CVT_CC_CV_1_TR2_SEL = 0x026e,
kD2231_CVT_CC_CV_1_TR3_SEL = 0x026f,
kD2231_CVT_CC_CV_1_TR4_SEL = 0x0270,
kD2231_CVT_CC_CV_1_TR5_SEL = 0x0271,
kD2231_CVT_CC_CV_2_TR1_SEL = 0x0272,
kD2231_CVT_CC_CV_2_TR2_SEL = 0x0273,
kD2231_CVT_CC_CV_2_TR3_SEL = 0x0274,
kD2231_CVT_CC_CV_2_TR4_SEL = 0x0275,
kD2231_CVT_CC_CV_2_TR5_SEL = 0x0276,
kD2231_CVT_CC_CV_3_TR1_SEL = 0x0277,
kD2231_CVT_CC_CV_3_TR2_SEL = 0x0278,
kD2231_CVT_CC_CV_3_TR3_SEL = 0x0279,
kD2231_CVT_CC_CV_3_TR4_SEL = 0x027a,
kD2231_CVT_CC_CV_3_TR5_SEL = 0x027b,
kD2231_CVT_CC_CV_4_TR1_SEL = 0x027c,
kD2231_CVT_CC_CV_4_TR2_SEL = 0x027d,
kD2231_CVT_CC_CV_4_TR3_SEL = 0x027e,
kD2231_CVT_CC_CV_4_TR4_SEL = 0x027f,
kD2231_CVT_CC_CV_4_TR5_SEL = 0x0280,
kD2231_CVT_ISET_DEF_0_MSB = 0x0281,
kD2231_CVT_ISET_DEF_0_LSB = 0x0282,
kD2231_CVT_ISET_DEF_1_MSB = 0x0283,
kD2231_CVT_ISET_DEF_1_LSB = 0x0284,
kD2231_CVT_ISET_DEF_2_MSB = 0x0285,
kD2231_CVT_ISET_DEF_2_LSB = 0x0286,
kD2231_CVT_ISET_DEF_3_MSB = 0x0287,
kD2231_CVT_ISET_DEF_3_LSB = 0x0288,
kD2231_CVT_VSET_DEF_0_MSB = 0x0289,
kD2231_CVT_VSET_DEF_0_LSB = 0x028a,
kD2231_CVT_VSET_DEF_1_MSB = 0x028b,
kD2231_CVT_VSET_DEF_1_LSB = 0x028c,
kD2231_CVT_VSET_DEF_2_MSB = 0x028d,
kD2231_CVT_VSET_DEF_2_LSB = 0x028e,
kD2231_CVT_VBAT_CONV_K = 0x028f,
kD2231_CVT_VBAT_CONV_OFF_MSB = 0x0290,
kD2231_CVT_VBAT_CONV_OFF_LSB = 0x0291,
kD2231_CVT_IBAT_CONV_K = 0x0292,
kD2231_CVT_VBAT_CONV_OFF = 0x0293,
kD2231_CVT_ACTUAL_ICHG = 0x0294,
kD2231_CVT_ACTUAL_VSET = 0x0295,
kD2231_CVT_ACTUAL_STATUS = 0x0296,
// GPADC Control and Results
kDIALOG_ADC_CONTROL = 0x03ec,
kDIALOG_ADC_CONTROL2 = 0x03ed,
kD2231_ADC_CTRL3 = 0x03ee,
kDIALOG_ADC_LSB = 0x03ef,
kDIALOG_ADC_MSB = 0x03f0,
kD2231_ADC_TEMP_CTRL1 = 0x03f1,
kD2231_ADC_FSM_TRIM0 = 0x03f2,
kD2231_ADC_FSM_TRIM1 = 0x03f3,
kD2231_ADC_FSM_TRIM2 = 0x03f4,
kD2231_ADC_FSM_TRIM3 = 0x03f5,
kD2231_ADC_ANA_TRIM0 = 0x03f6,
kD2231_ADC_ANA_TRIM1 = 0x03f7,
kD2231_VCC_MAIN_MON = 0x03f8,
kDIALOG_IBUS_ACCUM1 = 0x03fa,
kDIALOG_IBUS_ACCUM2 = 0x03fb,
kDIALOG_IBUS_ACCUM3 = 0x03fc,
kDIALOG_VBUS_ACCUM1 = 0x03fd,
kDIALOG_VBUS_ACCUM2 = 0x03fe,
kDIALOG_VBUS_ACCUM3 = 0x03ff,
kDIALOG_TDIE_ACCUM1 = 0x0400,
kDIALOG_TDIE_ACCUM2 = 0x0401,
kDIALOG_TDIE_ACCUM3 = 0x0402,
kDIALOG_IBUS_COUNT1 = 0x0403,
kDIALOG_IBUS_COUNT2 = 0x0404,
kD2231_IBUSCAL_1 = 0x0405,
kD2231_IBUSCAL_2 = 0x0406,
kD2231_IBUSCAL_3 = 0x0407,
kD2231_IBUSCAL_4 = 0x0408,
kD2231_IBUSCAL_5 = 0x0409,
kD2231_IBUSCAL_6 = 0x040a,
kD2231_IBUSCAL_7 = 0x040b,
kD2231_IBUSCAL_8 = 0x040c,
// Reserved Spare Registers
kD2231_SPARE_RW0 = 0x1080,
kD2231_SPARE_RW_LAST = 0x1007,
kD2231_DEBUG_DIG_3 = 0x7223,
kD2231_REG_OTP0 = 0x7c00,
kD2231_REG_OTP511 = 0x7dff,
// Misc
kDIALOG_TEST_ACCESS = 0x7000,
kDIALOG_TEST_ACCESS_ENA = 0x1D,
kDIALOG_TEST_ACCESS_DIS = 0x00,
};
enum {
// <rdar://problem/21879203> J99 EVT not recognizing lightning connection
kDIALOG_OTP_RELOAD_CONF = kD2231_SYS_CONF_E,
kDIALOG_OTP_SKIP_RELOAD_TO_ACT = (1<<6),
};
// -------------------------------------------------------------------
//
// -------------------------------------------------------------------
// Synthetic Accumulator Registers
enum {
kDIALOG_ACCUMULATOR_SEL_COUNT = 2,
kDIALOG_IBUS_ACCUMULATOR = 0,
kDIALOG_VBUS_ACCUMULATOR = 1,
kDIALOG_IBUCK0_ACCUMULATOR = 0,
kDIALOG_IBUCK1_ACCUMULATOR = 0,
};
enum {
kD2231_EVENT_A_TBAT = (1 << 7),
kD2231_EVENT_A_VBUS_EXT_REM = (1 << 6),
kD2231_EVENT_A_VDD_LOW = (1 << 5),
kD2231_EVENT_A_CHG_HV_ATT = (1 << 4),
kD2231_EVENT_A_VBUS_EXT_DET = (1 << 3),
kD2231_EVENT_A_HV_MODE = (1 << 2),
kD2231_EVENT_A_CHG_BUCK_LIMITED = (1 << 1),
kD2231_EVENT_A_VCENTER_DET = (1 << 0),
};
enum {
kD2231_EVENT_C_CHG_SLOW = (1 << 7),
kD2231_EVENT_C_CHG_BUCK_FLG = (1 << 6),
kD2231_EVENT_C_CHG_ABCC_ACT = (1 << 5),
kD2231_EVENT_C_CHG_TIMEOUT = (1 << 4),
kD2231_EVENT_C_CHG_PRECHG_TIMEOUT = (1 << 3),
kD2231_EVENT_C_CHG_END = (1 << 2),
kD2231_EVENT_C_CHG_FAST = (1 << 1),
kD2231_EVENT_C_CHG_PRE = (1 << 0),
};
enum {
kD2231_EVENT_D_GPIO6 = (1 << 5),
kD2231_EVENT_D_GPIO5 = (1 << 4),
kD2231_EVENT_D_GPIO4 = (1 << 3),
kD2231_EVENT_D_GPIO3 = (1 << 2),
kD2231_EVENT_D_GPIO2 = (1 << 1),
kD2231_EVENT_D_GPIO1 = (1 << 0),
};
enum {
kD2231_EVENT_I_VDDREF_CHG_FALL = (1 << 5),
kD2231_EVENT_I_TMID_DIE_FALL = (1 << 4),
kD2231_EVENT_I_TLINCHG_FALL = (1 << 3),
kD2231_EVENT_I_TVCENTER2_FALL = (1 << 2),
kD2231_EVENT_I_TVCENTER1_FALL = (1 << 1),
kD2231_EVENT_I_TBUCK_FALL = (1 << 0),
};
enum {
kD2231_EVENT_J_VDDREF_CHG_RISE = (1 << 5),
kD2231_EVENT_J_TMID_DIE_RISE = (1 << 4),
kD2231_EVENT_J_TLINCHG_RISE = (1 << 3),
kD2231_EVENT_J_TVCENTER2_RISE = (1 << 2),
kD2231_EVENT_J_TVCENTER1_RISE = (1 << 1),
kD2231_EVENT_J_TBUCK_RISE = (1 << 0),
};
enum {
kD2231_EVENT_L_FAULTY_ADAPTER = (1 << 6),
kD2231_EVENT_L_IBUS_OVERFLOW = (1 << 5),
kD2231_EVENT_L_VBUS_OV = (1 << 4),
kD2231_EVENT_L_CVT_RESTART = (1 << 3),
kD2231_EVENT_L_CVT_INCORRECT_CFG = (1 << 2),
kD2231_EVENT_L_EOMC = (1 << 1),
};
enum {
kD2231_STATUS_A_TBAT = (1 << 7),
kD2231_STATUS_A_VDD_LOW = (1 << 5),
kD2231_STATUS_A_CHG_HV_ATT = (1 << 4),
kD2231_STATUS_A_VBUS_EXT_DET = (1 << 3),
kD2231_STATUS_A_HV_MODE = (1 << 2),
kD2231_STATUS_A_CHG_BUCK_ILIMITED = (1 << 1),
kD2231_STATUS_A_VCENTER_DET = (1 << 0),
};
enum {
kD2231_STATUS_C_CHG_SLOW = (1 << 7),
kD2231_STATUS_C_CHG_BUCK_FLG = (1 << 6),
kD2231_STATUS_C_CHG_ABCC_ACT = (1 << 5),
kD2231_STATUS_C_CHG_TIMEOUT = (1 << 4),
kD2231_STATUS_C_CHG_PRECHG_TIMEOUT = (1 << 3),
kD2231_STATUS_C_CHG_END = (1 << 2),
kD2231_STATUS_C_CHG_FAST = (1 << 1),
kD2231_STATUS_C_CHG_PRE = (1 << 0),
};
enum {
kD2231_STATUS_D_GPIO6 = (1 << 5),
kD2231_STATUS_D_GPIO5 = (1 << 4),
kD2231_STATUS_D_GPIO4 = (1 << 3),
kD2231_STATUS_D_GPIO3 = (1 << 2),
kD2231_STATUS_D_GPIO2 = (1 << 1),
kD2231_STATUS_D_GPIO1 = (1 << 0),
};
enum {
kD2231_STATUS_I_VDDREF_CHG_FALL = (1 << 5),
kD2231_STATUS_I_TMID_DIE_FALL = (1 << 4),
kD2231_STATUS_I_TLINCHG_FALL = (1 << 3),
kD2231_STATUS_I_TVCENTER2_FALL = (1 << 2),
kD2231_STATUS_I_TVCENTER1_FALL = (1 << 1),
kD2231_STATUS_I_TBUCK_FALL = (1 << 0),
};
enum {
kD2231_STATUS_J_VDDREF_CHG_RISE = (1 << 5),
kD2231_STATUS_J_TMID_DIE_RISE = (1 << 4),
kD2231_STATUS_J_TLINCHG_RISE = (1 << 3),
kD2231_STATUS_J_TVCENTER2_RISE = (1 << 2),
kD2231_STATUS_J_TVCENTER1_RISE = (1 << 1),
kD2231_STATUS_J_TBUCK_RISE = (1 << 0),
};
enum {
kD2231_STATUS_L_FAULTY_ADAPTER = (1 << 6),
kD2231_STATUS_L_IBUS_OVERFLOW = (1 << 5),
kD2231_STATUS_L_VBUS_OV = (1 << 4),
kD2231_STATUS_L_CVT_INCORRECT_CFG = (1 << 2),
};
enum {
kD2231_STATUS_M_CHG_ATT = (1 << 0),
};
enum {
kD2231_CHG_CTRL_B_HV_CHG_ALLOW = ( 1<<1 ),
kD2231_CHG_CTRL_B_HV_CHG_ALLOW_MASK = ( 1<<1 ),
};
enum {
// N.B. as above, event register letters do not directly map to indexes
kDIALOG_EVENT_HOLD_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_MENU_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_RINGER_BUTTON_MASK= kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_BUTTON4_MASK= kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_BUTTONS_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ALARM_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ACC_DET_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(0, kD2231_EVENT_A_VBUS_EXT_DET),
kDIALOG_EVENT_VBUS_EXT_REM_MASK = EVENT_FLAG_MAKE(0, kD2231_EVENT_A_VBUS_EXT_REM),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(5, kD2231_EVENT_L_EOMC),
kDIALOG_EVENT_HIB_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ABCC_MASK = EVENT_FLAG_MAKE(1, kD2231_EVENT_C_CHG_ABCC_ACT),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_C_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(0, kD2231_EVENT_A_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_D_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_D_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_D_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_D_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_D_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(2, kD2231_EVENT_D_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO8_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO9_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO10_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO11_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO12_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO13_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO14_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO15_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO16_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO17_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO18_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO19_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO20_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO21_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_HOLD_DBL_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_MENU_DBL_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_RINGER_DBL_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_VHP_DET_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
};
enum {
// N.B. as above, status register letters do not directly map to indexes
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(0, kD2231_STATUS_A_VBUS_EXT_DET),
kDIALOG_STATUS_VBUS_MASK = STATUS_FLAG_MAKE(0, kD2231_STATUS_A_VCENTER_DET),
kDIALOG_STATUS_FW_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_STATUS_ACC_DET_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(1, kD2231_STATUS_C_CHG_PRE | kD2231_STATUS_C_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(1, kD2231_STATUS_C_CHG_TIMEOUT),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(1, kD2231_STATUS_C_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(0, kD2231_STATUS_A_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(6, kD2231_STATUS_M_CHG_ATT),
kDIALOG_STATUS_ABCC_MASK = STATUS_FLAG_MAKE(1, kD2231_STATUS_C_CHG_ABCC_ACT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(2 + (gpio)/8, (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {0, 0, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, kD2231_STATUS_C_CHG_PRE | kD2231_STATUS_C_CHG_FAST, 0, 0, 0, 0};
enum {
kD2231_EVENT_A_WAKEMASK = (kD2231_EVENT_A_VBUS_EXT_DET | kD2231_EVENT_A_VBUS_EXT_REM | kD2231_EVENT_A_VCENTER_DET),
kD2231_EVENT_C_WAKEMASK = (kD2231_EVENT_C_CHG_TIMEOUT | kD2231_EVENT_C_CHG_PRECHG_TIMEOUT | kD2231_EVENT_C_CHG_END),
kD2231_EVENT_D_WAKEMASK = (kD2231_EVENT_D_GPIO6 | kD2231_EVENT_D_GPIO5 | kD2231_EVENT_D_GPIO4 | kD2231_EVENT_D_GPIO3 | kD2231_EVENT_D_GPIO2 | kD2231_EVENT_D_GPIO1),
kD2231_EVENT_I_WAKEMASK = 0,
kD2231_EVENT_J_WAKEMASK = 0,
kD2231_EVENT_L_WAKEMASK = 0,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
~kD2231_EVENT_A_WAKEMASK,
~kD2231_EVENT_C_WAKEMASK,
~kD2231_EVENT_D_WAKEMASK,
~kD2231_EVENT_I_WAKEMASK,
~kD2231_EVENT_J_WAKEMASK,
~kD2231_EVENT_L_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD2231_EVENT_A_WAKEMASK,
kD2231_EVENT_C_WAKEMASK,
kD2231_EVENT_D_WAKEMASK,
kD2231_EVENT_I_WAKEMASK,
kD2231_EVENT_J_WAKEMASK,
kD2231_EVENT_L_WAKEMASK,
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
kD2231_EVENT_A_VBUS_EXT_DET | kD2231_EVENT_A_VCENTER_DET,
0,
0,
0,
0,
0,
};
static const eventRegisters kDialogEventUSBMask = {
// in d2231.h only include kD2231_EVENT_A_VBUS_EXT_DET: VCENTER can come and go while charger still usable
kD2231_EVENT_A_VBUS_EXT_DET,
kD2231_EVENT_C_CHG_ABCC_ACT,
0,
0,
0,
0,
};
static const eventRegisters kDialogEventFWMask = {
0,
0,
0,
0,
0,
0,
};
enum {
kDialogEventPwrsupplyCount = 2,
kDialogEventUSBCount = 2,
kDialogEventFWCount = 0,
};
enum {
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = (1 << 2),
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND,
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = 0,
};
enum {
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_WDOG = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_1 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MIN = 0x08,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x0a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x14,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x32,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x64,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0xc8,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2100 = 0xd2,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2560 = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MAX = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0xff,
};
enum {
kDIALOG_CHARGE_BUCK_CONTROL_MIN = 80,
kDIALOG_CHARGE_BUCK_CONTROL_STEP_PER_100MA = 10,
kDIALOG_CHARGE_BUCK_CONTROL_MAX = 2550,
};
enum {
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3ff,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_B_CHG_SUSP = (1 << 5),
kDIALOG_CHARGE_CONTROL_CHG_HIB = 0,
};
enum {
kDIALOG_CHARGE_CONTROL_STEP = 10,
kDIALOG_CHARGE_CONTROL_MAX = 6390,
};
enum {
kDIALOG_CHARGE_CONTROL_ALT_USB_DIS = (1 << 6),
kDIALOG_CHARGE_CONTROL_CHG_BUCK_EN = (1 << 7),
};
enum {
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = 0xFF,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = 0x00, // TODO
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
enum {
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
kDIALOG_ADC_LSB_MANADC_ERROR = (1 << 6),
};
enum {
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 7),
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0x1f << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = (0 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH_1A = (1 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = (2 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = (3 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_LG = (4 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VIBUS = kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_LG,
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN_P = (5 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN_N = (6 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = (7 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_HG = (8 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = (10 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VCENTER_TEMP1 = (13 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LINCHG_TEMP = (14 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_CHG_BUCK_TEMP = (15 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_VCENTER_TEMP2 = (16 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_MID_DIE_TEMP = (17 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_LV_LDO_TEMP = (18 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_START = kDIALOG_ADC_CONTROL_MUX_SEL_VCENTER_TEMP1,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_END = kDIALOG_ADC_CONTROL_MUX_SEL_LV_LDO_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_ICH_6A = (29 << 0),
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = kDIALOG_ADC_CONTROL_MUX_SEL_ICH_6A,
kDIALOG_ADC_CONTROL2_AUTO_VDD_OUT_EN = (1 << 7),
kDIALOG_ADC_CONTROL2_ICH6A_EN = (1 << 1),
kDIALOG_ADC_CONTROL2_IBUS_EN = (1 << 0),
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0,
kDIALOG_ADC_CONTROL2_DEFAULTS = 0,
};
enum {
kDIALOG_ADC_RESOLUTION_BITS = 10,
kDIALOG_ADC_FULL_SCALE_MV = 1500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40,
};
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (1 << 6) | (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (1 << 6),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (0 << 6) | (0 << 1),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (0 << 6) | (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = kDIALOG_SYS_GPIO_DIRECTION_OUT, // not supported
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_OUT) == kDIALOG_SYS_GPIO_DIRECTION_OUT)
#define NUM_LDOS 0
static const struct ldo_params ldo_d2231[NUM_LDOS] = {
};
#define LDOP ldo_d2231
#endif /* __DIALOG_D2231_H */
drivers/dialog/pmu/d2238.h
+1190
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2255.h
+1363
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2257.h
+1521
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/d2355.h
+844
View File
@@ -0,0 +1,844 @@
/* Euphrates / Arno
* <rdar://problem/18528237> Euphrates: Specification and Data-sheet from Vendor (Dialog)
*
* NOTE: Arno is d2370
*
* Copyright (C) 2014 Apple Inc. All rights reserved.
*
* This document is the property of Apple Inc.
* It is considered confidential and proprietary.
*
* This document may not be reproduced or transmitted in any form,
* in whole or in part, without the express written permission of
* Apple Inc.
*/
#ifndef __DIALOG_D2355_H
#define __DIALOG_D2355_H
#define PMU_HAS_SWI 0
#define PMU_HAS_DWI 0
#define PMU_HAS_LCM_LDO 0
#define PMU_HAS_BIST_ADC 0
#define PMU_HAS_CHG_ABCC_FLAG 1
#define PMU_HAS_VIB 0
#define PMU_HAS_RAM 0
#define PMU_HAS_WLED 0
#define PMU_HAS_32K_RTC 0
// TODO: enable accumulators
#define PMU_HAS_ACCUMULATORS 0
#define PMU_HAS_SYS 0
#define PMU_HAS_WDT 0
#define PMU_HAS_CHARGER 1
#define PMU_HAS_ISET_BAT_2BYTES 1
#define PMU_DRV_NEW_DRIVER 1
enum {
kDIALOG_ADDR_R = 0xeb,
kDIALOG_ADDR_W = 0xea,
kDIALOG_REG_BYTES = 2,
};
enum {
kDIALOG_EVENT_COUNT = 10,
kDIALOG_STATUS_COUNT = 10,
kDIALOG_FAULTLOG_COUNT = 3,
kDIALOG_CHIPID_COUNT = 9,
kDIALOG_GPIO_COUNT = 8,
};
#include "dCommon.h"
// ---------------------------------
// Chip Identification
// ---------------------------------
enum {
kDIALOG_MASK_REV_CODE = 0x0000,
kDIALOG_TRIM_REL_CODE = 0x0001,
kDIALOG_PLATFORM_ID = 0x0002,
kDIALOG_PARITY = 0x0003,
kDIALOG_DEVICE_ID1 = 0x0004,
kDIALOG_DEVICE_ID2 = 0x0005,
kDIALOG_DEVICE_ID3 = 0x0006,
kDIALOG_DEVICE_ID4 = 0x0007,
kDIALOG_DEVICE_ID5 = 0x0008,
kDIALOG_CHIP_ID = kDIALOG_MASK_REV_CODE,
};
// ---------------------------------
// System Configuration
// ---------------------------------
// ---------------------------------
// Faultlog (virtual)
// ---------------------------------
enum {
kD2355_FAULT_LOG_A = 0x0050,
kD2355_FAULT_LOG_B,
kD2355_FAULT_LOG_C,
kDIALOG_FAULT_LOG = kD2355_FAULT_LOG_A,
};
// ---------------------------------
// Event Register (virtual)
// ---------------------------------
enum {
kD2355_EVENT_A = 0x0060,
kD2355_EVENT_B,
kD2355_EVENT_C,
kD2355_EVENT_D,
kD2355_EVENT_E,
kD2355_EVENT_F,
kD2355_EVENT_G,
kD2355_EVENT_H,
kD2355_EVENT_I,
kD2355_EVENT_J,
kDIALOG_EVENT_A = kD2355_EVENT_A,
};
// ---------------------------------
// Status Register (virtual)
// ---------------------------------
enum {
kD2355_STATUS_A = 0x0080,
kD2355_STATUS_B,
kD2355_STATUS_C,
kD2355_STATUS_D,
kD2355_STATUS_E,
kD2355_STATUS_F,
kD2355_STATUS_G,
kD2355_STATUS_H,
kD2355_STATUS_I,
kD2355_STATUS_J,
kDIALOG_STATUS_A = kD2355_STATUS_A,
};
// ---------------------------------
// IRQ Mask Register (virtual)
// ---------------------------------
enum {
kD2355_IRQ_MASK_A = 0x0a0,
kD2355_IRQ_MASK_B,
kD2355_IRQ_MASK_C,
kD2355_IRQ_MASK_D,
kD2355_IRQ_MASK_E,
kD2355_IRQ_MASK_F,
kD2355_IRQ_MASK_G,
kD2355_IRQ_MASK_H,
kD2355_IRQ_MASK_I,
kD2355_IRQ_MASK_J,
kDIALOG_IRQ_MASK_A = kD2355_IRQ_MASK_A,
};
// ---------------------------------
// MAIN FSM & IRQ Control
// ---------------------------------
enum {
kD2355_MFSM_FAULT_LOG1 = 0x0100,
};
enum {
kD2355_MFSM_CONF_A = 0x0140,
kD2355_MFSM_CONF_B,
kD2355_MFSM_CONF_C,
};
// ---------------------------------
// GPIO: control
// ---------------------------------
enum {
kD2355_GPIO_GPIO1 = 0x01c0,
kD2355_GPIO_GPIO2,
kD2355_GPIO_GPIO3,
kD2355_GPIO_GPIO4,
kD2355_GPIO_GPIO5,
kD2355_GPIO_GPIO6,
kD2355_GPIO_GPIO7,
kD2355_GPIO_GPIO8 = 0x01c7,
};
// ---------------------------------
// GPIO: Event/Status/IRQ_CTL
// ---------------------------------
// ---------------------------------
// GPIO: Debouncer Configuration
// ---------------------------------
// ---------------------------------
// GPADC
// ---------------------------------
enum {
kD2355_ADC_EVENT_A = 0x0310,
kD2355_ADC_EVENT_B,
kD2355_ADC_EVENT_C,
kD2355_ADC_STATUS_A = 0x320,
kD2355_ADC_STATUS_B,
kD2355_ADC_STATUS_C,
kD2355_ADC_IRQ_MASK_A = 0x0330,
kD2355_ADC_IRQ_MASK_B,
kD2355_ADC_IRQ_MASK_C,
};
// ---------------------------------
// Temperature & Sensor Control
// ---------------------------------
enum {
kD2355_T_OFFSET_MSB = 0x033f,
kD2355_T_OFFSET_LSB = 0x0340,
};
// ---------------------------------
// Charging Control
// ---------------------------------
enum {
kD2355_ADC_CHG_TRIM4 = 0x341,
kD2355_ADC_ICHG_END,
kD2355_ADC_TBAT_0,
kD2355_ADC_TBAT_1,
kD2355_ADC_TBAT_2,
kD2355_ADC_TBAT_3,
kD2355_ADC_TBAT_4,
kD2355_ADC_TBAT_MAX,
// Hysteresis,
// ...
kD2355_ADC_ICHG_AVG = 0x035e,
kD2355_ADC_ICHG6A_AVG = 0x035f,
kD2355_ADC_ACTUAL_TBAT_BAND,
};
// ---------------------------------
// GPADC Control and Result
// ---------------------------------
enum {
kD2355_ADC_CTRL1 = 0x0361,
kD2355_ADC_RES_LSB,
kD2355_ADC_RES_MSB,
kD2355_ADC_CTRL2,
kD2355_ADC_CTRL3,
kD2355_ADC_FSM_TRIM0,
kD2355_ADC_FSM_TRIM1,
kD2355_ADC_FSM_TRIM2,
kD2355_ADC_FSM_SAR,
kD2355_ADC_ANA_TRIM0,
kD2355_ADC_ANA_TRIM1,
};
// ---------------------------------
// CHARGER SYSTEM
// ---------------------------------
// Event, Status & IRQ Control
enum {
kD2355_CHG_EVENT_A = 0x0410,
kD2355_CHG_EVENT_B,
kD2355_CHG_EVENT_C,
kD2355_CHG_EVENT_D,
kD2355_CHG_STATUS_A = 0x0420,
kD2355_CHG_STATUS_B,
kD2355_CHG_STATUS_C,
kD2355_CHG_STATUS_D,
kD2355_CHG_IRQ_MASK_A =0x0430,
kD2355_CHG_IRQ_MASK_B,
kD2355_CHG_IRQ_MASK_C,
kD2355_CHG_IRQ_MASK_D,
};
enum {
kD2355_CHG_CTRL_A = 0x0440,
kD2355_CHG_CTRL_B = 0x0441,
kD2355_CHG_CTRL_C,
kD2355_CHG_CTRL_D = 0x0443,
kD2355_CHG_CTRL_E,
kD2355_CHG_CTRL_F,
kD2355_CHG_TIME = 0x0447,
kD2355_CHG_TIME_PRE,
// USB Current Limit
kD2355_CHG_ISET_BUCK = 0x044e,
kD2355_CHG_ISET_BUCK_SHADOW,
kD2355_CHG_ISET_BUCK_LV_ABSMAX,
kD2355_CHG_ISET_BUCK_HV_ABSMAX,
kD2355_CHG_ISET_BUCK_ACTUAL = 0x0452,
kD2355_CHG_ISET_BUCK_ALT,
// Battery Current Limit
kD2355_CHG_ICHG_PRE_MSB = 0x0454,
kD2355_CHG_ICHG_PRE_LSB,
kD2355_CHG_ICHG_BAT_MSB = 0x0456,
kD2355_CHG_ICHG_BAT_LSB,
kD2355_CHG_ICHG_BAT_MAX_MSB = 0x0458,
kD2355_CHG_ICHG_BAT_MAX_LSB,
// ??
kD2355_CHG_ICHG_BAT_ACTUAL_MSB = 0x045b,
kD2355_CHG_ICHG_BAT_ACTUAL_LSB,
};
// ---------------------------------
// Misc/DEBUG
// ---------------------------------
enum {
kDIALOG_TEST_ACCESS = 0x0B10,
kDIALOG_TEST_ACCESS_ENA = 0x1D,
kDIALOG_TEST_ACCESS_DIS = 0x00,
};
enum {
// <rdar://problem/21879203> J99 EVT not recognizing lightning connection
kDIALOG_OTP_RELOAD_CONF = kD2355_MFSM_CONF_A,
kDIALOG_OTP_SKIP_RELOAD_TO_ACT = (1<<4),
};
// ---------------------------------
// Events
// ---------------------------------
#if 0
// Synthetic Accumulator Registers
enum {
kDIALOG_ACCUMULATOR_SEL_COUNT = 2,
kDIALOG_IBUS_ACCUMULATOR = 0,
kDIALOG_VBUS_ACCUMULATOR = 1,
kDIALOG_IBUCK0_ACCUMULATOR = 0,
kDIALOG_IBUCK1_ACCUMULATOR = 0,
};
#endif
// ---------------------------------
// Events (virtual)
// ---------------------------------
enum {
// 0: DEB_EVENT_A
kD2355_EVENT_A_GPIO8 = (1 << 7),
kD2355_EVENT_A_GPIO7 = (1 << 6),
kD2355_EVENT_A_GPIO6 = (1 << 5),
kD2355_EVENT_A_GPIO5 = (1 << 4),
kD2355_EVENT_A_GPIO4 = (1 << 3),
kD2355_EVENT_A_GPIO3 = (1 << 2),
kD2355_EVENT_A_GPIO2 = (1 << 1),
kD2355_EVENT_A_GPIO1 = (1 << 0),
// 1: DEB_EVENT_B
kD2355_EVENT_B_CHG_BG_HIGH_TEMP = (1 <<1),
kD2355_EVENT_B_CHG_VBUS_ATT = (1 <<0),
// 2: ADC_EVENT_A
kD2355_EVENT_C_PBUS_CNT_OVERFLOW= (1 << 4),
kD2355_EVENT_C_EOMC = (1 << 3),
kD2355_EVENT_C_IBUS_OVERFLOW = (1 << 2),
kD2355_EVENT_C_TBAT = (1 << 1),
kD2355_EVENT_C_VDD_LOW = (1 << 0),
// 3: ADC_EVENT_B
kD2355_EVENT_D_VDDREF_CHG_FALL = (1 << 5),
kD2355_EVENT_D_TMID_DIE_FALL = (1 << 4),
kD2355_EVENT_D_TLINCHG_FALL = (1 << 3),
kD2355_EVENT_D_TVCENTER2_FALL = (1 << 2),
kD2355_EVENT_D_TVCENTER1_FALL = (1 << 1),
kD2355_EVENT_D_TCBUCK_FALL = (1 << 0),
// 4: ADC_EVENT_C
kD2355_EVENT_E_VDDREF_CHG_RISE = (1 << 5),
kD2355_EVENT_E_TMID_DIE_RISE = (1 << 4),
kD2355_EVENT_E_TLINCHG_RISE = (1 << 3),
kD2355_EVENT_E_TVCENTER2_RISE = (1 << 2),
kD2355_EVENT_E_TVCENTER1_RISE = (1 << 1),
kD2355_EVENT_E_TBUCK_RISE = (1 << 0),
// 5: CHG_EVENT_A
kD2355_EVENT_F_CV_LOOP_AVERAGE_SATURATED = (1 << 7),
kD2355_EVENT_F_FAULTY_ADAPTER = (1 << 6),
kD2355_EVENT_F_VBUS_OV = (1 << 5),
kD2355_EVENT_F_VBUS_EXT_REM = (1 << 4),
kD2355_EVENT_F_CHG_HV_ATT = (1 << 3),
kD2355_EVENT_F_VBUS_EXT_DET = (1 << 2),
kD2355_EVENT_F_HV_MODE = (1 << 1),
kD2355_EVENT_F_VCENTER_DET = (1 << 0),
// 6: CHG_EVENT_B
kD2355_EVENT_G_CHG_SLOW = (1 << 7),
kD2355_EVENT_G_CHG_BUCK_FLG = (1 << 6),
kD2355_EVENT_G_CHG_ABCC_ACT = (1 << 5),
kD2355_EVENT_G_CHG_TIMEOUT = (1 << 4),
kD2355_EVENT_G_CHG_PRECHG_TIMEOUT = (1 << 3),
kD2355_EVENT_G_CHG_END = (1 << 2),
kD2355_EVENT_G_CHG_FAST = (1 << 1),
kD2355_EVENT_G_CHG_PRE = (1 << 0),
// 7: CHG_EVENT_C
// ... kD2355_EVENT_H
// 8: CHG_EVENT_D
// ... kD2355_EVENT_I
// 9: THRCTL_EVENT_A
// ... kD2355_EVENT_J
};
enum {
// 0: DEB_STATUS_A
kD2355_STATUS_A_GPIO8 = (1 << 7),
kD2355_STATUS_A_GPIO7 = (1 << 6),
kD2355_STATUS_A_GPIO6 = (1 << 5),
kD2355_STATUS_A_GPIO5 = (1 << 4),
kD2355_STATUS_A_GPIO4 = (1 << 3),
kD2355_STATUS_A_GPIO3 = (1 << 2),
kD2355_STATUS_A_GPIO2 = (1 << 1),
kD2355_STATUS_A_GPIO1 = (1 << 0),
// 1: DEB_STATUS_B
kD2355_STATUS_B_CHG_ATT = (1 <<7),
kD2355_STATUS_B_CHG_BG_HIGH_TEMP = (1 <<1),
kD2355_STATUS_B_CHG_VBUS_ATT = (1 <<0),
// 2: ADC_STATUS_A
kD2355_STATUS_C_PBUS_CNT_OVERFLOW= (1 << 3),
kD2355_STATUS_C_IBUS_OVERFLOW = (1 << 2),
kD2355_STATUS_C_TBAT = (1 << 1),
kD2355_STATUS_C_VDD_LOW = (1 << 0),
// 3: ADC_STATUS_B
kD2355_STATUS_D_VDDREF_CHG_FALL = (1 << 5),
kD2355_STATUS_D_TMID_DIE_FALL = (1 << 4),
kD2355_STATUS_D_TLINCHG_FALL = (1 << 3),
kD2355_STATUS_D_TVCENTER2_FALL = (1 << 2),
kD2355_STATUS_D_TVCENTER1_FALL = (1 << 1),
kD2355_STATUS_D_TCBUCK_FALL = (1 << 0),
// 4: ADC_STATUS_C
kD2355_STATUS_C_VDDREF_CHG_RISE = (1 << 5),
kD2355_STATUS_C_TMID_DIE_RISE = (1 << 4),
kD2355_STATUS_C_TLINCHG_RISE = (1 << 3),
kD2355_STATUS_C_TVCENTER2_RISE = (1 << 2),
kD2355_STATUS_C_TVCENTER1_RISE = (1 << 1),
kD2355_STATUS_C_TBUCK_RISE = (1 << 0),
// 5: CHG_STATUS_A
kD2355_STATUS_F_CV_LOOP_AVERAGE_SATURATED = (1 << 7),
kD2355_STATUS_F_FAULTY_ADAPTER = (1 << 6),
kD2355_STATUS_F_VBUS_OV = (1 << 5),
kD2355_STATUS_F_RES0 = (1 << 4),
kD2355_STATUS_F_CHG_HV_ATT = (1 << 3),
kD2355_STATUS_F_VBUS_EXT_DET = (1 << 2),
kD2355_STATUS_F_HV_MODE = (1 << 1),
kD2355_STATUS_F_VCENTER_DET = (1 << 0),
// 6: CHG_STATUS_B
kD2355_STATUS_G_CHG_SLOW = (1 << 7),
kD2355_STATUS_G_CHG_BUCK_FLG = (1 << 6),
kD2355_STATUS_G_CHG_ABCC_ACT = (1 << 5),
kD2355_STATUS_G_CHG_TIMEOUT = (1 << 4),
kD2355_STATUS_G_CHG_PRECHG_TIMEOUT = (1 << 3),
kD2355_STATUS_G_CHG_END = (1 << 2),
kD2355_STATUS_G_CHG_FAST = (1 << 1),
kD2355_STATUS_G_CHG_PRE = (1 << 0),
// 7: CHG_STATUS_C
// ... kD2355_STATUS_H
// 8: CHG_STATUS_D
// ... kD2355_STATUS_I
// 9: THRCTL_STATUS_A
// ... kD2355_STATUS_J
};
enum {
kD2355_CHG_CTRL_A_TCTR_MASK = 0xf0,
kD2355_CHG_CTRL_A_PCTR_MASK = 0x07,
kD2355_CHG_CTRL_D_FORCE_VSYS_HI_UVLO = ( 1<<7 ),
kD2355_CHG_CTRL_D_SW_BOOST_OFF = ( 1<<6 ),
kD2355_CHG_CTRL_D_BUCK_BUS_PWR_SUSPEND = ( 1<<5 ),
kD2355_CHG_CTRL_D_ALT_USB_DIS1 = ( 1<<4 ),
kD2355_CHG_CTRL_D_SUSPEND = ( 1<<3 ),
kD2355_CHG_CTRL_D_BAT_PWR_SUSP = ( 1<<2 ),
kD2355_CHG_CTRL_D_HV_CHG_ALLOW = ( 1<<1 ),
kD2355_CHG_CTRL_D_OVP_DIS = ( 1<<0 ),
kD2355_CHG_CTRL_E_BUCK_EN = ( 1<<7 ),
};
enum {
// kDIALOG_CHARGE_CONTROL_EN
// used only in iBoot to clear USB_DIS1 and allow control of usb charge limit via ISET_BUCK
//
// kDIALOG_SYS_CONTROL
// Here used only for kD2355_CHG_CTRL_D_BAT_PWR_SUSP
// kDIALOG_CHARGE_CONTROL_ICHG_BAT_MSB
// Battery current limit (in charger_set_charging() )
// kDIALOG_CHARGE_BUCK_CONTROL
// USB input current limit, used in charger_set_charging()
kDIALOG_CHARGE_CONTROL_ICHG_BAT_MSB = kD2355_CHG_ICHG_BAT_MSB,
kDIALOG_OTP_ISET_BAT_MSB = kD2355_CHG_ICHG_BAT_MAX_MSB,
kDIALOG_CHARGE_STATUS_MSB = kD2355_CHG_ICHG_BAT_ACTUAL_MSB,
kDIALOG_CHARGE_BUCK_CONTROL = kD2355_CHG_ISET_BUCK,
kDIALOG_CHARGE_BUCK_STATUS = kD2355_CHG_ISET_BUCK_ACTUAL,
kDIALOG_SYS_CONTROL = kD2355_CHG_CTRL_D,
kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND = kD2355_CHG_CTRL_D_BAT_PWR_SUSP,
// masks
kDIALOG_SYS_CONTROL_HIBERNATE_ALWAYS = 0,
kDIALOG_SYS_CONTROL_CHRG_CONTROLS = kDIALOG_SYS_CONTROL_BAT_PWR_SUSPEND,
kDIALOG_CHARGE_CONTROL_EN = kD2355_CHG_CTRL_D,
kDIALOG_CHARGE_CONTROL_ALT_USB_DIS = kD2355_CHG_CTRL_D_ALT_USB_DIS1,
// for HighVoltage Charging
kDIALOG_HV_CHG_ALLOW = kD2355_CHG_CTRL_D_HV_CHG_ALLOW,
kDIALOG_HV_CHG_ALLOW_MASK = ( 1<<1 ),
};
enum {
// for ISET_BUCK (USB current limit)
kDIALOG_CHARGE_BUCK_CONTROL_MIN = 80,
kDIALOG_CHARGE_BUCK_CONTROL_STEP_PER_100MA = 10,
kDIALOG_CHARGE_BUCK_CONTROL_MAX = 2550,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MIN = 0x08,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_100 = 0x0a,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_200 = 0x14,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_500 = 0x32,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1000 = 0x64,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_1900 = 0xbf,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2000 = 0xc9,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2100 = 0xd2,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2400 = 0xf0,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_2560 = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MAX = 0xff,
kDIALOG_CHARGE_BUCK_CONTROL_ISET_BUCK_MASK = 0xff,
};
enum {
// for ICHG_BAT (Battery Current Limit)
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_MASK = 0x3ff,
kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT = 0,
kDIALOG_OTP_ISET_BAT_SHIFT = kDIALOG_CHARGE_CONTROL_A_ISET_BAT_SHIFT,
kDIALOG_CHARGE_CONTROL_B_CHG_SUSP = (1 << 5),
kDIALOG_CHARGE_CONTROL_CHG_HIB = 0,
// these are ok, the one above not (not in CHARGE_CONTROL_A!!!)
kDIALOG_CHARGE_CONTROL_ISET_BAT_MASK = 0x3ff,
kDIALOG_CHARGE_CONTROL_ISET_BAT_SHIFT = 0,
kDIALOG_CHARGE_CONTROL_STEP = 10,
kDIALOG_CHARGE_CONTROL_MAX = 6390,
};
enum {
kDIALOG_CHARGE_CONTROL_TIME = kD2355_CHG_CTRL_A,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_MASK = kD2355_CHG_CTRL_A_TCTR_MASK,
kDIALOG_CHARGE_CONTROL_TIME_TCTR_DISABLED = 0x00,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_MASK = kD2355_CHG_CTRL_A_PCTR_MASK,
kDIALOG_CHARGE_CONTROL_TIME_PCTR_DISABLED = 0x00,
};
// ---------------------------------
// GPADC Control and Result
// ---------------------------------
// channels
enum {
kD2355_ADC_MUX_SEL_VSYS_LO = 0,
kD2355_ADC_MUX_SEL_ICH_1A,
kD2355_ADC_MUX_SEL_TBAT,
kD2355_ADC_MUX_SEL_VBAT,
kD2355_ADC_MUX_SEL_IBUS_IN_LG,
kD2355_ADC_MUX_SEL_ADC_IN_P,
kD2355_ADC_MUX_SEL_ADC_IN_N,
kD2355_ADC_MUX_SEL_TJINT,
kD2355_ADC_MUX_SEL_IBUS_IN_HG,
kD2355_ADC_MUX_SEL_VBUS = 10,
kD2355_ADC_MUX_SEL_VCENTER,
kD2355_ADC_MUX_SEL_VSYS_HI,
kD2355_ADC_MUX_SEL_VCENTER_TEMP1,
kD2355_ADC_MUX_SEL_LINCHG_TEMP,
kD2355_ADC_MUX_SEL_CHG_BUCK_TEMP,
kD2355_ADC_MUX_SEL_VCENTER_TEMP0,
kD2355_ADC_MUX_SEL_MID_DIE_TEMP,
kD2355_ADC_MUX_SEL_LV_LDO_TEMP = 18,
kD2355_ADC_MUX_SEL_BOOST_TEMP = 19,
kD2355_ADC_MUX_SEL_ICH_6A = 29,
};
enum {
kDIALOG_ADC_CONTROL_MUX_SEL_VDD_OUT = kD2355_ADC_MUX_SEL_VSYS_LO, // TODO: verify
kDIALOG_ADC_CONTROL_MUX_SEL_ICH_1A = kD2355_ADC_MUX_SEL_ICH_1A,
kDIALOG_ADC_CONTROL_MUX_SEL_TBAT = kD2355_ADC_MUX_SEL_TBAT,
kDIALOG_ADC_CONTROL_MUX_SEL_VBAT = kD2355_ADC_MUX_SEL_VBAT,
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_LG = kD2355_ADC_MUX_SEL_IBUS_IN_LG,
kDIALOG_ADC_CONTROL_MUX_SEL_VIBUS = kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_LG,
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN_P = kD2355_ADC_MUX_SEL_ADC_IN_P,
kDIALOG_ADC_CONTROL_MUX_SEL_ADC_IN_N = kD2355_ADC_MUX_SEL_ADC_IN_N,
kDIALOG_ADC_CONTROL_MUX_SEL_TJUNC = kD2355_ADC_MUX_SEL_TJINT,
kDIALOG_ADC_CONTROL_MUX_SEL_IBUS_IN_HG = kD2355_ADC_MUX_SEL_IBUS_IN_HG,
kDIALOG_ADC_CONTROL_MUX_SEL_VBUS = kD2355_ADC_MUX_SEL_VBUS,
kDIALOG_ADC_CONTROL_MUX_SEL_VCENTER_TEMP1 = kD2355_ADC_MUX_SEL_VCENTER_TEMP1,
kDIALOG_ADC_CONTROL_MUX_SEL_LINCHG_TEMP = kD2355_ADC_MUX_SEL_LINCHG_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_CHG_BUCK_TEMP = kD2355_ADC_MUX_SEL_CHG_BUCK_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_MID_DIE_TEMP = kD2355_ADC_MUX_SEL_MID_DIE_TEMP,
kDIALOG_ADC_CONTROL_MUX_SEL_ICH_6A = kD2355_ADC_MUX_SEL_ICH_6A,
kDIALOG_ADC_CONTROL_MUX_SEL_ICH = kD2355_ADC_MUX_SEL_ICH_1A,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_START = kD2355_ADC_MUX_SEL_VCENTER_TEMP1,
kDIALOG_ADC_CONTROL_MUX_SEL_TINT_END = kD2355_ADC_MUX_SEL_LV_LDO_TEMP,
kDIALOG_ADC_CONTROL2_AUTO_VDD_OUT_EN = (1 << 7),
kDIALOG_ADC_CONTROL2_ICH6A_EN = (1 << 1),
kDIALOG_ADC_CONTROL2_IBUS_EN = (1 << 0),
kDIALOG_ADC_CONTROL_MAN_CONV = (1 << 7),
kDIALOG_ADC_CONTROL_MUX_SEL_MASK = (0x1f << 0),
kDIALOG_ADC_LSB_ADC_OVL = (1 << 7),
kDIALOG_ADC_LSB_MANADC_ERROR = (1 << 6),
kDIALOG_ICHG_AVG = kD2355_ADC_ICHG_AVG,
kDIALOG_ADC_RESOLUTION_BITS = 12,
kDIALOG_ADC_FULL_SCALE_MV = 1500,
kDIALOG_ADC_BRICK_ID_OFFSET_MV = 40, // TODO: verify
kDIALOG_ADC_MAN_CTL = kD2355_ADC_CTRL1,
kDIALOG_ADC_CONTROL = kD2355_ADC_CTRL1,
kDIALOG_ADC_LSB = kD2355_ADC_RES_LSB,
kDIALOG_ADC_MSB = kD2355_ADC_RES_MSB,
kDIALOG_T_OFFSET_MSB = kD2355_T_OFFSET_MSB,
kDIALOG_T_OFFSET_LSB = kD2355_T_OFFSET_LSB,
};
enum {
kDIALOG_ADC_CONTROL_DEFAULTS = 0, // TODO: verify
kDIALOG_ADC_CONTROL2_DEFAULTS = 0, // TODO: verify
};
// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
enum {
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_LOW = (0 << 1),
kDIALOG_SYS_GPIO_OUTPUT_LEVEL_HIGH = (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_MASK = (1 << 6) | (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_OUT = (1 << 6),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_HIGH = (0 << 6) | (0 << 1),
kDIALOG_SYS_GPIO_DIRECTION_IN_LEVEL_LOW = (0 << 6) | (1 << 1),
kDIALOG_SYS_GPIO_DIRECTION_OUT_32KHZ = kDIALOG_SYS_GPIO_DIRECTION_OUT, // not supported
kDIALOG_SYS_GPIO_REG_START = kD2355_GPIO_GPIO1,
};
#define IS_GPIO_OUTPUT(gpio) (((gpio)&kDIALOG_SYS_GPIO_DIRECTION_OUT) == kDIALOG_SYS_GPIO_DIRECTION_OUT)
// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
enum {
// N.B. index in Virtual Registers
kDIALOG_FAULT_LOG_RST = FAULTLOG_FLAG_MAKE(0, (1 << 3)),
kDIALOG_FAULT_LOG_POR = FAULTLOG_FLAG_MAKE(0, (1 << 2)),
kDIALOG_FAULT_LOG_OVER_TEMP = FAULTLOG_FLAG_MAKE(0, (1 << 1)),
kDIALOG_FAULT_LOG_VDD_UNDER = FAULTLOG_FLAG_MAKE(0, (1 << 0)),
kDIALOG_FAULT_LOG_WDOG = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_3 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_2 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_RESET_IN_1 = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_BTN_SHUTDOWN = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_TWO_FINGER_RESET = kDIALOG_NOTEXIST_MASK,
kDIALOG_FAULT_LOG_NTC_SHDN = kDIALOG_NOTEXIST_MASK,
};
enum {
// N.B. index in Virtual Registers
kDIALOG_EVENT_HOLD_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_MENU_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_RINGER_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_BUTTON4_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_BUTTONS_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_PWR_BUTTON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ALARM_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ACC_DET_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_VBUS_DET_MASK = EVENT_FLAG_MAKE(5, kD2355_EVENT_F_VBUS_EXT_DET),
kDIALOG_EVENT_VBUS_EXT_REM_MASK = EVENT_FLAG_MAKE(5, kD2355_EVENT_F_VBUS_EXT_REM),
kDIALOG_EVENT_EOMC_MASK = EVENT_FLAG_MAKE(2, kD2355_EVENT_C_EOMC),
kDIALOG_EVENT_HIB_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ABCC_MASK = EVENT_FLAG_MAKE(6, kD2355_EVENT_G_CHG_ABCC_ACT),
kDIALOG_EVENT_CHG_END_MASK = EVENT_FLAG_MAKE(6, kD2355_EVENT_G_CHG_END),
kDIALOG_EVENT_TBAT_MASK = EVENT_FLAG_MAKE(2, kD2355_EVENT_C_TBAT),
kDIALOG_EVENT_GPIO1_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO1),
kDIALOG_EVENT_GPIO2_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO2),
kDIALOG_EVENT_GPIO3_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO3),
kDIALOG_EVENT_GPIO4_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO4),
kDIALOG_EVENT_GPIO5_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO5),
kDIALOG_EVENT_GPIO6_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO6),
kDIALOG_EVENT_GPIO7_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO7),
kDIALOG_EVENT_GPIO8_MASK = EVENT_FLAG_MAKE(0, kD2355_EVENT_A_GPIO8),
kDIALOG_EVENT_GPIO9_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO10_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO11_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO12_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO13_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO14_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO15_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO16_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO17_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO18_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO19_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO20_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_GPIO21_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_HOLD_DBL_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_MENU_DBL_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_RINGER_DBL_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_VHP_DET_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_ON_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_EVENT_LDO2_EN_MASK = kDIALOG_NOTEXIST_MASK,
};
enum {
// N.B. index in Virtual Registers
kDIALOG_STATUS_USB_MASK = STATUS_FLAG_MAKE(5, kD2355_STATUS_F_VBUS_EXT_DET),
kDIALOG_STATUS_VBUS_MASK = STATUS_FLAG_MAKE(5, kD2355_STATUS_F_VCENTER_DET),
kDIALOG_STATUS_FW_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_STATUS_ACC_DET_MASK = kDIALOG_NOTEXIST_MASK,
kDIALOG_STATUS_CHARGING_MASK = STATUS_FLAG_MAKE(6, kD2355_EVENT_G_CHG_PRE | kD2355_EVENT_G_CHG_FAST),
kDIALOG_STATUS_CHG_TO_MASK = STATUS_FLAG_MAKE(6, kD2355_EVENT_G_CHG_TIMEOUT),
kDIALOG_STATUS_CHG_END_MASK = STATUS_FLAG_MAKE(6, kD2355_EVENT_G_CHG_END),
kDIALOG_STATUS_TBAT_MASK = STATUS_FLAG_MAKE(2, kD2355_STATUS_C_TBAT),
kDIALOG_STATUS_CHG_ATT_MASK = STATUS_FLAG_MAKE(1, kD2355_STATUS_B_CHG_ATT),
kDIALOG_STATUS_ABCC_MASK = STATUS_FLAG_MAKE(6, kD2355_EVENT_G_CHG_ABCC_ACT),
#define kDIALOG_STATUS_GPIO_MASK(gpio) STATUS_FLAG_MAKE(0, (1 << ((gpio) % 8)))
};
static const statusRegisters kDialogStatusFWMask = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
static const statusRegisters kDialogStatusChargingMask = {0, 0, 0, 0, 0, 0, kD2355_STATUS_G_CHG_PRE | kD2355_STATUS_G_CHG_FAST, 0 , 0 , 0};
enum {
kD2355_EVENT_A_WAKEMASK = ( kD2355_EVENT_A_GPIO1 | kD2355_EVENT_A_GPIO2 | kD2355_EVENT_A_GPIO3 | kD2355_EVENT_A_GPIO4 |
kD2355_EVENT_A_GPIO5 | kD2355_EVENT_A_GPIO6 | kD2355_EVENT_A_GPIO7 | kD2355_EVENT_A_GPIO8 ),
kD2355_EVENT_B_WAKEMASK = 0,
kD2355_EVENT_C_WAKEMASK = 0,
kD2355_EVENT_D_WAKEMASK = 0,
kD2355_EVENT_E_WAKEMASK = 0,
kD2355_EVENT_F_WAKEMASK = kD2355_EVENT_F_VBUS_EXT_DET | kD2355_EVENT_F_VBUS_EXT_REM | kD2355_EVENT_F_VCENTER_DET,
kD2355_EVENT_G_WAKEMASK = kD2355_EVENT_G_CHG_TIMEOUT | kD2355_EVENT_G_CHG_PRECHG_TIMEOUT | kD2355_EVENT_G_CHG_END,
kD2355_EVENT_H_WAKEMASK = 0,
kD2355_EVENT_I_WAKEMASK = 0,
kD2355_EVENT_J_WAKEMASK = 0,
};
// All events that are masked during shutdown - inverse of the wake mask,
// events that wake up the system
static const eventRegisters kDialogEventIntMasks = {
(UInt8)~kD2355_EVENT_A_WAKEMASK, // really LLDB? really?
~kD2355_EVENT_B_WAKEMASK,
~kD2355_EVENT_C_WAKEMASK,
~kD2355_EVENT_D_WAKEMASK,
~kD2355_EVENT_E_WAKEMASK,
~kD2355_EVENT_F_WAKEMASK,
~kD2355_EVENT_G_WAKEMASK,
~kD2355_EVENT_H_WAKEMASK,
~kD2355_EVENT_I_WAKEMASK,
~kD2355_EVENT_J_WAKEMASK,
};
// All wake events without the buttons
static const eventRegisters kDialogEventNotButtonMasks = {
kD2355_EVENT_A_WAKEMASK,
kD2355_EVENT_B_WAKEMASK,
kD2355_EVENT_C_WAKEMASK,
kD2355_EVENT_D_WAKEMASK,
kD2355_EVENT_E_WAKEMASK,
kD2355_EVENT_F_WAKEMASK,
kD2355_EVENT_G_WAKEMASK,
kD2355_EVENT_H_WAKEMASK,
kD2355_EVENT_I_WAKEMASK,
kD2355_EVENT_J_WAKEMASK,
};
// All events indicating external power supply
static const eventRegisters kDialogEventPwrsupplyMask = {
0,
0,
0,
0,
0,
kD2355_EVENT_F_VBUS_EXT_DET | kD2355_EVENT_F_VCENTER_DET,
0,
0,
0,
0,
};
static const eventRegisters kDialogEventUSBMask = {
// in d2231.h only include kD2231_EVENT_A_VBUS_EXT_DET: VCENTER can come and go while charger still usable
0,
0,
0,
0,
0,
kD2355_EVENT_F_VBUS_EXT_DET | kD2355_EVENT_F_VCENTER_DET,
0, // kD2355_STATUS_G_CHG_ABCC_ACT ?
0,
0,
0,
};
static const eventRegisters kDialogEventFWMask = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
enum {
// TODO: verify this guys
kDialogEventPwrsupplyCount = 2,
kDialogEventUSBCount = 2,
kDialogEventFWCount = 0,
};
// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
#define NUM_LDOS 0
static const struct ldo_params ldo_d2355[NUM_LDOS] = {
};
#define LDOP ldo_d2355
#endif
drivers/dialog/pmu/dCommon.h
+57
View File
@@ -0,0 +1,57 @@
#ifndef __DIALOG_DCOMMON_H
#define __DIALOG_DCOMMON_H
typedef UInt8 eventRegisters[kDIALOG_EVENT_COUNT];
typedef UInt8 statusRegisters[kDIALOG_STATUS_COUNT];
typedef UInt8 faultRegisters[kDIALOG_FAULTLOG_COUNT];
// Test whether any of the 'mask' bits is set in 'registers'
static inline bool REGISTER_TEST_MASK(const UInt8 *events, const UInt8 *mask, unsigned int count) {
for (unsigned int i = 0 ; i < count; i++) {
if ((events[i] & mask[i]) != 0) return true;
}
return false;
}
#define EVENT_FLAG_MAKE(byte,bit) ((UInt16)((byte)&0xff)<<8 | ((bit)&0xff))
#define EVENT_FLAG_GET_BYTE(flag) ((UInt16)flag>>8)
#define EVENT_FLAG_GET_BIT(flag) (flag&0xff)
/* return a UInt16 if mismatch, which should warn you */
#define EVENT_FLAG_GET_BIT_FOR_BYTE(flag,byte) \
(((flag) & 0xff) | (EVENT_FLAG_GET_BYTE(flag)==(byte) ? 0 : 0xffff))
#define EVENT_REGISTERS_GET_BYTE(registers,flag) ((registers)[EVENT_FLAG_GET_BYTE(flag)])
#define EVENT_FLAG_TEST(registers,flag) ((EVENT_REGISTERS_GET_BYTE(registers,flag)&EVENT_FLAG_GET_BIT(flag)) != 0)
#define EVENT_REGISTER_TEST_MASK(registers,mask) REGISTER_TEST_MASK(registers,mask,kDIALOG_EVENT_COUNT)
#define STATUS_FLAG_MAKE EVENT_FLAG_MAKE
#define STATUS_FLAG_TEST EVENT_FLAG_TEST
#define STATUS_REGISTER_TEST_MASK(registers,mask) REGISTER_TEST_MASK(registers,mask,kDIALOG_STATUS_COUNT)
#define FAULTLOG_FLAG_MAKE EVENT_FLAG_MAKE
#define FAULTLOG_FLAG_TEST EVENT_FLAG_TEST
#define FAULTLOG_REGISTER_TEST_MASK(registers,mask) REGISTER_TEST_MASK(registers,mask,kDIALOG_FAULTLOG_COUNT)
enum {
kDIALOG_NOTEXIST_MASK = EVENT_FLAG_MAKE(0, 0)
};
struct ldo_params {
UInt16 minv;
UInt8 step;
UInt8 maxs;
UInt8 stepmask;
UInt8 bypass;
UInt16 ldoreg;
UInt16 actreg;
UInt8 actmask;
};
int pmu_uvwarn_config(int dev, uint32_t thresholdMV);
int pmu_set_data(int dev, uint16_t reg, uint8_t byte, bool do_confirm);
int pmu_get_data(int dev, uint16_t reg, uint8_t *byte);
void pmu_check_events(bool *powersupply_change_event, bool *button_event, bool *other_wake_event);
void pmu_read_events(eventRegisters data);
#endif
drivers/dialog/pmu/power.c
+1934
View File
File diff suppressed because it is too large. Load diff
drivers/dialog/pmu/rules.mk
+22
View File
@@ -0,0 +1,22 @@
# Copyright (C) 2008 Apple Inc. All rights reserved.
#
# This document is the property of Apple Inc.
# It is considered confidential and proprietary.
#
# This document may not be reproduced or transmitted in any form,
# in whole or in part, without the express written permission of
# Apple Inc.
#
LOCAL_DIR := $(GET_LOCAL_DIR)
OPTIONS += \
WITH_HW_POWER_DIALOG=1 \
WITH_HW_POWER=1
ALL_OBJS += \
$(LOCAL_DIR)/power.o \
$(LOCAL_DIR)/charger.o
MODULES += \
lib/power