Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

+220
View File
@@ -0,0 +1,220 @@
#
# MTK PMIC configuration
#
config MTK_PMIC_NEW_ARCH
tristate "MediaTek Power Management New Arch driver"
default n
---help---
This selects for MediaTek(R) PMIC New Arch driver.
Separate pmic feature form Power folder that also have battery and charging feature.
Select y to support MTK PMIC NEW ARCH.
If so, you should choose the corresponding main chip to follow.
Select n to support MTK PMIC LEGACY ARCH.
config MTK_PMIC_COMMON
tristate "MediaTek Power Management Common driver"
default n
---help---
This selects for MediaTek(R) PMIC common driver.
This feature is mainly to separate to common and platform part from driver layer.
Select y to support MTK PMIC COMMON feature.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6353
tristate "MediaTek PMIC MT6353 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6353 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6355
tristate "MediaTek PMIC MT6355 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6355 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6356
tristate "MediaTek PMIC MT6356 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6356 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6357
tristate "MediaTek PMIC MT6357 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6357 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6358
tristate "MediaTek PMIC MT6358 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6358 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6359
tristate "MediaTek PMIC MT6359 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6359 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6359P
tristate "MediaTek PMIC MT6359P Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6359P driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6390
tristate "MediaTek PMIC MT6390 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6390 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_PMIC_CHIP_MT6335
tristate "MediaTek Power MT6335 Driver"
default n
---help---
This selects for MediaTek(R) PMIC MT6335 driver.
It's main chip type and providing power features like auxadc,
buck/ldo, interrupt-controller..etc
Set y to support this driver.
Set n and choose other chip.
config MTK_EXTBUCK
tristate "EXT BUCK Driver"
default n
---help---
This selects for EXT BUCK driver.
It's sub chip type and used mainly in buck controlling.
Set y to support this driver.
Set n and choose other chip.
config EXTBUCK_MT6311
bool "MediaTek I2C Ext Buck MT6311"
depends on MTK_EXTBUCK
default n
---help---
MediaTek(R) I2C interface External BUCK MT6311 driver.
External Buck for PROC1.
Regulator Driver.
Set y to enable it.
Set n to disable it.
config MTK_AUXADC_INTF
bool "MediaTek PMIC Auxadc interface"
depends on MTK_PMIC_NEW_ARCH
default n
---help---
MediaTek PMIC Auxadc interface Driver
only for MTK_PMIC_NEW_ARCH
Set y to enable it.
Set n to disable it.
config REGULATOR_ISL91302A
bool "Intersil Spi Ext Buck Isl91302a"
depends on MTK_EXTBUCK
select RT_REGMAP
default n
---help---
Intersil SPI Interface
External Buck for
GPU, PROC1, PROC2
Regulator Driver
config REGULATOR_RT5734
bool "Richtek Spi Ext Buck rt5734"
depends on MTK_EXTBUCK
select RT_REGMAP
default n
---help---
Richtek SPI Interface External Buck for GPU, PROC1, PROC2
Regulator Driver
Say Y to enable it.
Say N to disable it.
config REGULATOR_RT5738
bool "Richtek Ext Buck RT5738"
depends on MTK_EXTBUCK
default n
---help---
Richtek I2c Interface
Extern Buck for MTK Platform
Say Y to enable it.
Say N to disable it.
config REGULATOR_MT6691
bool "MediaTek I2C Ext Buck MT6691"
depends on MTK_EXTBUCK
default n
---help---
Richtek I2c Interface
Extern Buck for MTK Platform
Say Y to enable it.
Say N to disable it.
config MTK_EXTERNAL_CHARGER_TYPE_DETECT
bool "MediaTek external charger type detection"
---help---
MediaTek external charger type detection flow
only for MTK_PMIC_NEW_ARCH
It used to support external charger type detection.
Default is MTK PMIC path. Select Y to disable MTK charger type detect.
Set y to enable it.
Set n to disable it.
config CHRDET_VBUS_DETECTION
bool "MediaTek vbus detection"
default n
help
MediaTek vbus detection flow
only for no charger ic
It used to support vbus detection.
Select Y to enable MTK pmic vbus detect.
Set y to enable it.
Set n to disable it.
config MTK_TB_WIFI_ONLY
bool "power config for wifi only projects."
default n
help
power config for wifi only projects in kernel.
Turn off unused power.
Set y to enable it.
Set n to disable it.
source "drivers/misc/mediatek/pmic/mt6370/Kconfig"
source "drivers/misc/mediatek/pmic/mt6360/Kconfig"
source "drivers/misc/mediatek/pmic/mt6397/Kconfig"
+220
View File
@@ -0,0 +1,220 @@
ifeq ($(CONFIG_MACH_MT6768),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6370_PMU) += mt6370/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6771),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6370_PMU) += mt6370/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6781),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6370_PMU) += mt6370/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6739),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6877),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6833),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6853),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6873),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6885),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6893),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else ifeq ($(CONFIG_MACH_MT6785),y)
subdir-ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6357)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6357
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6358)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6358
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359
subdir-ccflags-$(CONFIG_MTK_PMIC_CHIP_MT6359P)+= -I$(srctree)/drivers/misc/mediatek/pmic/include/mt6359p
obj-$(CONFIG_MTK_EXTBUCK) += extbuck/
obj-$(CONFIG_MTK_PMIC_COMMON) += common/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += mt6357/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += mt6358/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359) += mt6359/
obj-$(CONFIG_MTK_PMIC_CHIP_MT6359P) += mt6359p/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
obj-y += mtk_battery_adc_intf.o
endif
else
obj-$(CONFIG_MFD_MT6370_PMU) += mt6370/
obj-$(CONFIG_MFD_MT6360_PMU) += mt6360/
obj-$(CONFIG_MFD_MT6397) += mt6397/
endif
+19
View File
@@ -0,0 +1,19 @@
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic/include
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic_wrap/$(CONFIG_MTK_PLATFORM)
#ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(CONFIG_MTK_PLATFORM)/include/
#ccflags-y += -I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(CONFIG_MTK_PLATFORM)/include/mach/
ifeq ($(CONFIG_MTK_TINYSYS_SSPM_SUPPORT), y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/$(MTK_PLATFORM)/
endif
obj-$(CONFIG_MTK_PMIC_COMMON) += upmu.o upmu_regulator.o upmu_debugfs.o upmu_initial_setting.o
ifeq ($(CONFIG_MTK_PMIC_CHIP_MT6359), y)
obj-y += upmu_lbat_service_v2.o
else ifeq ($(CONFIG_MTK_PMIC_CHIP_MT6359P), y)
obj-y += upmu_lbat_service_v2.o
else
obj-y += upmu_lbat_service.o
endif
+740
View File
@@ -0,0 +1,740 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/debugfs.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/preempt.h>
#include <linux/uaccess.h>
#include <linux/of_platform.h>
#include <linux/soc/mediatek/pmic_wrap.h>
#include <linux/regmap.h>
#include <linux/mfd/mt6358/core.h>
#include <mt-plat/upmu_common.h>
#include <mach/mtk_pmic.h>
#include "include/pmic.h"
#include "include/pmic_irq.h"
#include "include/pmic_throttling_dlpt.h"
#include "include/pmic_debugfs.h"
#include "include/pmic_api_buck.h"
#include "include/pmic_bif.h"
#include "include/pmic_auxadc.h"
/**********************************************************
* PMIC related define
***********************************************************/
#if !defined(CONFIG_FPGA_EARLY_PORTING)
#define CONFIG_PMIC_HW_ACCESS_EN
#endif
/*---IPI Mailbox define---*/
#if defined(IPIMB)
#include <mach/mtk_pmic_ipi.h>
#endif
/**********************************************************
* PMIC read/write APIs
***********************************************************/
static struct mt6358_chip *chip;
struct regmap *pmic_nolock_regmap;
static int pmic_read_device(struct regmap *map,
unsigned int RegNum,
unsigned int *val,
unsigned int MASK,
unsigned int SHIFT)
{
int ret = 0;
#if defined(CONFIG_PMIC_HW_ACCESS_EN)
if (!map) {
pr_notice("[%s] regmap not ready\n", __func__);
return -ENODEV;
}
ret = regmap_read(map, RegNum, val);
if (ret) {
dev_notice(chip->dev,
"[%s]ret=%d Reg=0x%x MASK=0x%x SHIFT=%d\n",
__func__, ret, RegNum, MASK, SHIFT);
return ret;
}
*val &= (MASK << SHIFT);
*val >>= SHIFT;
PMICLOG("[%s] (0x%x,0x%x,0x%x,0x%x)\n",
__func__, RegNum, *val, MASK, SHIFT);
#else
pr_info("[%s] Can not access HW PMIC(FPGA?/PWRAP?)\n", __func__);
#endif /*defined(CONFIG_PMIC_HW_ACCESS_EN)*/
return ret;
}
static int pmic_write_device(struct regmap *map,
unsigned int RegNum,
unsigned int val,
unsigned int MASK,
unsigned int SHIFT)
{
int ret = 0;
#if defined(CONFIG_PMIC_HW_ACCESS_EN)
if (!map) {
pr_notice("[%s] regmap not ready\n", __func__);
return -ENODEV;
}
ret = regmap_update_bits(map, RegNum, (MASK << SHIFT), (val << SHIFT));
if (ret) {
dev_notice(chip->dev,
"[%s]ret=%d Reg=0x%x val=0x%x MASK=0x%x SHIFT=%d\n",
__func__, ret, RegNum, val, MASK, SHIFT);
return ret;
}
PMICLOG("[%s] (0x%x,0x%x,0x%x,%d)\n",
__func__, RegNum, val, MASK, SHIFT);
#else
PMICLOG("[%s] Can not access HW PMIC(FPGA?/PWRAP?)\n", __func__);
#endif /*defined(CONFIG_PMIC_HW_ACCESS_EN)*/
return ret;
}
unsigned int pmic_read_interface(unsigned int RegNum,
unsigned int *val,
unsigned int MASK,
unsigned int SHIFT)
{
int ret;
if (!chip) {
pr_notice("[%s] PMIC not ready\n", __func__);
return -ENODEV;
}
ret = pmic_read_device(chip->regmap, RegNum, val, MASK, SHIFT);
return abs(ret);
}
unsigned int pmic_config_interface(unsigned int RegNum,
unsigned int val,
unsigned int MASK,
unsigned int SHIFT)
{
int ret;
if (preempt_count() > 0 ||
irqs_disabled() ||
system_state != SYSTEM_RUNNING ||
oops_in_progress)
return pmic_config_interface_nolock(RegNum, val, MASK, SHIFT);
if (!chip) {
pr_notice("[%s] PMIC not ready\n", __func__);
return -ENODEV;
}
ret = pmic_write_device(chip->regmap, RegNum, val, MASK, SHIFT);
return ret;
}
unsigned int pmic_read_interface_nolock(unsigned int RegNum,
unsigned int *val,
unsigned int MASK,
unsigned int SHIFT)
{
int ret;
ret = pmic_read_device(pmic_nolock_regmap, RegNum, val, MASK, SHIFT);
return abs(ret);
}
unsigned int pmic_config_interface_nolock(unsigned int RegNum,
unsigned int val,
unsigned int MASK,
unsigned int SHIFT)
{
int ret = 0;
ret = pmic_write_device(pmic_nolock_regmap, RegNum, val, MASK, SHIFT);
return abs(ret);
}
unsigned short pmic_set_register_value(PMU_FLAGS_LIST_ENUM flagname,
unsigned int val)
{
const PMU_FLAG_TABLE_ENTRY *pFlag = &pmu_flags_table[flagname];
unsigned int ret = 0;
if (pFlag->flagname != flagname) {
pr_info("[%s]pmic flag idx error\n", __func__);
return 1;
}
ret = pmic_config_interface((unsigned int)(pFlag->offset), val,
(unsigned int)(pFlag->mask), (unsigned int)(pFlag->shift));
if (ret != 0) {
pr_info("[%s] error ret: %d when set Reg[0x%x]=0x%x\n",
__func__, ret, (pFlag->offset), val);
return ret;
}
return 0;
}
unsigned short pmic_get_register_value(PMU_FLAGS_LIST_ENUM flagname)
{
const PMU_FLAG_TABLE_ENTRY *pFlag = &pmu_flags_table[flagname];
unsigned int val = 0;
unsigned int ret = 0;
ret = pmic_read_interface((unsigned int)pFlag->offset, &val,
(unsigned int)(pFlag->mask), (unsigned int)(pFlag->shift));
if (ret != 0) {
pr_info("[%s] error ret: %d when get Reg[0x%x]\n", __func__,
ret, (pFlag->offset));
return ret;
}
return val;
}
unsigned short pmic_set_register_value_nolock(PMU_FLAGS_LIST_ENUM flagname,
unsigned int val)
{
const PMU_FLAG_TABLE_ENTRY *pFlag = &pmu_flags_table[flagname];
unsigned int ret = 0;
if (pFlag->flagname != flagname) {
pr_info("[%s]pmic flag idx error\n", __func__);
return 1;
}
ret = pmic_config_interface_nolock((unsigned int)(pFlag->offset), val,
(unsigned int)(pFlag->mask), (unsigned int)(pFlag->shift));
if (ret != 0) {
pr_info("[%s] error ret: %d when set Reg[0x%x]=0x%x\n",
__func__, ret, (pFlag->offset), val);
return ret;
}
return 0;
}
unsigned short pmic_get_register_value_nolock(PMU_FLAGS_LIST_ENUM flagname)
{
const PMU_FLAG_TABLE_ENTRY *pFlag = &pmu_flags_table[flagname];
unsigned int val = 0;
unsigned int ret = 0;
ret = pmic_read_interface_nolock((unsigned int)pFlag->offset, &val,
(unsigned int)(pFlag->mask), (unsigned int)(pFlag->shift));
if (ret != 0) {
pr_info("[%s] error ret: %d when get Reg[0x%x]\n", __func__,
ret, (pFlag->offset));
return ret;
}
return val;
}
unsigned short bc11_set_register_value(PMU_FLAGS_LIST_ENUM flagname,
unsigned int val)
{
return pmic_set_register_value(flagname, val);
}
unsigned short bc11_get_register_value(PMU_FLAGS_LIST_ENUM flagname)
{
return pmic_get_register_value(flagname);
}
unsigned short pmic_set_hk_reg_value(PMU_FLAGS_LIST_ENUM flagname,
unsigned int val)
{
return pmic_set_register_value(flagname, val);
}
unsigned int upmu_get_reg_value(unsigned int reg)
{
unsigned int reg_val = 0;
unsigned int ret = 0;
ret = pmic_read_interface(reg, &reg_val, 0xFFFF, 0x0);
return reg_val;
}
EXPORT_SYMBOL(upmu_get_reg_value);
void upmu_set_reg_value(unsigned int reg, unsigned int reg_val)
{
unsigned int ret = 0;
ret = pmic_config_interface(reg, reg_val, 0xFFFF, 0x0);
}
/*****************************************************************************
* FTM
******************************************************************************/
#define PMIC_DEVNAME "pmic_ftm"
#define Get_IS_EXT_BUCK_EXIST _IOW('k', 20, int)
#define Get_IS_EXT_VBAT_BOOST_EXIST _IOW('k', 21, int)
#define Get_IS_EXT_SWCHR_EXIST _IOW('k', 22, int)
#define Get_IS_EXT_BUCK2_EXIST _IOW('k', 23, int)
#define Get_IS_EXT_BUCK3_EXIST _IOW('k', 24, int)
static struct class *pmic_class;
static struct cdev *pmic_cdev;
static int pmic_major;
static dev_t pmic_devno;
static long pmic_ftm_ioctl(struct file *file,
unsigned int cmd,
unsigned long arg)
{
void __user *user_data = (void __user *)arg;
int adc_in_data[2] = { 1, 1 };
int adc_out_data[2] = { 1, 1 };
/* adc_in_data is used to check userspace data size */
if (copy_from_user(adc_in_data, user_data, sizeof(adc_in_data)))
return -EFAULT;
switch (cmd) {
case Get_IS_EXT_BUCK_EXIST:
#ifdef CONFIG_MTK_EXTBUCK
adc_out_data[0] = is_ext_buck_exist();
#else
adc_out_data[0] = 0;
#endif
PMICLOG("[%s] Get_IS_EXT_BUCK_EXIST:%d\n"
, __func__, adc_out_data[0]);
break;
case Get_IS_EXT_VBAT_BOOST_EXIST:
adc_out_data[0] = is_ext_vbat_boost_exist();
PMICLOG("[%s] Get_IS_EXT_VBAT_BOOST_EXIST:%d\n"
, __func__, adc_out_data[0]);
break;
case Get_IS_EXT_SWCHR_EXIST:
adc_out_data[0] = is_ext_swchr_exist();
PMICLOG("[%s] Get_IS_EXT_SWCHR_EXIST:%d\n"
, __func__, adc_out_data[0]);
break;
case Get_IS_EXT_BUCK2_EXIST:
#ifdef CONFIG_MTK_EXTBUCK
adc_out_data[0] = is_ext_buck2_exist();
#else
adc_out_data[0] = 0;
#endif
PMICLOG("[%s] Get_IS_EXT_BUCK2_EXIST:%d\n"
, __func__, adc_out_data[0]);
break;
case Get_IS_EXT_BUCK3_EXIST:
#ifdef CONFIG_MTK_EXTBUCK
/* just for UI showing CONNECTED */
adc_out_data[0] = is_ext_buck2_exist();
#else
adc_out_data[0] = 0;
#endif
PMICLOG("[%s] Get_IS_EXT_BUCK3_EXIST:%d\n"
, __func__, adc_out_data[0]);
break;
default:
PMICLOG("[%s] Error ID\n", __func__);
return -EINVAL;
}
if (copy_to_user(user_data, adc_out_data, sizeof(adc_out_data)))
return -EFAULT;
return 0;
}
#ifdef CONFIG_COMPAT
static long pmic_ftm_compat_ioctl(struct file *file,
unsigned int cmd,
unsigned long arg)
{
int ret = 0;
switch (cmd) {
/*#if defined(FTM_EXT_BUCK_CHECK) */
case Get_IS_EXT_BUCK_EXIST:
case Get_IS_EXT_VBAT_BOOST_EXIST:
case Get_IS_EXT_SWCHR_EXIST:
case Get_IS_EXT_BUCK2_EXIST:
ret = file->f_op->unlocked_ioctl(file, cmd, arg);
break;
default:
PMICLOG("[%s] Error ID\n", __func__);
break;
}
return 0;
}
#endif
static int pmic_ftm_open(struct inode *inode, struct file *file)
{
return 0;
}
static int pmic_ftm_release(struct inode *inode, struct file *file)
{
return 0;
}
static const struct file_operations pmic_ftm_fops = {
.owner = THIS_MODULE,
.unlocked_ioctl = pmic_ftm_ioctl,
#ifdef CONFIG_COMPAT
.compat_ioctl = pmic_ftm_compat_ioctl,
#endif
.open = pmic_ftm_open,
.release = pmic_ftm_release,
};
void pmic_ftm_init(void)
{
struct class_device *class_dev = NULL;
int ret = 0;
ret = alloc_chrdev_region(&pmic_devno, 0, 1, PMIC_DEVNAME);
if (ret)
PMICLOG("[%s] Error: Can't Get Major number for pmic_ftm\n"
, __func__);
pmic_cdev = cdev_alloc();
pmic_cdev->owner = THIS_MODULE;
pmic_cdev->ops = &pmic_ftm_fops;
ret = cdev_add(pmic_cdev, pmic_devno, 1);
if (ret)
PMICLOG("[%s] Error: cdev_add\n", __func__);
pmic_major = MAJOR(pmic_devno);
pmic_class = class_create(THIS_MODULE, PMIC_DEVNAME);
class_dev = (struct class_device *)device_create(pmic_class,
NULL, pmic_devno, NULL, PMIC_DEVNAME);
PMICLOG("[%s] Done\n", __func__);
}
/*****************************************************************************
* HW Setting
******************************************************************************/
unsigned short is_battery_remove;
unsigned short is_wdt_reboot_pmic;
unsigned short is_wdt_reboot_pmic_chk;
unsigned short g_vmodem_vosel;
unsigned short is_battery_remove_pmic(void)
{
return is_battery_remove;
}
void PMIC_CUSTOM_SETTING_V1(void)
{
}
/*****************************************************************************
* system function
******************************************************************************/
void __attribute__ ((weak)) pmic_auxadc_suspend(void)
{
}
void __attribute__ ((weak)) pmic_auxadc_resume(void)
{
}
void __attribute__ ((weak)) record_md_vosel(void)
{
}
void __attribute__ ((weak)) pmic_enable_smart_reset(unsigned char smart_en,
unsigned char smart_sdn_en)
{
pr_notice("[%s] smart reset not support!\n", __func__);
}
void __attribute__ ((weak)) enable_bat_temp_det(bool en)
{
}
#ifdef IPIMB
static struct regmap *pmic_read_regmap;
static int pmic_ipi_reg_write(void *context, const void *data,
size_t count)
{
unsigned int ret;
unsigned short *dout = (unsigned short *)data;
unsigned short reg = dout[0], val = dout[1];
if (count != 4) {
pr_notice("%s: reg=0x%x, val=0x%x, count=%zu\n",
__func__, reg, val, count);
return -EINVAL;
}
ret = pmic_ipi_config_interface(reg, val, 0xFFFF, 0, 1);
if (ret) {
pr_info("[%s]fail with ret=%d, reg=0x%x val=0x%x\n",
__func__, ret, reg, val);
return -EINVAL;
}
return 0;
}
static int pmic_ipi_reg_read(void *context,
const void *reg_buf, size_t reg_size,
void *val_buf, size_t val_size)
{
unsigned short reg = *(unsigned short *)reg_buf;
unsigned int val = 0;
int ret = 0;
if (reg_size != 2 || val_size != 2) {
pr_notice("%s: reg=0x%x, reg_size=%zu, val_size=%zu\n",
__func__, reg, reg_size, val_size);
return -EINVAL;
}
ret = regmap_read(pmic_read_regmap, reg, &val);
*(u16 *)val_buf = val;
return ret;
}
static int pmic_ipi_reg_update_bits(void *context, unsigned int reg,
unsigned int mask, unsigned int val)
{
unsigned int ret;
ret = pmic_ipi_config_interface(reg, val, mask, 0, 1);
if (ret) {
pr_info("[%s]fail with ret=%d, reg=0x%x mask=0x%x val=0x%x\n",
__func__, ret, reg, mask, val);
return -EINVAL;
}
return 0;
}
static void pmic_ipi_regmap_unlock_empty(void *__map)
{
}
static const struct regmap_config pmic_ipi_regmap_config = {
.name = "pmic_ipi",
.reg_bits = 16,
.val_bits = 16,
.reg_stride = 2,
.max_register = 0xffff,
.reg_format_endian = REGMAP_ENDIAN_NATIVE,
.val_format_endian = REGMAP_ENDIAN_NATIVE,
};
static const struct regmap_config pmic_ipi_nolock_regmap_config = {
.name = "pmic_ipi_nolock",
.reg_bits = 16,
.val_bits = 16,
.lock = pmic_ipi_regmap_unlock_empty,
.unlock = pmic_ipi_regmap_unlock_empty,
.reg_stride = 2,
.max_register = 0xffff,
.reg_format_endian = REGMAP_ENDIAN_NATIVE,
.val_format_endian = REGMAP_ENDIAN_NATIVE,
};
static struct regmap_bus regmap_pmic_ipi_bus = {
.write = pmic_ipi_reg_write,
.read = pmic_ipi_reg_read,
.reg_update_bits = pmic_ipi_reg_update_bits,
.fast_io = true,
};
#endif
#if IS_ENABLED(CONFIG_CHRDET_VBUS_DETECTION)
static irqreturn_t mtk_mt_irq_handler_thread(int irq, void *data)
{
if (pmic_get_register_value(PMIC_RGS_CHRDET)) {
pr_info("usb cable in\n");
mt_usb_connect_v1();
} else {
pr_info("usb cable out\n");
mt_usb_disconnect_v1();
}
return IRQ_HANDLED;
}
bool mtk_mt_pmic_get_vcdt(void)
{
if (pmic_get_register_value(PMIC_RGS_CHRDET))
return true;
return false;
}
EXPORT_SYMBOL(mtk_mt_pmic_get_vcdt);
#endif
static int pmic_mt_probe(struct platform_device *pdev)
{
int ret = 0;
#if IS_ENABLED(CONFIG_CHRDET_VBUS_DETECTION)
int mt_irq = 0;
#endif
chip = dev_get_drvdata(pdev->dev.parent);
#ifdef IPIMB
pmic_read_regmap = dev_get_regmap(chip->dev->parent, NULL);
chip->regmap = devm_regmap_init(&pdev->dev, &regmap_pmic_ipi_bus,
NULL, &pmic_ipi_regmap_config);
if (IS_ERR(chip->regmap)) {
ret = PTR_ERR(chip->regmap);
dev_notice(&pdev->dev, "failed to init IPI regmap\n");
chip->regmap = dev_get_regmap(chip->dev->parent, NULL);
}
pmic_nolock_regmap = devm_regmap_init(&pdev->dev,
&regmap_pmic_ipi_bus,
NULL,
&pmic_ipi_nolock_regmap_config);
if (IS_ERR(pmic_nolock_regmap)) {
ret = PTR_ERR(pmic_nolock_regmap);
dev_notice(&pdev->dev, "failed to init nolock regmap\n");
pmic_nolock_regmap = chip->regmap;
}
#else
pmic_nolock_regmap = chip->regmap;
#endif
pr_info("******** MT pmic driver probe!! ********\n");
/*get PMIC CID */
PMICLOG("PMIC CID = 0x%x\n", pmic_get_register_value(PMIC_SWCID));
#if defined(CONFIG_MACH_MT6781)
record_is_pmic_new_power_grid(pdev);
#endif
record_md_vosel();
PMIC_INIT_SETTING_V1();
PMICLOG("[PMIC_INIT_SETTING_V1] Done\n");
/*PMIC Interrupt Service*/
PMIC_EINT_SETTING(pdev);
PMICLOG("[PMIC_EINT_SETTING] Done\n");
mtk_regulator_init(to_platform_device(pdev->dev.parent));
PMICLOG("[PMIC] mtk_regulator_init : done.\n");
pmic_throttling_dlpt_init(pdev);
PMICLOG("[PMIC] pmic_throttling_dlpt_init : done.\n");
pmic_debug_init(pdev);
PMICLOG("[PMIC] pmic_debug_init : done.\n");
pmic_ftm_init();
if (IS_ENABLED(CONFIG_MTK_BIF_SUPPORT))
pmic_bif_init();
#if IS_ENABLED(CONFIG_CHRDET_VBUS_DETECTION)
/*add pmic mt6358 chrdet irq for vbus detection*/
mt_irq = platform_get_irq_byname(pdev, "chrdet_edge");
if (mt_irq < 0) {
pr_info("[PMIC] Get mt irq fail, %d.\n", mt_irq);
return mt_irq;
}
ret = devm_request_threaded_irq(&pdev->dev, mt_irq, NULL,
mtk_mt_irq_handler_thread,
IRQF_ONESHOT | IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW,
"chrdet_edge", chip);
if (ret) {
pr_info("Failed to request mt IRQ: %d: %d\n", mt_irq, ret);
return ret;
}
#endif
return ret;
}
static int pmic_mt_remove(struct platform_device *pdev)
{
PMICLOG("******** MT pmic driver remove!! ********\n");
return 0;
}
static void pmic_mt_shutdown(struct platform_device *pdev)
{
PMICLOG("******** MT pmic driver shutdown!! ********\n");
vmd1_pmic_setting_on();
}
static int pmic_mt_suspend(struct platform_device *pdev, pm_message_t state)
{
PMICLOG("******** MT pmic driver suspend!! ********\n");
pmic_throttling_dlpt_suspend();
pmic_auxadc_suspend();
return 0;
}
static int pmic_mt_resume(struct platform_device *pdev)
{
PMICLOG("******** MT pmic driver resume!! ********\n");
pmic_throttling_dlpt_resume();
pmic_auxadc_resume();
return 0;
}
static const struct of_device_id pmic_of_match[] = {
{.compatible = "mediatek,mt-pmic"},
{},
};
static struct platform_driver pmic_mt_driver = {
.probe = pmic_mt_probe,
.remove = pmic_mt_remove,
.shutdown = pmic_mt_shutdown,
.suspend = pmic_mt_suspend,
.resume = pmic_mt_resume,
.driver = {
.name = "mt-pmic",
.of_match_table = pmic_of_match,
},
};
/**************************************************************************
* PMIC mudule init/exit
***************************************************************************/
static int __init pmic_mt_init(void)
{
int ret;
ret = platform_driver_register(&pmic_mt_driver);
if (ret) {
pr_info("****[%s] Unable to register driver (%d)\n",
__func__, ret);
return ret;
}
pr_info("****[%s] Initialization : DONE !!\n", __func__);
return 0;
}
fs_initcall(pmic_mt_init);
static void __exit pmic_mt_exit(void)
{
platform_driver_unregister(&pmic_mt_driver);
}
module_exit(pmic_mt_exit);
MODULE_AUTHOR("Jimmy-YJ Huang");
MODULE_DESCRIPTION("MTK PMIC COMMON Interface Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0.0_M");
@@ -0,0 +1,225 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <mach/mtk_pmic.h>
#include <mt-plat/mtk_auxadc_intf.h>
static struct mtk_auxadc_intf *auxadc_intf;
const char *pmic_get_auxadc_name(u8 list)
{
return pmic_auxadc_channel_name[list];
}
EXPORT_SYMBOL(pmic_get_auxadc_name);
int pmic_get_auxadc_value(u8 list)
{
int value = 0;
if (list >= AUXADC_LIST_START && list <= AUXADC_LIST_END) {
value = mt_get_auxadc_value(list);
return value;
}
pr_info("%s Invalid AUXADC LIST\n", __func__);
return -EINVAL;
}
static struct mtk_auxadc_ops pmic_auxadc_ops = {
.get_channel_value = pmic_get_auxadc_value,
.dump_regs = pmic_auxadc_dump_regs,
};
static struct mtk_auxadc_intf pmic_auxadc_intf = {
.ops = &pmic_auxadc_ops,
.name = "mtk_auxadc_intf",
.channel_name = pmic_auxadc_channel_name,
};
int register_mtk_auxadc_intf(struct mtk_auxadc_intf *intf)
{
auxadc_intf = intf;
platform_device_register_simple(auxadc_intf->name, -1, NULL, 0);
return 0;
}
EXPORT_SYMBOL(register_mtk_auxadc_intf);
void mtk_auxadc_init(void)
{
#if 0
pmic_auxadc_init();
#endif
pmic_auxadc_intf.channel_num = pmic_get_auxadc_channel_max();
if (register_mtk_auxadc_intf(&pmic_auxadc_intf) < 0)
pr_notice("[%s] register MTK Auxadc Intf Fail\n", __func__);
}
static ssize_t mtk_auxadc_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count);
static ssize_t mtk_auxadc_show(struct device *dev,
struct device_attribute *attr, char *buf);
static struct device_attribute mtk_auxadc_attrs[] = {
__ATTR(dump_channel, 0444, mtk_auxadc_show, NULL),
__ATTR(channel, 0644, mtk_auxadc_show, mtk_auxadc_store),
__ATTR(value, 0444, mtk_auxadc_show, NULL),
__ATTR(regs, 0444, mtk_auxadc_show, NULL),
__ATTR(md_channel, 0644, mtk_auxadc_show, mtk_auxadc_store),
__ATTR(md_value, 0444, mtk_auxadc_show, NULL),
__ATTR(md_dump_channel, 0444, mtk_auxadc_show, NULL),
};
static int get_parameters(char *buf, long int *param, int num_of_par)
{
char *token;
int base, cnt;
token = strsep(&buf, " ");
for (cnt = 0; cnt < num_of_par; cnt++) {
if (token != NULL) {
if ((token[1] == 'x') || (token[1] == 'X'))
base = 16;
else
base = 10;
if (kstrtoul(token, base, &param[cnt]) != 0)
return -EINVAL;
token = strsep(&buf, " ");
} else
return -EINVAL;
}
return 0;
}
static ssize_t mtk_auxadc_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
ptrdiff_t cmd;
int ret;
long int val;
cmd = attr - mtk_auxadc_attrs;
switch (cmd) {
case AUXADC_CHANNEL:
ret = get_parameters((char *)buf, &val, 1);
if (ret < 0) {
pr_notice("get parameter fail\n");
return -EINVAL;
}
auxadc_intf->dbg_chl = val;
break;
default:
break;
}
return count;
}
static ssize_t mtk_auxadc_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ptrdiff_t cmd;
int i;
int value;
cmd = attr - mtk_auxadc_attrs;
buf[0] = '\0';
switch (cmd) {
case AUXADC_DUMP:
snprintf(buf+strlen(buf),
256, "=== Channel Dump Start ===\n");
for (i = 0; i < auxadc_intf->channel_num; i++) {
value = auxadc_intf->ops->get_channel_value(i);
if (value >= 0)
snprintf(buf+strlen(buf), 256,
"Channel%d (%s) = 0x%x(%d)\n",
i, auxadc_intf->channel_name[i],
value, value);
}
snprintf(buf+strlen(buf),
256, "==== Channel Dump End ====\n");
break;
case AUXADC_CHANNEL:
snprintf(buf + strlen(buf), 256, "%d (%s)\n"
, auxadc_intf->dbg_chl
, auxadc_intf->channel_name[auxadc_intf->dbg_chl]);
break;
case AUXADC_VALUE:
value = auxadc_intf->ops->get_channel_value(
auxadc_intf->dbg_chl);
snprintf(buf + strlen(buf), 256, "Channel%d (%s) = 0x%x(%d)\n"
, auxadc_intf->dbg_chl
, auxadc_intf->channel_name[auxadc_intf->dbg_chl]
, value, value);
break;
case AUXADC_REGS:
auxadc_intf->ops->dump_regs(buf);
break;
default:
break;
}
return strlen(buf);
}
static int create_sysfs_interface(struct device *dev)
{
int i;
for (i = 0; i < ARRAY_SIZE(mtk_auxadc_attrs); i++)
if (device_create_file(dev, mtk_auxadc_attrs + i))
return -EINVAL;
return 0;
}
static int remove_sysfs_interface(struct device *dev)
{
int i;
for (i = 0; i < ARRAY_SIZE(mtk_auxadc_attrs); i++)
device_remove_file(dev, mtk_auxadc_attrs + i);
return 0;
}
static int mtk_auxadc_intf_probe(struct platform_device *pdev)
{
int ret;
pr_info("%s\n", __func__);
platform_set_drvdata(pdev, auxadc_intf);
ret = create_sysfs_interface(&pdev->dev);
if (ret < 0) {
pr_notice("%s create sysfs fail\n", __func__);
return -EINVAL;
}
return 0;
}
static int mtk_auxadc_intf_remove(struct platform_device *pdev)
{
int ret;
ret = remove_sysfs_interface(&pdev->dev);
return 0;
}
static struct platform_driver mtk_auxadc_intf_driver = {
.driver = {
.name = "mtk_auxadc_intf",
},
.probe = mtk_auxadc_intf_probe,
.remove = mtk_auxadc_intf_remove,
};
module_platform_driver(mtk_auxadc_intf_driver);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("MTK PMIC AUXADC Interface Driver");
MODULE_AUTHOR("Jeff Chang <jeff_chang@richtek.com>");
MODULE_VERSION("1.0.0_M");
@@ -0,0 +1,310 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <mt-plat/upmu_common.h>
#include "include/pmic.h"
#include "include/pmic_debugfs.h"
#include "include/pmic_irq.h"
#include "include/pmic_throttling_dlpt.h"
#include "include/pmic_lbat_service.h"
/*-------pmic_dbg_level global variable-------*/
unsigned int gPMICDbgLvl;
unsigned int gPMICHKDbgLvl;
unsigned int gPMICIRQDbgLvl;
unsigned int gPMICREGDbgLvl;
unsigned int gPMICCOMDbgLvl; /* so far no used */
#define DUMP_ALL_REG 0
int pmic_pre_wdt_reset(void)
{
int ret = 0;
/* remove dump exception status before wdt, since we will recore
* it at next boot preloader
*/
#if 0
preempt_disable();
local_irq_disable();
pr_info(PMICTAG "[%s][pmic_boot_status]\n", __func__);
pmic_dump_exception_reg();
#if DUMP_ALL_REG
pmic_dump_register();
#endif
#endif
return ret;
}
int pmic_pre_condition1(void)
{
return 0;
}
int pmic_pre_condition2(void)
{
return 0;
}
int pmic_pre_condition3(void)
{
return 0;
}
int pmic_post_condition1(void)
{
return 0;
}
int pmic_post_condition2(void)
{
return 0;
}
int pmic_post_condition3(void)
{
return 0;
}
/*****************************************************************************
* mt-pmic dev_attr APIs
******************************************************************************/
unsigned int g_reg_value;
static ssize_t show_pmic_access(struct device *dev,
struct device_attribute *attr,
char *buf)
{
pr_info("[%s] 0x%x\n", __func__, g_reg_value);
return sprintf(buf, "0x%x\n", g_reg_value);
}
static ssize_t store_pmic_access(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t size)
{
int ret = 0;
char *pvalue = NULL, *addr = NULL, *val = NULL;
unsigned int reg_value = 0;
unsigned int reg_address = 0;
pr_info("[%s]\n", __func__);
if (buf != NULL && size != 0) {
pr_info("[%s] size is %d, buf is %s\n"
, __func__, (int)size, buf);
pvalue = (char *)buf;
addr = strsep(&pvalue, " ");
val = strsep(&pvalue, " ");
if (addr)
ret = kstrtou32(addr, 16, (unsigned int *)&reg_address);
if (val) {
ret = kstrtou32(val, 16, (unsigned int *)&reg_value);
pr_info("[%s] write PMU reg 0x%x with value 0x%x !\n"
, __func__, reg_address, reg_value);
ret = pmic_config_interface(
reg_address, reg_value, 0xFFFF, 0x0);
} else {
ret = pmic_read_interface(
reg_address, &g_reg_value, 0xFFFF, 0x0);
pr_info("[%s] read PMU reg 0x%x with value 0x%x !\n"
, __func__, reg_address, g_reg_value);
pr_info("[%s] use \"cat pmic_access\" to get value\n"
, __func__);
}
}
return size;
}
/*664*/
static DEVICE_ATTR(pmic_access, 0664, show_pmic_access, store_pmic_access);
/*
* PMIC dump exception
*/
static int pmic_dump_exception_show(struct seq_file *s, void *unused)
{
both_dump_exception_reg(s);
return 0;
}
static int pmic_dump_exception_open(struct inode *inode, struct file *file)
{
return single_open(file, pmic_dump_exception_show, NULL);
}
const struct file_operations pmic_dump_exception_operations = {
.open = pmic_dump_exception_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
/*
* PMIC debug level
*/
/*-------pmic_dbg_level-------*/
static ssize_t pmic_dbg_level_write(struct file *file,
const char __user *buf,
size_t size,
loff_t *ppos)
{
char info[10];
unsigned int value = 0;
int ret = 0;
memset(info, 0, 10);
ret = simple_write_to_buffer(info, sizeof(info) - 1, ppos, buf, size);
if (ret < 0)
return ret;
ret = kstrtou32(info, 16, (unsigned int *)&value);
if (ret)
return ret;
pr_info("[%s] value=0x%x\n", __func__, value);
if (value != 0xFFFF) {
pmic_dbg_level_set(value);
pr_info("D %d, HK %d, IRQ %d, REG %d, COM %d\n",
gPMICDbgLvl, gPMICHKDbgLvl, gPMICIRQDbgLvl,
gPMICREGDbgLvl, gPMICCOMDbgLvl);
}
return size;
}
static int pmic_dbg_level_show(struct seq_file *s, void *unused)
{
seq_puts(s, "4:PMIC_LOG_DBG\n");
seq_puts(s, "3:PMIC_LOG_INFO\n");
seq_puts(s, "2:PMIC_LOG_NOT\n");
seq_puts(s, "1:PMIC_LOG_WARN\n");
seq_puts(s, "0:PMIC_LOG_ERR\n");
seq_printf(s, "PMIC_Dbg_Lvl = %d\n", gPMICDbgLvl);
seq_printf(s, "PMIC_HK_Dbg_Lvl = %d\n", gPMICHKDbgLvl);
seq_printf(s, "PMIC_IRQ_Dbg_Lvl = %d\n", gPMICIRQDbgLvl);
seq_printf(s, "PMIC_REG_Dbg_Lvl = %d\n", gPMICREGDbgLvl);
seq_printf(s, "PMIC_COM_Dbg_Lvl = %d\n", gPMICCOMDbgLvl);
return 0;
}
static int pmic_dbg_level_open(struct inode *inode, struct file *file)
{
return single_open(file, pmic_dbg_level_show, NULL);
}
static const struct file_operations pmic_dbg_level_operations = {
.open = pmic_dbg_level_open,
.read = seq_read,
.write = pmic_dbg_level_write,
.llseek = seq_lseek,
.release = single_release,
};
/*
* PMIC reg cmp log
*/
/*----------------pmic reg cmp machanism-----------------------*/
void __attribute__ ((weak)) pmic_cmp_register(struct seq_file *m)
{
}
static int proc_cmp_register_show(struct seq_file *m, void *v)
{
seq_puts(m, "*****Compare PMIC registers with initial setting*****\n");
pmic_cmp_register(m);
return 0;
}
static int proc_cmp_register_open(struct inode *inode, struct file *file)
{
return single_open(file, proc_cmp_register_show, NULL);
}
static const struct file_operations pmic_cmp_register_proc_fops = {
.open = proc_cmp_register_open,
.read = seq_read,
};
/*
* PMIC reg dump log
*/
/*----------------pmic reg dump machanism-----------------------*/
static int proc_dump_register_show(struct seq_file *m, void *v)
{
seq_puts(m, "********** dump PMIC registers**********\n");
pmic_dump_register(m);
return 0;
}
static int proc_dump_register_open(struct inode *inode, struct file *file)
{
return single_open(file, proc_dump_register_show, NULL);
}
static const struct file_operations pmic_dump_register_proc_fops = {
.open = proc_dump_register_open,
.read = seq_read,
};
int __attribute__ ((weak)) pmic_irq_debug_init(struct dentry *debug_dir)
{
return 0;
}
int pmic_debug_init(struct platform_device *dev)
{
struct dentry *mtk_pmic_dir;
int ret_device_file = 0;
mtk_pmic_dir = debugfs_create_dir("mtk_pmic", NULL);
if (!mtk_pmic_dir) {
pr_notice(PMICTAG "fail to mkdir /sys/kernel/debug/mtk_pmic\n");
return -ENOMEM;
}
/*--/sys/kernel/debug/mtk_pmic--*/
debugfs_create_file("dump_pmic_reg", 0644,
mtk_pmic_dir, NULL,
&pmic_dump_register_proc_fops);
debugfs_create_file("cmp_pmic_reg", 0644,
mtk_pmic_dir, NULL,
&pmic_cmp_register_proc_fops);
debugfs_create_file("pmic_dump_exception", (S_IFREG | 0444),
mtk_pmic_dir, NULL,
&pmic_dump_exception_operations);
debugfs_create_file("pmic_dbg_level", (S_IFREG | 0444),
mtk_pmic_dir, NULL,
&pmic_dbg_level_operations);
pmic_regulator_debug_init(dev, mtk_pmic_dir);
pmic_throttling_dlpt_debug_init(dev, mtk_pmic_dir);
pmic_irq_debug_init(mtk_pmic_dir);
lbat_debug_init(mtk_pmic_dir);
PMICLOG("%s debugfs done\n", __func__);
/*--/sys/devices/platform/mt-pmic/ --*/
ret_device_file = device_create_file(&(dev->dev),
&dev_attr_pmic_access);
PMICLOG("%s dev attr done\n", __func__);
return 0;
}
MODULE_AUTHOR("Jimmy-YJ Huang");
MODULE_DESCRIPTION("MT PMIC DEBUGFS Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0.0_M");
@@ -0,0 +1,36 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <mt-plat/upmu_common.h>
#include <linux/io.h>
#include <linux/io.h>
#include <linux/of_address.h>
#include "include/pmic.h"
void PMIC_INIT_SETTING_V1(void)
{
unsigned int chip_version = 0;
chip_version = pmic_get_register_value(PMIC_SWCID);
PMIC_check_battery(); /*--update is_battery_remove--*/
PMIC_check_wdt_status(); /*--update is_wdt_reboot_pmic/chk--*/
/*--------------------------------------------------------*/
if (!PMIC_check_pwrhold_status())
PMIC_POWER_HOLD(1);
PMICLOG("[PMIC] Chip = 0x%x,is_battery_remove =%d, is_wdt_reboot=%d\n"
, chip_version, is_battery_remove, is_wdt_reboot_pmic);
PMIC_LP_INIT_SETTING();
/*****************************************************
* below programming is used for MD setting
*****************************************************/
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
PMIC_MD_INIT_SETTING_V1();
#endif
/*PMIC_PWROFF_SEQ_SETTING();*/
}
@@ -0,0 +1,669 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/list_sort.h>
#include <linux/dcache.h>
#include <linux/debugfs.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/pm_wakeup.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <mt-plat/upmu_common.h>
#include <include/pmic_lbat_service.h>
#define VOLT_TO_RAW(volt) (((volt) << 12) / 5400)
#define RAW_TO_VOLT(thd) (((thd) * 5400) >> 12)
#define USER_SIZE 16
#define DEF_H_DEB 150 /* 150ms */
#define DEF_L_DEB 0 /* no de-bounce */
#define LBAT_PRD 15 /* 15ms */
#define LBAT_SERVICE_DBG 0
static DEFINE_MUTEX(lbat_mutex);
static struct list_head lbat_hv_list = LIST_HEAD_INIT(lbat_hv_list);
static struct list_head lbat_lv_list = LIST_HEAD_INIT(lbat_lv_list);
/* workqueue for SW de-bounce */
static struct workqueue_struct *lbat_wq;
static unsigned int user_count;
enum lbat_thd_type {
LBAT_HV,
LBAT_LV,
};
struct lbat_thd_t {
unsigned int thd_volt;
struct lbat_user *user;
struct list_head list;
};
static struct lbat_thd_t *cur_hv_ptr;
static struct lbat_thd_t *cur_lv_ptr;
static struct lbat_user *lbat_user_table[USER_SIZE];
static void lbat_max_en_setting(int en_val)
{
pmic_set_register_value(PMIC_AUXADC_LBAT_EN_MAX, en_val);
pmic_set_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MAX, en_val);
}
static void lbat_min_en_setting(int en_val)
{
pmic_set_register_value(PMIC_AUXADC_LBAT_EN_MIN, en_val);
pmic_set_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MIN, en_val);
}
static void lbat_irq_enable(void)
{
if (cur_hv_ptr != NULL)
lbat_max_en_setting(1);
if (cur_lv_ptr != NULL)
lbat_min_en_setting(1);
}
static void lbat_irq_disable(void)
{
lbat_max_en_setting(0);
lbat_min_en_setting(0);
}
static int hv_list_cmp(void *priv, struct list_head *a, struct list_head *b)
{
struct lbat_thd_t *thd_a, *thd_b;
thd_a = list_entry(a, struct lbat_thd_t, list);
thd_b = list_entry(b, struct lbat_thd_t, list);
return thd_a->thd_volt - thd_b->thd_volt;
}
static int lv_list_cmp(void *priv, struct list_head *a, struct list_head *b)
{
struct lbat_thd_t *thd_a, *thd_b;
thd_a = list_entry(a, struct lbat_thd_t, list);
thd_b = list_entry(b, struct lbat_thd_t, list);
return thd_b->thd_volt - thd_a->thd_volt;
}
static int modify_lbat_list(enum lbat_thd_type type,
struct lbat_thd_t *thd)
{
if (!thd)
return -EINVAL;
switch (type) {
case LBAT_HV:
list_add(&thd->list, &lbat_hv_list);
list_sort(NULL, &lbat_hv_list, hv_list_cmp);
thd = list_first_entry(&lbat_hv_list,
struct lbat_thd_t, list);
if (cur_hv_ptr != thd) {
cur_hv_ptr = thd;
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MAX,
VOLT_TO_RAW(cur_hv_ptr->thd_volt));
}
break;
case LBAT_LV:
list_add(&thd->list, &lbat_lv_list);
list_sort(NULL, &lbat_lv_list, lv_list_cmp);
thd = list_first_entry(&lbat_lv_list,
struct lbat_thd_t, list);
if (cur_lv_ptr != thd) {
cur_lv_ptr = thd;
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MIN,
VOLT_TO_RAW(cur_lv_ptr->thd_volt));
}
break;
}
return 0;
}
/*
* After execute lbat_user's callback, set next thd node to wait event
*/
static void lbat_set_next_thd(struct lbat_user *user, struct lbat_thd_t *thd)
{
if (thd == user->hv_thd) {
modify_lbat_list(LBAT_LV, user->lv1_thd);
if (!list_empty(&user->lv2_thd->list))
list_del_init(&user->lv2_thd->list);
} else if (thd == user->lv1_thd) {
modify_lbat_list(LBAT_HV, user->hv_thd);
if (list_empty(&user->lv2_thd->list))
modify_lbat_list(LBAT_LV, user->lv2_thd);
}
}
/*
* Execute user's callback and set its next threshold if reach deb_times,
* otherwise ignore this event and reset lbat_list
*/
static void lbat_deb_handler(struct work_struct *work)
{
enum lbat_thd_type type;
unsigned int deb_times;
struct lbat_user *user =
container_of(work, struct lbat_user, deb_work);
mutex_lock(&lbat_mutex);
if (user->deb_thd_ptr == user->hv_thd) {
type = LBAT_HV;
deb_times = user->hv_deb_times;
} else {
type = LBAT_LV;
deb_times = user->lv_deb_times;
}
if (user->deb_cnt >= deb_times) {
/* execute user's callback after de-bounce */
user->callback(user->deb_thd_ptr->thd_volt);
lbat_set_next_thd(user, user->deb_thd_ptr);
} else {
/* ignore this event and reset lbat_list */
modify_lbat_list(type, user->deb_thd_ptr);
}
/* de-bounce done, reset deb_cnt and deb_thd_ptr */
user->deb_cnt = 0;
user->deb_thd_ptr = NULL;
lbat_irq_disable();
udelay(200);
lbat_irq_enable();
mutex_unlock(&lbat_mutex);
}
//static void lbat_timer_func(unsigned long data)
static void lbat_timer_func(struct timer_list *t)
{
unsigned int deb_prd = 0;
unsigned int deb_times = 0;
struct lbat_user *user = from_timer(user, t, deb_timer);
if (user->deb_thd_ptr == user->hv_thd) {
/* LBAT user HV de-bounce */
if (lbat_read_volt() < user->deb_thd_ptr->thd_volt) {
/* queue deb_work to reset lbat_list */
goto wq_handler;
}
deb_prd = user->hv_deb_prd;
deb_times = user->hv_deb_times;
} else if (user->deb_thd_ptr == user->lv1_thd ||
user->deb_thd_ptr == user->lv2_thd) {
/* LBAT user LV de-bounce */
if (lbat_read_volt() > user->deb_thd_ptr->thd_volt) {
/* queue deb_work to reset lbat_list */
goto wq_handler;
}
deb_prd = user->lv_deb_prd;
deb_times = user->lv_deb_times;
} else {
pr_notice("[%s] LBAT de-bounce threshold not match\n",
__func__);
return;
}
user->deb_cnt++;
#if LBAT_SERVICE_DBG
pr_info("[%s] name:%s, thd_volt:%d, de-bounce times:%d\n",
__func__, user->name,
user->deb_thd_ptr->thd_volt, user->deb_cnt);
#endif
if (user->deb_cnt < deb_times) {
mod_timer(&user->deb_timer,
jiffies + msecs_to_jiffies(deb_prd));
return;
}
wq_handler:
/* queue deb_work to execute user's callback or reset lbat_list */
queue_work(lbat_wq, &user->deb_work);
}
static void lbat_user_init_timer(struct lbat_user *user)
{
user->deb_cnt = 0;
user->hv_deb_prd = 0;
user->hv_deb_times = 0;
user->lv_deb_prd = 0;
user->lv_deb_times = 0;
/*workaround for mt6768*/
//init_timer(&user->deb_timer);
//user->deb_timer.data = (unsigned long)user;
//user->deb_timer.expires = 0;
//user->deb_timer.function = lbat_timer_func;
timer_setup(&user->deb_timer, lbat_timer_func, 0);
}
static int lbat_user_update(struct lbat_user *user)
{
/*
* add lv_thd to lbat_lv_list
* and assign first entry of lv_list to cur_lv_ptr
*/
modify_lbat_list(LBAT_LV, user->lv1_thd);
if (user_count == 0)
lbat_min_en_setting(1);
lbat_user_table[user_count++] = user;
return 0;
}
static struct lbat_thd_t *lbat_thd_init(unsigned int thd_volt,
struct lbat_user *user)
{
struct lbat_thd_t *thd;
if (thd_volt == 0)
return NULL;
thd = kzalloc(sizeof(*thd), GFP_KERNEL);
if (thd == NULL)
return NULL;
thd->thd_volt = thd_volt;
thd->user = user;
INIT_LIST_HEAD(&thd->list);
return thd;
}
struct lbat_user *lbat_user_register(const char *name,
unsigned int hv_thd_volt,
unsigned int lv1_thd_volt, unsigned int lv2_thd_volt,
void (*callback)(unsigned int thd_volt))
{
int ret = 0;
struct lbat_user *user = NULL;
mutex_lock(&lbat_mutex);
user = kzalloc(sizeof(*user), GFP_KERNEL);
if (user == NULL) {
ret = -10;
goto out;
}
strncpy(user->name, name, strlen(user->name));
if (hv_thd_volt >= 5400 || lv1_thd_volt <= 2650) {
ret = -11;
goto out;
} else if (hv_thd_volt < lv1_thd_volt ||
lv1_thd_volt < lv2_thd_volt) {
ret = -12;
goto out;
} else if (callback == NULL) {
ret = -13;
goto out;
}
user->hv_thd = lbat_thd_init(hv_thd_volt, user);
user->lv1_thd = lbat_thd_init(lv1_thd_volt, user);
user->lv2_thd = lbat_thd_init(lv2_thd_volt, user);
user->callback = callback;
lbat_user_init_timer(user);
INIT_WORK(&user->deb_work, lbat_deb_handler);
pr_info("[%s] hv=%d, lv1=%d, lv2=%d\n",
__func__, hv_thd_volt, lv1_thd_volt, lv2_thd_volt);
ret = lbat_user_update(user);
out:
if (ret)
pr_notice("[%s] error ret=%d\n", __func__, ret);
mutex_unlock(&lbat_mutex);
return user;
}
EXPORT_SYMBOL(lbat_user_register);
int lbat_user_set_debounce(struct lbat_user *user,
unsigned int hv_deb_prd, unsigned int hv_deb_times,
unsigned int lv_deb_prd, unsigned int lv_deb_times)
{
if (IS_ERR(user))
return PTR_ERR(user);
user->hv_deb_prd = hv_deb_prd;
user->hv_deb_times = hv_deb_times;
user->lv_deb_prd = lv_deb_prd;
user->lv_deb_times = lv_deb_times;
return 0;
}
EXPORT_SYMBOL(lbat_user_set_debounce);
static irqreturn_t bat_h_int_handler(int irq, void *data)
{
struct lbat_user *user;
if (cur_hv_ptr == NULL) {
lbat_max_en_setting(0);
return IRQ_NONE;
}
mutex_lock(&lbat_mutex);
pr_info("[%s] cur_thd_volt=%d\n", __func__, cur_hv_ptr->thd_volt);
user = cur_hv_ptr->user;
list_del_init(&cur_hv_ptr->list);
if (user->hv_deb_times) {
user->deb_cnt = 0;
user->deb_thd_ptr = cur_hv_ptr;
mod_timer(&user->deb_timer,
jiffies + msecs_to_jiffies(user->hv_deb_prd));
} else {
user->callback(cur_hv_ptr->thd_volt);
lbat_set_next_thd(user, cur_hv_ptr);
}
/* Since cur_hv_ptr is removed, assign new thd for cur_hv_ptr */
if (list_empty(&lbat_hv_list)) {
cur_hv_ptr = NULL;
goto out;
}
cur_hv_ptr = list_first_entry(
&lbat_hv_list, struct lbat_thd_t, list);
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MAX,
VOLT_TO_RAW(cur_hv_ptr->thd_volt));
out:
lbat_irq_disable();
udelay(200);
lbat_irq_enable();
mutex_unlock(&lbat_mutex);
return IRQ_HANDLED;
}
static irqreturn_t bat_l_int_handler(int irq, void *data)
{
struct lbat_user *user;
if (cur_lv_ptr == NULL) {
lbat_min_en_setting(0);
return IRQ_NONE;
}
mutex_lock(&lbat_mutex);
pr_info("[%s] cur_thd_volt=%d\n", __func__, cur_lv_ptr->thd_volt);
user = cur_lv_ptr->user;
list_del_init(&cur_lv_ptr->list);
if (user->lv_deb_times) {
user->deb_cnt = 0;
user->deb_thd_ptr = cur_lv_ptr;
mod_timer(&user->deb_timer,
jiffies + msecs_to_jiffies(user->lv_deb_prd));
} else {
user->callback(cur_lv_ptr->thd_volt);
lbat_set_next_thd(user, cur_lv_ptr);
}
/* Since cur_lv_ptr is removed, assign new thd for cur_lv_ptr */
if (list_empty(&lbat_lv_list)) {
cur_lv_ptr = NULL;
goto out;
}
cur_lv_ptr = list_first_entry(
&lbat_lv_list, struct lbat_thd_t, list);
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MIN,
VOLT_TO_RAW(cur_lv_ptr->thd_volt));
out:
lbat_irq_disable();
udelay(200);
lbat_irq_enable();
mutex_unlock(&lbat_mutex);
return IRQ_HANDLED;
}
void lbat_suspend(void)
{
lbat_irq_disable();
}
void lbat_resume(void)
{
lbat_irq_enable();
}
int lbat_service_init(struct platform_device *pdev)
{
int ret = 0;
pr_info("[%s]\n", __func__);
pmic_set_register_value(PMIC_AUXADC_LBAT_DEBT_MAX,
DEF_H_DEB / LBAT_PRD);
pmic_set_register_value(PMIC_AUXADC_LBAT_DEBT_MIN,
DEF_L_DEB / LBAT_PRD);
pmic_set_register_value(
PMIC_AUXADC_LBAT_DET_PRD_15_0,
LBAT_PRD);
pmic_set_register_value(
PMIC_AUXADC_LBAT_DET_PRD_19_16,
(LBAT_PRD & 0xF0000) >> 16);
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "bat_h"),
NULL, bat_h_int_handler, IRQF_TRIGGER_NONE,
"bat_h", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request bat_h irq fail\n");
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "bat_l"),
NULL, bat_l_int_handler, IRQF_TRIGGER_NONE,
"bat_l", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request bat_l irq fail\n");
lbat_wq = create_singlethread_workqueue("lbat_service");
return ret;
}
unsigned int lbat_read_raw(void)
{
return pmic_get_register_value(PMIC_AUXADC_ADC_OUT_LBAT);
}
unsigned int lbat_read_volt(void)
{
unsigned int raw_data = lbat_read_raw();
return RAW_TO_VOLT(raw_data);
}
/*
* Lbat service debug
*/
void lbat_dump_reg(void)
{
pr_notice("AUXADC_LBAT_VOLT_MAX = 0x%x, AUXADC_LBAT_VOLT_MIN = 0x%x, RG_INT_EN_BAT_H = %d, RG_INT_EN_BAT_L = %d\n"
, pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MIN)
, pmic_get_register_value(PMIC_RG_INT_EN_BAT_H)
, pmic_get_register_value(PMIC_RG_INT_EN_BAT_L));
pr_notice("AUXADC_LBAT_EN_MAX = %d, AUXADC_LBAT_IRQ_EN_MAX = %d, AUXADC_LBAT_EN_MIN = %d, AUXADC_LBAT_IRQ_EN_MIN = %d\n"
, pmic_get_register_value(PMIC_AUXADC_LBAT_EN_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_EN_MIN)
, pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MIN));
pr_notice("AUXADC_LBAT_DEBT_MAX=%d, AUXADC_LBAT_DEBT_MIN=%d\n"
, pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MIN));
}
static void lbat_dump_thd_list(struct seq_file *s)
{
unsigned int len = 0;
char str[128] = "";
struct lbat_thd_t *thd = NULL;
if (list_empty(&lbat_hv_list) && list_empty(&lbat_lv_list)) {
pr_notice("[%s] no entry in lbat list\n", __func__);
seq_puts(s, "no entry in lbat list\n");
return;
}
mutex_lock(&lbat_mutex);
list_for_each_entry(thd, &lbat_hv_list, list) {
len += snprintf(str + len, sizeof(str) - len,
"%shv_list, thd_volt:%d, user:%s\n",
(thd == cur_hv_ptr ||
thd == cur_lv_ptr) ? "->" : " ",
thd->thd_volt, thd->user->name);
pr_notice("%s", str);
seq_printf(s, "%s", str);
strncpy(str, "", strlen(str));
len = 0;
}
pr_notice("\n");
seq_puts(s, "\n");
list_for_each_entry(thd, &lbat_lv_list, list) {
len += snprintf(str + len, sizeof(str) - len,
"%slv_list, thd_volt:%d, user:%s\n",
(thd == cur_hv_ptr ||
thd == cur_lv_ptr) ? "->" : " ",
thd->thd_volt, thd->user->name);
pr_notice("%s", str);
seq_printf(s, "%s", str);
strncpy(str, "", strlen(str));
len = 0;
}
pr_notice("\n");
mutex_unlock(&lbat_mutex);
}
static void lbat_dbg_dump_reg(struct seq_file *s)
{
lbat_dump_reg();
seq_printf(s, "AUXADC_LBAT_VOLT_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MAX));
seq_printf(s, "AUXADC_LBAT_VOLT_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MIN));
seq_printf(s, "RG_INT_EN_BAT_H = 0x%x\n",
pmic_get_register_value(PMIC_RG_INT_EN_BAT_H));
seq_printf(s, "RG_INT_EN_BAT_L = 0x%x\n",
pmic_get_register_value(PMIC_RG_INT_EN_BAT_L));
seq_printf(s, "AUXADC_LBAT_EN_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_EN_MAX));
seq_printf(s, "AUXADC_LBAT_IRQ_EN_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MAX));
seq_printf(s, "AUXADC_LBAT_EN_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_EN_MIN));
seq_printf(s, "AUXADC_LBAT_IRQ_EN_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MIN));
seq_printf(s, "AUXADC_LBAT_DEBT_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MAX));
seq_printf(s, "AUXADC_LBAT_DEBT_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MIN));
seq_printf(s, "AUXADC_ADC_RDY_LBAT = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_ADC_RDY_LBAT));
seq_printf(s, "AUXADC_ADC_OUT_LBAT = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_ADC_OUT_LBAT));
}
static void lbat_dump_user_table(struct seq_file *s)
{
unsigned int i;
struct lbat_user *user;
mutex_lock(&lbat_mutex);
for (i = 0; i < user_count; i++) {
user = lbat_user_table[i];
seq_printf(s, "%2d:%20s, %d, %d, %d, (%d,%d,%d,%d), %pf\n",
i, user->name,
user->hv_thd->thd_volt,
user->lv1_thd->thd_volt, user->lv2_thd->thd_volt,
user->hv_deb_prd, user->hv_deb_times,
user->lv_deb_prd, user->lv_deb_times,
user->callback);
}
mutex_unlock(&lbat_mutex);
}
struct lbat_dbg_st {
unsigned int dbg_id;
};
enum {
LBAT_DBG_DUMP_LIST,
LBAT_DBG_DUMP_REG,
LBAT_DBG_DUMP_TABLE,
LBAT_DBG_MAX,
};
static struct lbat_dbg_st dbg_data[LBAT_DBG_MAX];
static int lbat_dbg_show(struct seq_file *s, void *unused)
{
struct lbat_dbg_st *dbg_st = s->private;
switch (dbg_st->dbg_id) {
case LBAT_DBG_DUMP_LIST:
lbat_dump_thd_list(s);
break;
case LBAT_DBG_DUMP_REG:
lbat_dbg_dump_reg(s);
break;
case LBAT_DBG_DUMP_TABLE:
lbat_dump_user_table(s);
break;
default:
break;
}
return 0;
}
static int lbat_dbg_open(struct inode *inode, struct file *file)
{
if (file->f_mode & FMODE_READ)
return single_open(file, lbat_dbg_show, inode->i_private);
file->private_data = inode->i_private;
return 0;
}
static ssize_t lbat_dbg_write(struct file *file,
const char __user *user_buffer, size_t count, loff_t *position)
{
return count;
}
static int lbat_dbg_release(struct inode *inode, struct file *file)
{
if (file->f_mode & FMODE_READ)
return single_release(inode, file);
return 0;
}
static const struct file_operations lbat_dbg_fops = {
.open = lbat_dbg_open,
.read = seq_read,
.write = lbat_dbg_write,
.llseek = seq_lseek,
.release = lbat_dbg_release,
};
int lbat_debug_init(struct dentry *debug_dir)
{
struct dentry *lbat_dbg_dir;
if (IS_ERR(debug_dir) || !debug_dir) {
pr_notice("dir mtk_pmic does not exist\n");
return -1;
}
lbat_dbg_dir = debugfs_create_dir("lbat_dbg", debug_dir);
if (IS_ERR(lbat_dbg_dir) || !lbat_dbg_dir) {
pr_notice("fail mkdir /sys/kernel/debug/mtk_pmic/lbat_dbg\n");
return -1;
}
/* lbat service debug init */
dbg_data[0].dbg_id = LBAT_DBG_DUMP_LIST;
/* file type is regular file(S_IFREG), permission is read(444) */
debugfs_create_file("lbat_dump_list", (S_IFREG | 0444),
lbat_dbg_dir, (void *)&dbg_data[0], &lbat_dbg_fops);
dbg_data[1].dbg_id = LBAT_DBG_DUMP_REG;
debugfs_create_file("lbat_dump_reg", (S_IFREG | 0444),
lbat_dbg_dir, (void *)&dbg_data[1], &lbat_dbg_fops);
dbg_data[2].dbg_id = LBAT_DBG_DUMP_TABLE;
debugfs_create_file("lbat_dump_table", (S_IFREG | 0444),
lbat_dbg_dir, (void *)&dbg_data[2], &lbat_dbg_fops);
return 0;
}
@@ -0,0 +1,784 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/list_sort.h>
#include <linux/dcache.h>
#include <linux/debugfs.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include <linux/pm_wakeup.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <linux/of.h>
#include <mt-plat/upmu_common.h>
#include <include/pmic_lbat_service.h>
#define USER_SIZE 16
#define LBAT_SERVICE_DBG 0
static DEFINE_MUTEX(lbat_mutex);
static struct list_head lbat_hv_list = LIST_HEAD_INIT(lbat_hv_list);
static struct list_head lbat_lv_list = LIST_HEAD_INIT(lbat_lv_list);
/* workqueue for SW de-bounce */
static struct workqueue_struct *lbat_wq;
static unsigned int user_count;
enum lbat_thd_type {
LBAT_HV,
LBAT_LV,
};
struct lbat_thd_t {
unsigned int thd_volt;
struct lbat_user *user;
struct list_head list;
};
static struct lbat_thd_t *cur_hv_ptr;
static struct lbat_thd_t *cur_lv_ptr;
static struct lbat_user *lbat_user_table[USER_SIZE];
static unsigned int r_ratio[2];
static unsigned int VOLT_TO_RAW(unsigned int volt)
{
return (volt << 12) / (1800 * r_ratio[0] / r_ratio[1]);
}
static void lbat_max_en_setting(int en_val)
{
pmic_set_register_value(PMIC_AUXADC_LBAT_DET_MAX, en_val);
pmic_set_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MAX, en_val);
}
static void lbat_min_en_setting(int en_val)
{
pmic_set_register_value(PMIC_AUXADC_LBAT_DET_MIN, en_val);
pmic_set_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MIN, en_val);
}
static void lbat_irq_enable(void)
{
if (cur_hv_ptr != NULL)
lbat_max_en_setting(1);
if (cur_lv_ptr != NULL)
lbat_min_en_setting(1);
pmic_set_register_value(PMIC_AUXADC_LBAT_EN, 1);
}
static void lbat_irq_disable(void)
{
pmic_set_register_value(PMIC_AUXADC_LBAT_EN, 0);
lbat_max_en_setting(0);
lbat_min_en_setting(0);
}
static int hv_list_cmp(void *priv, struct list_head *a, struct list_head *b)
{
struct lbat_thd_t *thd_a, *thd_b;
thd_a = list_entry(a, struct lbat_thd_t, list);
thd_b = list_entry(b, struct lbat_thd_t, list);
return thd_a->thd_volt - thd_b->thd_volt;
}
static int lv_list_cmp(void *priv, struct list_head *a, struct list_head *b)
{
struct lbat_thd_t *thd_a, *thd_b;
thd_a = list_entry(a, struct lbat_thd_t, list);
thd_b = list_entry(b, struct lbat_thd_t, list);
return thd_b->thd_volt - thd_a->thd_volt;
}
static int modify_lbat_list(enum lbat_thd_type type,
struct lbat_thd_t *thd)
{
if (!thd)
return -EINVAL;
switch (type) {
case LBAT_HV:
list_move(&thd->list, &lbat_hv_list);
list_sort(NULL, &lbat_hv_list, hv_list_cmp);
thd = list_first_entry(&lbat_hv_list,
struct lbat_thd_t, list);
if (cur_hv_ptr != thd) {
cur_hv_ptr = thd;
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MAX,
VOLT_TO_RAW(cur_hv_ptr->thd_volt));
}
break;
case LBAT_LV:
list_move(&thd->list, &lbat_lv_list);
list_sort(NULL, &lbat_lv_list, lv_list_cmp);
thd = list_first_entry(&lbat_lv_list,
struct lbat_thd_t, list);
if (cur_lv_ptr != thd) {
cur_lv_ptr = thd;
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MIN,
VOLT_TO_RAW(cur_lv_ptr->thd_volt));
}
break;
}
return 0;
}
static inline int list_is_first(const struct list_head *list,
const struct list_head *head)
{
return list->prev == head;
}
/*
* After execute lbat_user's callback, set next thd node to wait event
*/
static void lbat_hv_set_next_thd(struct lbat_user *user, struct lbat_thd_t *thd)
{
/* restore user->thd_list */
list_move(&thd->list, &user->thd_list);
list_sort(NULL, &user->thd_list, lv_list_cmp);
/* HV is triggered */
if (!list_is_first(&thd->list, &user->thd_list)) /* Not first */
modify_lbat_list(LBAT_HV, list_prev_entry(thd, list));
if (!list_is_last(&thd->list, &user->thd_list)) /* Not last */
modify_lbat_list(LBAT_LV, list_next_entry(thd, list));
}
static void lbat_lv_set_next_thd(struct lbat_user *user, struct lbat_thd_t *thd)
{
/* restore user->thd_list */
list_move(&thd->list, &user->thd_list);
list_sort(NULL, &user->thd_list, lv_list_cmp);
/* LV is triggered */
if (!list_is_first(&thd->list, &user->thd_list)) /* Not first */
modify_lbat_list(LBAT_HV, list_prev_entry(thd, list));
if (!list_is_last(&thd->list, &user->thd_list)) /* Not last */
modify_lbat_list(LBAT_LV, list_next_entry(thd, list));
}
static void lbat_set_next_thd(struct lbat_user *user, struct lbat_thd_t *thd)
{
if (thd == user->hv_thd) {
modify_lbat_list(LBAT_LV, user->lv1_thd);
if (!list_empty(&user->lv2_thd->list))
list_del_init(&user->lv2_thd->list);
} else if (thd == user->lv1_thd) {
modify_lbat_list(LBAT_HV, user->hv_thd);
if (list_empty(&user->lv2_thd->list))
modify_lbat_list(LBAT_LV, user->lv2_thd);
}
}
/*
* Execute user's callback and set its next threshold if reach deb_times,
* otherwise ignore this event and reset lbat_list
*/
// workaround for mt6877
static void lbat_deb_handler(struct work_struct *work)
{
enum lbat_thd_type type;
unsigned int deb_times;
struct lbat_user *user =
container_of(work, struct lbat_user, deb_work);
mutex_lock(&lbat_mutex);
if (user->deb_thd_ptr == user->hv_thd) {
type = LBAT_HV;
deb_times = user->hv_deb_times;
} else {
type = LBAT_LV;
deb_times = user->lv_deb_times;
}
if (user->deb_cnt >= deb_times) {
/* execute user's callback after de-bounce */
user->callback(user->deb_thd_ptr->thd_volt);
lbat_set_next_thd(user, user->deb_thd_ptr);
} else {
/* ignore this event and reset lbat_list */
modify_lbat_list(type, user->deb_thd_ptr);
}
/* de-bounce done, reset deb_cnt and deb_thd_ptr */
user->deb_cnt = 0;
user->deb_thd_ptr = NULL;
lbat_irq_disable();
udelay(200);
lbat_irq_enable();
mutex_unlock(&lbat_mutex);
}
//static void lbat_timer_func(unsigned long data)
static void lbat_timer_func(struct timer_list *t)
{
unsigned int deb_prd = 0;
unsigned int deb_times = 0;
// struct lbat_user *user = (struct lbat_user *)data;
struct lbat_user *user = from_timer(user, t, deb_timer);
if (user->deb_thd_ptr == user->hv_thd) {
/* LBAT user HV de-bounce */
if (lbat_read_volt() < user->deb_thd_ptr->thd_volt) {
/* queue deb_work to reset lbat_list */
goto wq_handler;
}
deb_prd = user->hv_deb_prd;
deb_times = user->hv_deb_times;
} else if (user->deb_thd_ptr == user->lv1_thd ||
user->deb_thd_ptr == user->lv2_thd) {
/* LBAT user LV de-bounce */
if (lbat_read_volt() > user->deb_thd_ptr->thd_volt) {
/* queue deb_work to reset lbat_list */
goto wq_handler;
}
deb_prd = user->lv_deb_prd;
deb_times = user->lv_deb_times;
} else {
pr_notice("[%s] LBAT de-bounce threshold not match\n",
__func__);
return;
}
user->deb_cnt++;
#if LBAT_SERVICE_DBG
pr_info("[%s] name:%s, thd_volt:%d, de-bounce times:%d\n",
__func__, user->name,
user->deb_thd_ptr->thd_volt, user->deb_cnt);
#endif
if (user->deb_cnt < deb_times) {
mod_timer(&user->deb_timer,
jiffies + msecs_to_jiffies(deb_prd));
return;
}
wq_handler:
/* queue deb_work to execute user's callback or reset lbat_list */
queue_work(lbat_wq, &user->deb_work);
}
static void lbat_user_init_timer(struct lbat_user *user)
{
user->deb_cnt = 0;
user->hv_deb_prd = 0;
user->hv_deb_times = 0;
user->lv_deb_prd = 0;
user->lv_deb_times = 0;
//init_timer(&user->deb_timer);
//user->deb_timer.data = (unsigned long)user;
//user->deb_timer.expires = 0;
//user->deb_timer.function = lbat_timer_func;
timer_setup(&user->deb_timer, lbat_timer_func, 0);
}
static int lbat_user_update(struct lbat_user *user)
{
struct lbat_thd_t *thd;
/*
* add lv_thd to lbat_lv_list
* and assign first entry of lv_list to cur_lv_ptr
*/
if (list_empty(&user->thd_list))
thd = user->lv1_thd;
else {
thd = list_first_entry(&user->thd_list,
struct lbat_thd_t, list);
thd = list_next_entry(thd, list);
}
modify_lbat_list(LBAT_LV, thd);
if (user_count == 0)
lbat_irq_enable();
lbat_user_table[user_count++] = user;
return 0;
}
static struct lbat_thd_t *lbat_thd_init(unsigned int thd_volt,
struct lbat_user *user)
{
struct lbat_thd_t *thd = NULL;
if (thd_volt == 0)
return NULL;
thd = kzalloc(sizeof(*thd), GFP_KERNEL);
if (thd == NULL)
return NULL;
thd->thd_volt = thd_volt;
thd->user = user;
INIT_LIST_HEAD(&thd->list);
return thd;
}
struct lbat_user *lbat_user_register_ext(const char *name,
unsigned int *thd_volt_arr, unsigned int thd_volt_size,
void (*callback)(unsigned int thd_volt))
{
int i, ret;
struct lbat_thd_t *thd;
struct lbat_user *user;
mutex_lock(&lbat_mutex);
user = kzalloc(sizeof(*user), GFP_KERNEL);
if (user == NULL) {
ret = -10;
goto out;
}
strncpy(user->name, name, ARRAY_SIZE(user->name) - 1);
if (thd_volt_arr[0] >= 5400 || thd_volt_arr[thd_volt_size - 1] <= 2000) {
ret = -EINVAL;
goto out;
} else if (callback == NULL) {
ret = -EINVAL;
goto out;
}
INIT_LIST_HEAD(&user->thd_list);
thd = lbat_thd_init(thd_volt_arr[0], user);
for (i = 0; i < thd_volt_size; i++) {
thd = lbat_thd_init(thd_volt_arr[i], user);
list_add_tail(&thd->list, &user->thd_list);
}
user->callback = callback;
lbat_user_init_timer(user);
INIT_WORK(&user->deb_work, lbat_deb_handler);
pr_info("[%s] name=%s, thd_volt_max=%d, thd_volt_min=%d\n", __func__,
user->name, thd_volt_arr[0], thd_volt_arr[thd_volt_size - 1]);
ret = lbat_user_update(user);
out:
if (ret)
pr_notice("[%s] error ret=%d\n", __func__, ret);
mutex_unlock(&lbat_mutex);
return user;
}
EXPORT_SYMBOL(lbat_user_register_ext);
struct lbat_user *lbat_user_register(const char *name,
unsigned int hv_thd_volt,
unsigned int lv1_thd_volt, unsigned int lv2_thd_volt,
void (*callback)(unsigned int thd_volt))
{
int ret = 0;
struct lbat_user *user;
mutex_lock(&lbat_mutex);
user = kzalloc(sizeof(*user), GFP_KERNEL);
if (user == NULL) {
ret = -10;
goto out;
}
strncpy(user->name, name, ARRAY_SIZE(user->name) - 1);
if (hv_thd_volt >= 5400 || lv1_thd_volt <= 2650) {
ret = -11;
goto out;
} else if (hv_thd_volt < lv1_thd_volt ||
lv1_thd_volt < lv2_thd_volt) {
ret = -12;
goto out;
} else if (callback == NULL) {
ret = -13;
goto out;
}
INIT_LIST_HEAD(&user->thd_list);
user->hv_thd = lbat_thd_init(hv_thd_volt, user);
user->lv1_thd = lbat_thd_init(lv1_thd_volt, user);
user->lv2_thd = lbat_thd_init(lv2_thd_volt, user);
user->callback = callback;
lbat_user_init_timer(user);
INIT_WORK(&user->deb_work, lbat_deb_handler);
pr_info("[%s] name=%s, hv=%d, lv1=%d, lv2=%d\n",
__func__, name, hv_thd_volt, lv1_thd_volt, lv2_thd_volt);
ret = lbat_user_update(user);
out:
if (ret)
pr_notice("[%s] error ret=%d\n", __func__, ret);
mutex_unlock(&lbat_mutex);
return user;
}
EXPORT_SYMBOL(lbat_user_register);
int lbat_user_set_debounce(struct lbat_user *user,
unsigned int hv_deb_prd, unsigned int hv_deb_times,
unsigned int lv_deb_prd, unsigned int lv_deb_times)
{
if (IS_ERR(user))
return PTR_ERR(user);
user->hv_deb_prd = hv_deb_prd;
user->hv_deb_times = hv_deb_times;
user->lv_deb_prd = lv_deb_prd;
user->lv_deb_times = lv_deb_times;
return 0;
}
EXPORT_SYMBOL(lbat_user_set_debounce);
static irqreturn_t bat_h_int_handler(int irq, void *data)
{
struct lbat_user *user = NULL;
if (cur_hv_ptr == NULL) {
lbat_max_en_setting(0);
return IRQ_NONE;
}
mutex_lock(&lbat_mutex);
pr_info("[%s] cur_thd_volt=%d\n", __func__, cur_hv_ptr->thd_volt);
user = cur_hv_ptr->user;
list_del_init(&cur_hv_ptr->list);
if (user->hv_deb_times) {
user->deb_cnt = 0;
user->deb_thd_ptr = cur_hv_ptr;
mod_timer(&user->deb_timer,
jiffies + msecs_to_jiffies(user->hv_deb_prd));
} else {
user->callback(cur_hv_ptr->thd_volt);
if (list_empty(&user->thd_list))
lbat_set_next_thd(user, cur_hv_ptr);
else
lbat_hv_set_next_thd(user, cur_hv_ptr);
}
/* Since cur_hv_ptr is removed, assign new thd for cur_hv_ptr */
if (list_empty(&lbat_hv_list)) {
cur_hv_ptr = NULL;
goto out;
}
cur_hv_ptr = list_first_entry(
&lbat_hv_list, struct lbat_thd_t, list);
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MAX,
VOLT_TO_RAW(cur_hv_ptr->thd_volt));
out:
lbat_irq_disable();
udelay(200);
lbat_irq_enable();
mutex_unlock(&lbat_mutex);
return IRQ_HANDLED;
}
static irqreturn_t bat_l_int_handler(int irq, void *data)
{
struct lbat_user *user = NULL;
if (cur_lv_ptr == NULL) {
lbat_min_en_setting(0);
return IRQ_NONE;
}
mutex_lock(&lbat_mutex);
pr_info("[%s] cur_thd_volt=%d\n", __func__, cur_lv_ptr->thd_volt);
user = cur_lv_ptr->user;
list_del_init(&cur_lv_ptr->list);
if (user->lv_deb_times) {
user->deb_cnt = 0;
user->deb_thd_ptr = cur_lv_ptr;
mod_timer(&user->deb_timer,
jiffies + msecs_to_jiffies(user->lv_deb_prd));
} else {
user->callback(cur_lv_ptr->thd_volt);
if (list_empty(&user->thd_list))
lbat_set_next_thd(user, cur_lv_ptr);
else
lbat_lv_set_next_thd(user, cur_lv_ptr);
}
/* Since cur_lv_ptr is removed, assign new thd for cur_lv_ptr */
if (list_empty(&lbat_lv_list)) {
cur_lv_ptr = NULL;
goto out;
}
cur_lv_ptr = list_first_entry(
&lbat_lv_list, struct lbat_thd_t, list);
pmic_set_register_value(PMIC_AUXADC_LBAT_VOLT_MIN,
VOLT_TO_RAW(cur_lv_ptr->thd_volt));
out:
lbat_irq_disable();
udelay(200);
lbat_irq_enable();
mutex_unlock(&lbat_mutex);
return IRQ_HANDLED;
}
void lbat_suspend(void)
{
lbat_irq_disable();
}
void lbat_resume(void)
{
lbat_irq_enable();
}
int lbat_service_init(struct platform_device *pdev)
{
int ret = 0;
struct device_node *np = NULL;
pr_info("[%s]\n", __func__);
/* Selects debounce as 8 */
pmic_set_register_value(PMIC_AUXADC_LBAT_DEBT_MAX_SEL, 3);
/* Selects debounce as 1 */
pmic_set_register_value(PMIC_AUXADC_LBAT_DEBT_MIN_SEL, 0);
/* Set LBAT_PRD as 15ms */
pmic_set_register_value(PMIC_AUXADC_LBAT_DET_PRD_SEL, 0);
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "bat_h"),
NULL, bat_h_int_handler, IRQF_TRIGGER_NONE,
"bat_h", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request bat_h irq fail\n");
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "bat_l"),
NULL, bat_l_int_handler, IRQF_TRIGGER_NONE,
"bat_l", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request bat_l irq fail\n");
lbat_wq = create_singlethread_workqueue("lbat_service");
/* get LBAT r_ratio */
np = of_find_node_by_name(NULL, "batadc");
if (!np) {
pr_notice("[%s] get batadc node fail\n", __func__);
r_ratio[0] = 7;
r_ratio[1] = 2;
return 0;
}
ret = of_property_read_u32_array(np, "resistance-ratio", r_ratio, 2);
pr_info("[%s] r_ratio = %d/%d\n", __func__, r_ratio[0], r_ratio[1]);
return ret;
}
unsigned int lbat_read_raw(void)
{
return pmic_get_register_value(PMIC_AUXADC_ADC_OUT_LBAT);
}
unsigned int lbat_read_volt(void)
{
unsigned int raw_data = lbat_read_raw();
return (raw_data * 1800 * r_ratio[0] / r_ratio[1]) >> 12;
}
/*
* Lbat service debug
*/
void lbat_dump_reg(void)
{
pr_notice("AUXADC_LBAT_VOLT_MAX = 0x%x, AUXADC_LBAT_VOLT_MIN = 0x%x, RG_INT_EN_BAT_H = %d, RG_INT_EN_BAT_L = %d\n"
, pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MIN)
, pmic_get_register_value(PMIC_RG_INT_EN_BAT_H)
, pmic_get_register_value(PMIC_RG_INT_EN_BAT_L));
pr_notice("AUXADC_LBAT_EN = %d, AUXADC_LBAT_DET_MAX = %d, AUXADC_LBAT_IRQ_EN_MAX = %d, AUXADC_LBAT_DET_MIN = %d, AUXADC_LBAT_IRQ_EN_MIN = %d\n"
, pmic_get_register_value(PMIC_AUXADC_LBAT_EN)
, pmic_get_register_value(PMIC_AUXADC_LBAT_DET_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MAX)
, pmic_get_register_value(PMIC_AUXADC_LBAT_DET_MIN)
, pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MIN));
pr_notice("AUXADC_LBAT_DEBT_MAX_SEL=%d, AUXADC_LBAT_DEBT_MIN_SEL=%d\n"
, pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MAX_SEL)
, pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MIN_SEL));
}
static void lbat_dump_thd_list(struct seq_file *s)
{
unsigned int len = 0;
char str[128] = "";
struct lbat_thd_t *thd = NULL;
if (list_empty(&lbat_hv_list) && list_empty(&lbat_lv_list)) {
pr_notice("[%s] no entry in lbat list\n", __func__);
seq_puts(s, "no entry in lbat list\n");
return;
}
mutex_lock(&lbat_mutex);
list_for_each_entry(thd, &lbat_hv_list, list) {
len += snprintf(str + len, sizeof(str) - len,
"%shv_list, thd_volt:%d, user:%s\n",
(thd == cur_hv_ptr ||
thd == cur_lv_ptr) ? "->" : " ",
thd->thd_volt, thd->user->name);
pr_notice("%s", str);
seq_printf(s, "%s", str);
strncpy(str, "", strlen(str));
len = 0;
}
pr_notice("\n");
seq_puts(s, "\n");
list_for_each_entry(thd, &lbat_lv_list, list) {
len += snprintf(str + len, sizeof(str) - len,
"%slv_list, thd_volt:%d, user:%s\n",
(thd == cur_hv_ptr ||
thd == cur_lv_ptr) ? "->" : " ",
thd->thd_volt, thd->user->name);
pr_notice("%s", str);
seq_printf(s, "%s", str);
strncpy(str, "", strlen(str));
len = 0;
}
pr_notice("\n");
mutex_unlock(&lbat_mutex);
}
static void lbat_dbg_dump_reg(struct seq_file *s)
{
lbat_dump_reg();
seq_printf(s, "AUXADC_LBAT_VOLT_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MAX));
seq_printf(s, "AUXADC_LBAT_VOLT_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_VOLT_MIN));
seq_printf(s, "RG_INT_EN_BAT_H = 0x%x\n",
pmic_get_register_value(PMIC_RG_INT_EN_BAT_H));
seq_printf(s, "RG_INT_EN_BAT_L = 0x%x\n",
pmic_get_register_value(PMIC_RG_INT_EN_BAT_L));
seq_printf(s, "AUXADC_LBAT_EN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_EN));
seq_printf(s, "AUXADC_LBAT_DET_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_DET_MAX));
seq_printf(s, "AUXADC_LBAT_IRQ_EN_MAX = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MAX));
seq_printf(s, "AUXADC_LBAT_DET_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_DET_MIN));
seq_printf(s, "AUXADC_LBAT_IRQ_EN_MIN = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_IRQ_EN_MIN));
seq_printf(s, "AUXADC_LBAT_DEBT_MAX_SEL = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MAX_SEL));
seq_printf(s, "AUXADC_LBAT_DEBT_MIN_SEL = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_LBAT_DEBT_MIN_SEL));
seq_printf(s, "AUXADC_ADC_RDY_LBAT = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_ADC_RDY_LBAT));
seq_printf(s, "AUXADC_ADC_OUT_LBAT = 0x%x\n",
pmic_get_register_value(PMIC_AUXADC_ADC_OUT_LBAT));
}
static void lbat_dump_user_table(struct seq_file *s)
{
unsigned int i = 0;
struct lbat_user *user = NULL;
struct lbat_thd_t *thd = NULL;
mutex_lock(&lbat_mutex);
for (i = 0; i < user_count; i++) {
user = lbat_user_table[i];
if (list_empty(&user->thd_list)) {
seq_printf(s,
"%2d:%20s, %d, %d, %d, (%d,%d,%d,%d), %pf\n",
i, user->name,
user->hv_thd->thd_volt,
user->lv1_thd->thd_volt,
user->lv2_thd->thd_volt,
user->hv_deb_prd, user->hv_deb_times,
user->lv_deb_prd, user->lv_deb_times,
user->callback);
} else {
seq_printf(s, "%2d:%20s,", i, user->name);
list_for_each_entry(thd, &user->thd_list, list) {
seq_printf(s, " %d,", thd->thd_volt);
}
seq_printf(s, " %pf\n", user->callback);
}
}
mutex_unlock(&lbat_mutex);
}
struct lbat_dbg_st {
unsigned int dbg_id;
};
enum {
LBAT_DBG_DUMP_LIST,
LBAT_DBG_DUMP_REG,
LBAT_DBG_DUMP_TABLE,
LBAT_DBG_MAX,
};
static struct lbat_dbg_st dbg_data[LBAT_DBG_MAX];
static int lbat_dbg_show(struct seq_file *s, void *unused)
{
struct lbat_dbg_st *dbg_st = s->private;
switch (dbg_st->dbg_id) {
case LBAT_DBG_DUMP_LIST:
lbat_dump_thd_list(s);
break;
case LBAT_DBG_DUMP_REG:
lbat_dbg_dump_reg(s);
break;
case LBAT_DBG_DUMP_TABLE:
lbat_dump_user_table(s);
break;
default:
break;
}
return 0;
}
static int lbat_dbg_open(struct inode *inode, struct file *file)
{
if (file->f_mode & FMODE_READ)
return single_open(file, lbat_dbg_show, inode->i_private);
file->private_data = inode->i_private;
return 0;
}
static ssize_t lbat_dbg_write(struct file *file,
const char __user *user_buffer, size_t count, loff_t *position)
{
return count;
}
static int lbat_dbg_release(struct inode *inode, struct file *file)
{
if (file->f_mode & FMODE_READ)
return single_release(inode, file);
return 0;
}
static const struct file_operations lbat_dbg_fops = {
.open = lbat_dbg_open,
.read = seq_read,
.write = lbat_dbg_write,
.llseek = seq_lseek,
.release = lbat_dbg_release,
};
int lbat_debug_init(struct dentry *debug_dir)
{
struct dentry *lbat_dbg_dir = NULL;
if (IS_ERR(debug_dir) || !debug_dir) {
pr_notice("dir mtk_pmic does not exist\n");
return -1;
}
lbat_dbg_dir = debugfs_create_dir("lbat_dbg", debug_dir);
if (IS_ERR(lbat_dbg_dir) || !lbat_dbg_dir) {
pr_notice("fail mkdir /sys/kernel/debug/mtk_pmic/lbat_dbg\n");
return -1;
}
/* lbat service debug init */
dbg_data[0].dbg_id = LBAT_DBG_DUMP_LIST;
/* file type is regular file(S_IFREG), permission is read(444) */
debugfs_create_file("lbat_dump_list", (S_IFREG | 0444),
lbat_dbg_dir, (void *)&dbg_data[0], &lbat_dbg_fops);
dbg_data[1].dbg_id = LBAT_DBG_DUMP_REG;
debugfs_create_file("lbat_dump_reg", (S_IFREG | 0444),
lbat_dbg_dir, (void *)&dbg_data[1], &lbat_dbg_fops);
dbg_data[2].dbg_id = LBAT_DBG_DUMP_TABLE;
debugfs_create_file("lbat_dump_table", (S_IFREG | 0444),
lbat_dbg_dir, (void *)&dbg_data[2], &lbat_dbg_fops);
return 0;
}
@@ -0,0 +1,813 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/kdev_t.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/debugfs.h>
#include <linux/syscalls.h>
#include <linux/writeback.h>
#include <linux/seq_file.h>
#include <linux/suspend.h>
#include <linux/uaccess.h>
#include <mt-plat/upmu_common.h>
#include "include/pmic_regulator.h"
#include "include/regulator_codegen.h"
/*****************************************************************************
* Global variable
******************************************************************************/
/*****************************************************************************
* PMIC BUCK/LDO info for EM
******************************************************************************/
static ssize_t show_buck_ldo_info(struct device *dev,
struct device_attribute *attr,
char *buf)
{
unsigned short i;
unsigned int len = 0;
pr_info("[%s]\n", __func__);
for (i = 0; i < mt_bucks_size; i++)
len += snprintf(buf + len, PAGE_SIZE, "%s,0/1=off/on\n"
, mt_bucks[i].en_att.attr.name);
len += snprintf(buf + len, PAGE_SIZE, "SEP\n");
for (i = 0; i < mt_ldos_size; i++)
len += snprintf(buf + len, PAGE_SIZE, "%s,0/1=off/on\n"
, mt_ldos[i].en_att.attr.name);
len += snprintf(buf + len, PAGE_SIZE, "SEP\n");
for (i = 0; i < mt_bucks_size; i++)
len += snprintf(buf + len, PAGE_SIZE, "%s,mv\n"
, mt_bucks[i].voltage_att.attr.name);
len += snprintf(buf + len, PAGE_SIZE, "SEP\n");
for (i = 0; i < mt_ldos_size; i++)
len += snprintf(buf + len, PAGE_SIZE, "%s,mv\n"
, mt_ldos[i].voltage_att.attr.name);
return len;
}
/* 444 no write permission */
static DEVICE_ATTR(buck_ldo_info, 0444, show_buck_ldo_info, NULL);
/*****************************************************************************
* PMIC6355 linux reguplator driver
******************************************************************************/
#ifdef REGULATOR_TEST
unsigned int g_buck_uV;
static ssize_t show_buck_api(struct device *dev,
struct device_attribute *attr,
char *buf)
{
pr_info("[%s] 0x%x\n", __func__, g_buck_uV);
return sprintf(buf, "%u\n", g_buck_uV);
}
static ssize_t store_buck_api(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t size)
{
/*PMICLOG("[EM] Not Support Write Function\n");*/
int ret = 0;
char *pvalue = NULL, *addr = NULL, *val = NULL;
unsigned int buck_uV = 0;
unsigned int buck_type = 0;
pr_info("[%s]\n", __func__);
if (buf != NULL && size != 0) {
pr_info("[%s] buf is %s\n", __func__, buf);
/*buck_type = simple_strtoul(buf, &pvalue, 16);*/
pvalue = (char *)buf;
if (size > 5) {
addr = strsep(&pvalue, " ");
if (addr)
ret = kstrtou32(addr, 10,
(unsigned int *)&buck_type);
} else
ret = kstrtou32(pvalue, 10, (unsigned int *)&buck_type);
if (buck_type == 9999) {
pr_info("[%s] regulator_test!\n", __func__);
pmic_regulator_en_test();
#if 0
pmic_regulator_vol_test();
#endif
} else {
if (size > 5) {
val = strsep(&pvalue, " ");
if (val)
ret = kstrtou32(val, 10,
(unsigned int *)&buck_uV);
pr_info("[%s] write buck_type[%d] with voltgae %d !\n"
, __func__, buck_type, buck_uV);
/* only for regulator test*/
/* ret=buck_set_voltage(buck_type, buck_uV); */
} else {
pr_info("[%s] use \"cat pmic_access\" to get value(decimal)\r\n"
, __func__);
}
}
}
return size;
}
/*664*/
static DEVICE_ATTR(buck_api, 0664, show_buck_api, store_buck_api);
#endif /*--REGULATOR_TEST--*/
/*****************************************************************************
* PMIC extern variable
******************************************************************************/
struct platform_device mt_pmic_device = {
.name = "pmic_regulator",
.id = -1,
};
static const struct platform_device_id pmic_regulator_id[] = {
{"pmic_regulator", 0},
{},
};
static int pmic_regulator_cust_dts_parser(struct platform_device *pdev,
struct device_node *regulators)
{
struct device_node *child = NULL;
int ret = 0;
unsigned int i = 0, default_on = 0;
if (!regulators) {
PMICLOG("[PMIC]%s regulators node not found\n", __func__);
return -ENODEV;
}
for_each_child_of_node(regulators, child) {
for (i = 0; i < pmic_regulator_ldo_matches_size; i++) {
/* compare dt name & ldos name */
if (!of_node_cmp(child->name,
pmic_regulator_ldo_matches[i].name)) {
PMICLOG("[PMIC]%s regulator_matches %s\n"
, child->name
, (char *)of_get_property(child,
"regulator-name", NULL));
break;
}
}
if (i == pmic_regulator_ldo_matches_size)
continue;
/* check regualtors and set it */
if (!of_property_read_u32(child, "regulator-default-on"
, &default_on)) {
switch (default_on) {
case 0:
/* skip */
PMICLOG("[PMIC]%s regulator_skip %s\n"
, child->name
, pmic_regulator_ldo_matches[i].name);
break;
case 1:
/* turn ldo off */
(mt_ldos[i].en_cb)(0);
PMICLOG("[PMIC]%s default is off\n"
, (char *)of_get_property(child,
"regulator-name", NULL));
break;
case 2:
/* turn ldo on */
(mt_ldos[i].en_cb)(1);
PMICLOG("[PMIC]%s default is on\n"
, (char *)of_get_property(child,
"regulator-name", NULL));
break;
default:
break;
}
}
}
PMICLOG("[PMIC]%s done\n", __func__);
return ret;
}
static int pmic_regulator_buck_dts_parser(struct platform_device *pdev,
struct device_node *np)
{
struct device_node *buck_regulators = NULL;
struct regulator_config config = {};
struct regulator_dev *rdev = NULL;
struct regulation_constraints *c = NULL;
int matched, i = 0, ret = 0;
#ifdef REGULATOR_TEST
int isEn;
#endif /*--REGULATOR_TEST--*/
buck_regulators = of_get_child_by_name(np, "buck_regulators");
if (!buck_regulators) {
pr_info("[PMIC]regulators node not found\n");
return -EINVAL;
}
matched = of_regulator_match(&pdev->dev, buck_regulators,
pmic_regulator_buck_matches,
pmic_regulator_buck_matches_size);
if ((matched < 0) || (matched != mt_bucks_size)) {
pr_info("[PMIC]Error parsing regulator init data: %d %d\n",
matched, mt_bucks_size);
ret = -matched;
goto out;
}
for (i = 0; i < pmic_regulator_buck_matches_size; i++) {
if (mt_bucks[i].isUsedable != 1)
continue;
#if 1
config.dev = &(pdev->dev);
config.init_data = pmic_regulator_buck_matches[i].init_data;
config.of_node = pmic_regulator_buck_matches[i].of_node;
config.driver_data = &(mt_bucks[i]);
mt_bucks[i].desc.owner = THIS_MODULE;
rdev = regulator_register(&mt_bucks[i].desc, &config);
if (IS_ERR(rdev)) {
ret = PTR_ERR(rdev);
pr_notice("[regulator_register] failed to register %s (%d)\n"
, mt_bucks[i].desc.name, ret);
continue;
} else
PMICLOG("[regulator_register] pass %s\n"
, mt_bucks[i].desc.name);
c = rdev->constraints;
c->valid_ops_mask |= mt_bucks[i].constraints.valid_ops_mask;
c->valid_modes_mask |= mt_bucks[i].constraints.valid_modes_mask;
#else
mt_bucks[i].config.dev = &(pdev->dev);
mt_bucks[i].config.init_data =
pmic_regulator_buck_matches[i].init_data;
mt_bucks[i].config.of_node =
pmic_regulator_buck_matches[i].of_node;
mt_bucks[i].config.driver_data =
pmic_regulator_buck_matches[i].driver_data;
mt_bucks[i].desc.owner = THIS_MODULE;
mt_bucks[i].rdev =
regulator_register(&mt_bucks[i].desc,
&mt_bucks[i].config);
if (IS_ERR(mt_bucks[i].rdev)) {
ret = PTR_ERR(mt_bucks[i].rdev);
pr_notice("[regulator_register] failed to register %s (%d)\n"
, mt_bucks[i].desc.name, ret);
continue;
} else
PMICLOG("[regulator_register] pass %s\n"
, mt_bucks[i].desc.name);
#endif
#ifdef REGULATOR_TEST
mt_bucks[i].reg = regulator_get(&(pdev->dev)
, mt_bucks[i].desc.name);
isEn = regulator_is_enabled(mt_bucks[i].reg);
if (isEn != 0)
PMICLOG("[regulator] %s is default on\n"
, mt_bucks[i].desc.name);
#endif /*--REGULATOR_TEST--*/
}
out:
of_node_put(buck_regulators);
return ret;
}
static int pmic_regulator_ldo_dts_parser(struct platform_device *pdev,
struct device_node *np)
{
struct device_node *ldo_regulators = NULL;
struct regulator_config config = {};
struct regulator_dev *rdev = NULL;
int matched, i = 0, ret = 0;
#ifdef REGULATOR_TEST
int isEn;
#endif /*--REGULATOR_TEST--*/
ldo_regulators = of_get_child_by_name(np, "ldo_regulators");
if (!ldo_regulators) {
pr_info("[PMIC]regulators node not found\n");
return -EINVAL;
}
matched = of_regulator_match(&pdev->dev, ldo_regulators,
pmic_regulator_ldo_matches,
pmic_regulator_ldo_matches_size);
if ((matched < 0) || (matched != mt_ldos_size)) {
pr_info("[PMIC]Error parsing regulator init data: %d %d\n",
matched, mt_ldos_size);
ret = -matched;
goto out;
}
for (i = 0; i < pmic_regulator_ldo_matches_size; i++) {
if (mt_ldos[i].isUsedable != 1)
continue;
#if 1
config.dev = &(pdev->dev);
config.init_data = pmic_regulator_ldo_matches[i].init_data;
config.of_node = pmic_regulator_ldo_matches[i].of_node;
config.driver_data = pmic_regulator_ldo_matches[i].driver_data;
mt_ldos[i].desc.owner = THIS_MODULE;
rdev = regulator_register(&mt_ldos[i].desc, &config);
if (IS_ERR(rdev)) {
ret = PTR_ERR(rdev);
pr_notice("[regulator_register] failed to register %s (%d)\n"
, mt_ldos[i].desc.name, ret);
continue;
} else {
PMICLOG("[regulator_register] pass %s\n"
, mt_ldos[i].desc.name);
}
#else
mt_ldos[i].config.dev = &(pdev->dev);
mt_ldos[i].config.init_data =
pmic_regulator_ldo_matches[i].init_data;
mt_ldos[i].config.of_node =
pmic_regulator_ldo_matches[i].of_node;
mt_ldos[i].config.driver_data =
pmic_regulator_ldo_matches[i].driver_data;
mt_ldos[i].desc.owner = THIS_MODULE;
mt_ldos[i].rdev =
regulator_register(&mt_ldos[i].desc,
&mt_ldos[i].config);
if (IS_ERR(mt_ldos[i].rdev)) {
ret = PTR_ERR(mt_ldos[i].rdev);
pr_notice("[regulator_register] failed to register %s (%d)\n"
, mt_ldos[i].desc.name, ret);
continue;
} else {
PMICLOG("[regulator_register] pass %s\n"
, mt_ldos[i].desc.name);
}
#endif
#ifdef REGULATOR_TEST
mt_ldos[i].reg = regulator_get(&(pdev->dev),
mt_ldos[i].desc.name);
isEn = regulator_is_enabled(mt_ldos[i].reg);
if (isEn != 0)
PMICLOG("[regulator] %s is default on\n"
, mt_ldos[i].desc.name);
#endif /*--REGULATOR_TEST--*/
/* To initialize varriables which were used to record status, */
/* if ldo regulator have been modified by user. */
/* mt_ldos[i].vosel.ldo_user = mt_ldos[i].rdev->use_count; */
if (mt_ldos[i].da_vol_cb != NULL)
mt_ldos[i].vosel.def_sel = (mt_ldos[i].da_vol_cb)();
mt_ldos[i].vosel.cur_sel = mt_ldos[i].vosel.def_sel;
}
/*--for ldo customization--*/
ret = pmic_regulator_cust_dts_parser(pdev, ldo_regulators);
if (ret) {
pr_info("pmic_regulator_cust_dts_parser fail\n");
ret = -EINVAL;
goto out;
}
out:
of_node_put(ldo_regulators);
return ret;
}
static int pmic_regulator_init(struct platform_device *pdev)
{
struct device_node *np;
int ret = 0;
np = pdev->dev.of_node;
if (!np) {
pr_info("%s np = NULL\n", __func__);
return -EINVAL;
}
ret = pmic_regulator_buck_dts_parser(pdev, np);
if (ret) {
pr_info("pmic_regulator_buck_dts_parser fail\n");
ret = -EINVAL;
goto out;
}
ret = pmic_regulator_ldo_dts_parser(pdev, np);
if (ret) {
pr_info("pmic_regulator_ldo_dts_parser fail\n");
ret = -EINVAL;
goto out;
}
out:
of_node_put(np);
return ret;
}
void pmic_regulator_suspend(void)
{
int i;
for (i = 0; i < mt_ldos_size; i++) {
if (mt_ldos[i].isUsedable == 1) {
if (mt_ldos[i].da_vol_cb != NULL) {
mt_ldos[i].vosel.cur_sel =
(mt_ldos[i].da_vol_cb)();
if (mt_ldos[i].vosel.cur_sel !=
mt_ldos[i].vosel.def_sel) {
mt_ldos[i].vosel.restore = true;
pr_info("%s(name=%s id=%d default_sel=%d current_sel=%d)\n"
, __func__
, mt_ldos[i].rdev->desc->name
, mt_ldos[i].rdev->desc->id
, mt_ldos[i].vosel.def_sel
, mt_ldos[i].vosel.cur_sel);
} else
mt_ldos[i].vosel.restore = false;
}
}
}
}
void pmic_regulator_resume(void)
{
int i, selector;
for (i = 0; i < mt_ldos_size; i++) {
if (mt_ldos[i].isUsedable == 1) {
if (mt_ldos[i].vol_cb != NULL) {
if (mt_ldos[i].vosel.restore == true) {
/*-- regulator voltage changed? --*/
selector = mt_ldos[i].vosel.cur_sel;
(mt_ldos[i].vol_cb)(selector);
pr_info("%s(name=%s id=%d default_sel=%d current_sel=%d)\n"
, __func__
, mt_ldos[i].rdev->desc->name
, mt_ldos[i].rdev->desc->id
, mt_ldos[i].vosel.def_sel
, mt_ldos[i].vosel.cur_sel);
}
}
}
}
}
static int pmic_regulator_pm_event(struct notifier_block *notifier,
unsigned long pm_event,
void *unused)
{
switch (pm_event) {
case PM_HIBERNATION_PREPARE: /* Going to hibernate */
pr_info("[%s] pm_event %lu (IPOH)\n", __func__, pm_event);
return NOTIFY_DONE;
case PM_POST_HIBERNATION: /* Hibernation finished */
pr_info("[%s] pm_event %lu\n", __func__, pm_event);
pmic_regulator_resume();
return NOTIFY_DONE;
}
return NOTIFY_OK;
}
static struct notifier_block pmic_regulator_pm_notifier_block = {
.notifier_call = pmic_regulator_pm_event,
.priority = 0,
};
int mtk_regulator_init(struct platform_device *dev)
{
int ret = 0;
#ifdef CONFIG_OF
pmic_regulator_init(dev);
#endif
ret = register_pm_notifier(&pmic_regulator_pm_notifier_block);
if (ret) {
PMICLOG("****failed to register PM notifier %d\n", ret);
return ret;
}
return ret;
}
#ifdef REGULATOR_TEST
void pmic_regulator_en_test(void)
{
int i = 0;
int ret1 = 0, ret2 = 0;
struct regulator *reg = NULL;
/*for (i = 0; i < ARRAY_SIZE(mt_ldos); i++) {*/
for (i = 0; i < mt_ldos_size; i++) {
if (mt_ldos[i].isUsedable != 1)
continue;
/*---VIO18 should not be off---*/
if (strcmp("va09", mt_ldos[i].desc.name) != 0)
continue;
reg = mt_ldos[i].reg;
pr_info("[regulator enable test] %s\n", mt_ldos[i].desc.name);
ret1 = regulator_enable(reg);
ret2 = regulator_is_enabled(reg);
if (ret2 == (mt_ldos[i].da_en_cb()))
pr_info("[enable test pass]\n");
else
pr_info("[enable test fail]\n");
ret1 = regulator_disable(reg);
ret2 = regulator_is_enabled(reg);
if (ret2 == (mt_ldos[i].da_en_cb()))
pr_info("[disable test pass]\n");
else
pr_info("[disable test fail]\n");
}
}
void pmic_regulator_vol_test(void)
{
int i = 0, j = 0;
struct regulator *reg = NULL;
const int *pVoltage = NULL;
const int *idxs = NULL;
int rvoltage = 0;
for (i = 0; i < mt_ldos_size; i++) {
reg = mt_ldos[i].reg;
if (mt_ldos[i].isUsedable != 1)
continue;
pr_info("[regulator voltage test] %s n_voltages:%d\n",
mt_ldos[i].desc.name, mt_ldos[i].desc.n_voltages);
if (mt_ldos[i].pvoltages == NULL)
continue;
pVoltage = mt_ldos[i].pvoltages;
idxs = mt_ldos[i].idxs;
for (j = 0; j < mt_ldos[i].desc.n_voltages; j++) {
regulator_set_voltage(reg, pVoltage[j], pVoltage[j]);
rvoltage = regulator_get_voltage(reg);
if (idxs[j] == mt_ldos[i].da_vol_cb() &&
(pVoltage[j] == rvoltage)) {
pr_info("[%d]:pass set_voltage:%d rvoltage:%d\n"
, idxs[j]
, pVoltage[j]
, rvoltage);
} else {
pr_info("[%d:%d]:fail set_voltage:%d rvoltage:%d\n"
, idxs[j]
, mt_ldos[i].da_vol_cb()
, pVoltage[j]
, rvoltage);
}
}
}
}
#endif /*--REGULATOR_TEST--*/
/*****************************************************************************
* Dump all LDO status
******************************************************************************/
void dump_ldo_status_read_debug(void)
{
int i = 0, j = 0;
int en = 0, ret = 0;
int voltage_reg = 0;
int voltage = 0;
const int *pVoltage = NULL, *pVoltidx = NULL;
pr_debug("********** BUCK/LDO status dump [1:ON,0:OFF]**********\n");
/*for (i = 0; i < ARRAY_SIZE(mtk_bucks); i++) {*/
for (i = 0; i < mt_bucks_size; i++) {
if (mt_bucks[i].da_en_cb != NULL)
en = (mt_bucks[i].da_en_cb)();
else
en = -1;
if (mt_bucks[i].da_vol_cb != NULL) {
voltage_reg = (mt_bucks[i].da_vol_cb)();
voltage = mt_bucks[i].desc.min_uV +
mt_bucks[i].desc.uV_step * voltage_reg;
} else {
voltage_reg = -1;
voltage = -1;
}
pr_info("%s status:%d voltage:%duv voltage_reg:%d\n",
mt_bucks[i].desc.name, en, voltage, voltage_reg);
}
/*for (i = 0; i < ARRAY_SIZE(mt_ldos); i++) {*/
for (i = 0; i < mt_ldos_size; i++) {
if (mt_ldos[i].da_en_cb != NULL)
en = (mt_ldos[i].da_en_cb)();
else
en = -1;
if (mt_ldos[i].desc.n_voltages != 1) {
if (mt_ldos[i].da_vol_cb != NULL) {
voltage_reg = (mt_ldos[i].da_vol_cb)();
if (mt_ldos[i].pvoltages != NULL) {
pVoltage = (const int *)
mt_ldos[i].pvoltages;
pVoltidx = (const int *)
mt_ldos[i].idxs;
/*HW LDO sequence issue, we need to change it */
for (j = 0;
j < mt_ldos[i].desc.n_voltages;
j++) {
if (pVoltidx[j] == voltage_reg) {
ret = j;
break;
}
}
voltage = pVoltage[ret];
} else {
voltage =
mt_ldos[i].desc.min_uV +
mt_ldos[i].desc.uV_step *
voltage_reg;
}
} else {
voltage_reg = -1;
voltage = -1;
}
} else
voltage = mt_ldos[i].desc.fixed_uV;
pr_info("%s status:%d voltage:%duv voltage_reg:%d\n",
mt_ldos[i].desc.name, en, voltage, voltage_reg);
}
}
static int proc_utilization_show(struct seq_file *m, void *v)
{
int i = 0, j = 0;
int en = 0, ret = 0;
int voltage_reg = 0;
int voltage = 0;
const int *pVoltage = NULL, *pVoltidx = NULL;
seq_puts(m, "********** BUCK/LDO status dump [1:ON,0:OFF]**********\n");
/*for (i = 0; i < ARRAY_SIZE(mtk_bucks); i++) {*/
for (i = 0; i < mt_bucks_size; i++) {
if (mt_bucks[i].da_en_cb != NULL)
en = (mt_bucks[i].da_en_cb)();
else
en = -1;
if (mt_bucks[i].da_vol_cb != NULL) {
voltage_reg = (mt_bucks[i].da_vol_cb)();
voltage = mt_bucks[i].desc.min_uV +
mt_bucks[i].desc.uV_step *
voltage_reg;
} else {
voltage_reg = -1;
voltage = -1;
}
seq_printf(m, "%s status:%d voltage:%duv voltage_reg:%d\n"
, mt_bucks[i].desc.name
, en, voltage, voltage_reg);
}
/*for (i = 0; i < ARRAY_SIZE(mt_ldos); i++) {*/
for (i = 0; i < mt_ldos_size; i++) {
if (mt_ldos[i].da_en_cb != NULL)
en = (mt_ldos[i].da_en_cb)();
else
en = -1;
if (mt_ldos[i].desc.n_voltages != 1) {
if (mt_ldos[i].da_vol_cb != NULL) {
voltage_reg = (mt_ldos[i].da_vol_cb)();
if (mt_ldos[i].pvoltages != NULL) {
pVoltage = (const int *)
mt_ldos[i].pvoltages;
pVoltidx = (const int *)
mt_ldos[i].idxs;
/*HW LDO sequence issue, we need to change it */
for (j = 0;
j < mt_ldos[i].desc.n_voltages; j++) {
if (pVoltidx[j] == voltage_reg) {
ret = j;
break;
}
}
voltage = pVoltage[ret];
} else {
voltage =
mt_ldos[i].desc.min_uV +
mt_ldos[i].desc.uV_step *
voltage_reg;
}
} else {
voltage_reg = -1;
voltage = -1;
}
} else {
voltage = mt_ldos[i].desc.fixed_uV;
voltage_reg = -1;
}
seq_printf(m, "%s status:%d voltage:%duv voltage_reg:%d\n"
, mt_ldos[i].desc.name, en, voltage, voltage_reg);
}
return 0;
}
static int proc_utilization_open(struct inode *inode, struct file *file)
{
return single_open(file, proc_utilization_show, NULL);
}
static const struct file_operations pmic_debug_proc_fops = {
.open = proc_utilization_open,
.read = seq_read,
};
void pmic_regulator_debug_init(struct platform_device *dev,
struct dentry *debug_dir)
{
/* /sys/class/regulator/.../ */
int ret_device_file = 0, i;
struct dentry *mt_pmic_dir = debug_dir;
#ifdef REGULATOR_TEST
ret_device_file = device_create_file(&(dev->dev), &dev_attr_buck_api);
#endif /*--REGULATOR_TEST--*/
/* /sys/class/regulator/.../ */
/*EM BUCK voltage & Status*/
for (i = 0; i < mt_bucks_size; i++) {
/*PMICLOG("[PMIC] register buck id=%d\n",i);*/
if (*(int *)(&mt_bucks[i].en_att)) {
PMICLOG("[PMIC] register ldo en_att\n");
ret_device_file = device_create_file(&(dev->dev),
&(mt_bucks[i].en_att));
}
if (*(int *)(&mt_bucks[i].voltage_att)) {
PMICLOG("[PMIC] register ldo voltage_att\n");
ret_device_file = device_create_file(&(dev->dev),
&(mt_bucks[i].voltage_att));
}
}
/*ret_device_file = device_create_file(&(dev->dev),
*&mtk_bucks_class[i].voltage_att);
*/
/*EM ldo voltage & Status*/
for (i = 0; i < mt_ldos_size; i++) {
/*PMICLOG("[PMIC] register ldo id=%d\n",i);*/
if (*(int *)(&mt_ldos[i].en_att)) {
PMICLOG("[PMIC] register ldo en_att\n");
ret_device_file = device_create_file(&(dev->dev),
&mt_ldos[i].en_att);
}
if (*(int *)(&mt_ldos[i].voltage_att)) {
PMICLOG("[PMIC] register ldo voltage_att\n");
ret_device_file = device_create_file(&(dev->dev),
&mt_ldos[i].voltage_att);
}
}
ret_device_file = device_create_file(&(dev->dev),
&dev_attr_buck_ldo_info);
debugfs_create_file("dump_ldo_status", 0644,
mt_pmic_dir, NULL, &pmic_debug_proc_fops);
PMICLOG("proc_create pmic_debug_proc_fops\n");
}
MODULE_AUTHOR("Jimmy-YJ Huang");
MODULE_DESCRIPTION("MT PMIC REGULATOR Driver");
MODULE_LICENSE("GPL");
MODULE_VERSION("1.0.0_M");
@@ -0,0 +1,207 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/i2c.h>
#include <linux/pm.h>
#include <linux/of_gpio.h>
#include <linux/pm_runtime.h>
#include <linux/smp.h>
#include <linux/device.h>
#include <linux/debugfs.h>
#include <linux/printk.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/consumer.h>
#include <linux/dcache.h>
#include <mach/upmu_hw.h>
#include <mach/upmu_sw.h>
#include <mt-plat/upmu_common.h>
#include <mach/mtk_pmic.h>
#include "include/pmic.h"
#include "include/pmic_irq.h"
#include "include/pmic_throttling_dlpt.h"
#include "include/pmic_debugfs.h"
#include "include/pmic_api_buck.h"
#include "include/pmic_bif.h"
#include "include/pmic_auxadc.h"
#if 0
/* /proj/mtk22477/casws_mtk22477/lc1/kernel-4.19/drivers/misc/mediatek/include/mt-plat */
/*
-I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(CONFIG_MTK_PLATFORM)/include \
-I$(srctree)/drivers/misc/mediatek/include/mt-plat/$(CONFIG_MTK_PLATFORM)/include/mach \
*/
/*
* PMIC EXTERN FUNCTIONS
*/
/*----- BATTERY_OC_PROTECT -----*/
void __attribute__ ((weak)) exec_battery_oc_callback(BATTERY_OC_LEVEL battery_oc_level){ }
void __attribute__ ((weak)) bat_oc_h_en_setting(int en_val){ }
void __attribute__ ((weak)) bat_oc_l_en_setting(int en_val){ }
/*----- CHRDET_PROTECT -----*/
#ifdef CONFIG_MTK_KERNEL_POWER_OFF_CHARGING
unsigned int __attribute__ ((weak)) upmu_get_rgs_chrdet(void){ return 0; }
#endif
/*----- PMIC thread -----*/
void __attribute__ ((weak)) pmic_enable_charger_detection_int(int x){ }
/*----- LDO OC -----*/
void __attribute__ ((weak)) msdc_sd_power_off(void){ }
/*----- REGULATOR -----*/
int __attribute__ ((weak)) mtk_regulator_init(struct platform_device *dev){ return 0; }
unsigned int __attribute__ ((weak)) pmic_config_interface_buck_vsleep_check(unsigned int RegNum,
unsigned int val, unsigned int MASK, unsigned int SHIFT){ return 0; }
void __attribute__ ((weak)) pmic_regulator_debug_init(
struct platform_device *dev, struct dentry *debug_dir){ }
void __attribute__ ((weak)) pmic_regulator_suspend(void){ }
void __attribute__ ((weak)) pmic_regulator_resume(void){ }
/*----- EFUSE -----*/
int __attribute__ ((weak)) pmic_read_VMC_efuse(void){ return 0; }
/*----- Others -----*/
int __attribute__ ((weak)) PMIC_POWER_HOLD(unsigned int hold){ return 0; }
void __attribute__ ((weak)) mt_power_off(void){ }
unsigned int __attribute__ ((weak)) bat_get_ui_percentage(void){ return 0; }
signed int __attribute__ ((weak)) fgauge_read_IM_current(void *data){ return 0; }
void __attribute__ ((weak)) pmic_auxadc_lock(void){ }
void __attribute__ ((weak)) pmic_auxadc_unlock(void){ }
signed int __attribute__ ((weak)) fgauge_read_v_by_d(int d_val){ return 0; }
signed int __attribute__ ((weak)) fgauge_read_r_bat_by_v(signed int voltage){ return 0; }
void __attribute__ ((weak)) kpd_pwrkey_pmic_handler(unsigned long pressed){ }
void __attribute__ ((weak)) kpd_pmic_rstkey_handler(unsigned long pressed){ }
int __attribute__ ((weak)) is_mt6311_sw_ready(void){ return 0; }
int __attribute__ ((weak)) is_mt6311_exist(void){ return 0; }
int __attribute__ ((weak)) get_mt6311_i2c_ch_num(void){ return 0; }
#if !defined CONFIG_MTK_LEGACY
void __attribute__ ((weak)) pmu_drv_tool_customization_init(void){ }
#endif
int __attribute__ ((weak)) batt_init_cust_data(void){ return 0; }
unsigned int __attribute__ ((weak)) mt_gpio_to_irq(unsigned int gpio){return 0; }
int __attribute__ ((weak)) mt_gpio_set_debounce(unsigned int gpio, unsigned int debounce){ return 0; }
#ifdef CONFIG_MTK_PMIC_COMMON
int __attribute__ ((weak)) PMIC_check_battery(void){ return 0; }
int __attribute__ ((weak)) PMIC_check_wdt_status(void){ return 0; }
int __attribute__ ((weak)) PMIC_check_pwrhold_status(void){ return 0; }
void __attribute__ ((weak)) PMIC_LP_INIT_SETTING(void){ }
int __attribute__ ((weak)) PMIC_MD_INIT_SETTING_V1(void){ return 0; }
void __attribute__ ((weak)) PMIC_PWROFF_SEQ_SETTING(void){ }
int __attribute__ ((weak)) pmic_tracking_init(void){ return 0; }
#endif
unsigned int __attribute__ ((weak)) PMIC_CHIP_VER(void){ return 0; }
void __attribute__ ((weak)) record_md_vosel(void){ }
void __attribute__ ((weak)) register_low_battery_notify(
void (*low_battery_callback)(enum LOW_BATTERY_LEVEL_TAG),
enum LOW_BATTERY_PRIO_TAG prio_val)
{
}
void __attribute__ ((weak)) register_low_battery_notify_ext(
void (*low_battery_callback)(enum LOW_BATTERY_LEVEL_TAG),
enum LOW_BATTERY_PRIO_TAG prio_val)
{
}
int __attribute__ ((weak)) dlpt_check_power_off(void)
{
return 0;
}
unsigned int __attribute__ ((weak)) PMIC_LP_CHIP_VER(void) { return 0; }
unsigned int __attribute__ ((weak)) is_pmic_mrv(void) { return 0; }
void __attribute__ ((weak)) PMIC_INIT_SETTING_V1(void) { }
int __attribute__ ((weak)) do_ptim_ex(bool isSuspend, unsigned int *bat, signed int *cur) { return 0; }
#if defined(CONFIG_MACH_MT6768) || defined(CONFIG_MACH_MT6739) || defined(CONFIG_MACH_MT6781)
int __attribute__ ((weak)) pmic_buck_vproc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_buck_vcore_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_buck_vmodem_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_buck_vs1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_buck_vpa_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vsram_proc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vsram_others_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vfe28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vxo22_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vrf18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vrf12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vefuse_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vcn33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vcn28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vcn18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vcama_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vcamd_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vcamio_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vldo28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vaux18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vaud28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vio28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vdram_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vmc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vmch_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vemc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vsim1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vsim2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vibr_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vusb33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_tref_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
int __attribute__ ((weak)) pmic_ldo_vio18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg){ return 0; }
#endif
/*kernel-4.14/drivers/misc/mediatek/pmic/mt6359p/v1/pmic_lp_api.c*/
#if defined(CONFIG_MACH_MT6877)
int __attribute__ ((weak)) pmic_ldo_vio18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg) { return 0; }
#endif
void __attribute__ ((weak)) register_battery_oc_notify(
void (*battery_oc_callback)(BATTERY_OC_LEVEL tag),
BATTERY_OC_PRIO prio_val) {}
#endif
#include <mt-plat/mtk_boot_common.h>
void __attribute__ ((weak)) mt_usb_connect_v1(void){}
void __attribute__ ((weak)) mt_usb_disconnect_v1(void){}
enum boot_mode_t __attribute__ ((weak)) get_boot_mode(void){ return 0;}
@@ -0,0 +1,19 @@
#inlcude SPI Interface Start
ccflags-y += -I$(srctree)/drivers/spi/mediatek/mt6799/
ifeq ($(CONFIG_TRUSTONIC_TEE_SUPPORT),y)
subdir-ccflags-y += -I$(srctree)/drivers/spi/trustzone/spi/Tlspi/inc
include $(srctree)/drivers/tee/gud/Makefile.include
endif
#include SPI Interface End
ifeq ($(CONFIG_MTK_TINYSYS_SSPM_SUPPORT), y)
obj-$(CONFIG_REGULATOR_ISL91302A) += vproc2_ipi.o
else
obj-$(CONFIG_REGULATOR_ISL91302A) += isl91302a-spi.o
endif
obj-$(CONFIG_REGULATOR_ISL91302A) += isl91302a-regulator.o
obj-$(CONFIG_REGULATOR_RT5734) += rt5734-spi.o rt5734-regulator.o
obj-$(CONFIG_REGULATOR_RT5738) += rt5738-regulator.o
obj-$(CONFIG_REGULATOR_MT6691) += mt6691-regulator.o
obj-$(CONFIG_EXTBUCK_MT6311) += mt6311-i2c.o mt6311-regulator.o mt6311_api.o
obj-$(CONFIG_MTK_EXTBUCK) += extbuck.o
@@ -0,0 +1,80 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/regulator/consumer.h>
#include <mt-plat/upmu_common.h>
#if defined(CONFIG_REGULATOR_MT6315)
#include <linux/regulator/mt6315-misc.h>
#endif
#ifdef CONFIG_REGULATOR_RT5738
#include "rt5738-regulator.h"
#endif
#ifdef CONFIG_REGULATOR_MT6691
#include "mt6691-regulator.h"
#endif
int is_ext_buck_exist(void)
{
#ifndef CONFIG_MTK_EXTBUCK
return 0;
#else
#ifdef CONFIG_REGULATOR_ISL91302A
struct regulator *reg;
reg = regulator_get(NULL, "ext_buck_proc1");
if (reg == NULL)
return 0;
regulator_put(reg);
return 1;
#endif /* CONFIG_REGULATOR_ISL91302A */
#ifdef CONFIG_EXTBUCK_MT6311
if ((is_mt6311_exist() == 1))
return 1;
#endif /* CONFIG_EXTBUCK_MT6311 */
#if defined(CONFIG_MTK_PMIC_CHIP_MT6313)
if ((is_mt6313_exist() == 1))
return 1;
#endif /* CONFIG_MTK_PMIC_CHIP_MT6313 */
#if defined(CONFIG_REGULATOR_MT6315)
if ((is_mt6315_exist() == 1))
return 1;
#endif
#ifdef CONFIG_REGULATOR_RT5738
if ((is_rt5738_exist() == 1))
return 1;
#endif /* CONFIG_REGULATOR_RT5738 */
#endif /* if not CONFIG_MTK_EXTBUCK */
return 0;
}
int is_ext_buck2_exist(void)
{
#ifndef CONFIG_MTK_EXTBUCK
return 0;
#else
#ifdef CONFIG_REGULATOR_RT5738
if ((is_rt5738_exist() == 1))
return 1;
#endif /* CONFIG_REGULATOR_RT5738 */
#ifdef CONFIG_REGULATOR_MT6691
return is_mt6691_exist();
#endif /* CONFIG_REGULATOR_MT6691 */
return 0;
#endif /* if not CONIFG_MTK_EXTBUCK */
}
int is_ext_buck_sw_ready(void)
{
#if defined(CONFIG_EXTBUCK_MT6311)
if ((is_mt6311_sw_ready() == 1))
return 1;
#elif defined(CONFIG_MTK_PMIC_CHIP_MT6313)
if ((is_mt6313_sw_ready() == 1))
return 1;
#endif
return 0;
}
@@ -0,0 +1,467 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include "isl91302a-spi.h"
#include <linux/regulator/machine.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/mediatek/mtk_regulator_core.h>
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#include <mach/mtk_pmic_ipi.h>
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
#include <linux/delay.h>
#define ISL91302A_BUCK_MAX 3
struct isl91302a_regulator_info {
struct mtk_simple_regulator_desc *mreg_desc;
uint32_t vol_up_reg;
uint32_t vol_up_mask;
uint32_t vol_up_shift;
uint32_t vol_lo_reg;
uint32_t vol_lo_mask;
uint32_t vol_lo_shift;
uint32_t mode_reg;
uint32_t mode_bit;
uint32_t ramp_reg;
uint32_t ramp_mask;
uint32_t ramp_shift;
uint32_t ramp_sel;
};
#define ISL91302A_MIN_VOLTAGE (1200)
#define ISL91302A_MAX_VOLTAGE (1231000)
#define ISL91302A_RAMP_RATE (12500) /* uV/us */
/* buck 1 */
#define isl91302a_gpu_vol_reg (0)
#define isl91302a_gpu_vol_mask (0)
#define isl91302a_gpu_vol_shift (0)
#define isl91302a_gpu_enable_reg ISL91302A_MODECTRL_R
#define isl91302a_gpu_enable_bit (0x80)
#define isl91302a_gpu_min_uV (ISL91302A_MIN_VOLTAGE)
#define isl91302a_gpu_max_uV (ISL91302A_MAX_VOLTAGE)
#define isl91302a_gpu_id (0)
/* buck 2 */
#define isl91302a_proc2_vol_reg (0)
#define isl91302a_proc2_vol_mask (0)
#define isl91302a_proc2_vol_shift (0)
#define isl91302a_proc2_enable_reg ISL91302A_MODECTRL_R
#define isl91302a_proc2_enable_bit (0x40)
#define isl91302a_proc2_min_uV (ISL91302A_MIN_VOLTAGE)
#define isl91302a_proc2_max_uV (ISL91302A_MAX_VOLTAGE)
#define isl91302a_proc2_id (1)
/* buck 3 */
#define isl91302a_proc1_vol_reg (0)
#define isl91302a_proc1_vol_mask (0)
#define isl91302a_proc1_vol_shift (0)
#define isl91302a_proc1_enable_reg ISL91302A_MODECTRL_R
#define isl91302a_proc1_enable_bit (0x20)
#define isl91302a_proc1_min_uV (ISL91302A_MIN_VOLTAGE)
#define isl91302a_proc1_max_uV (ISL91302A_MAX_VOLTAGE)
#define isl91302a_proc1_id (2)
static struct mtk_simple_regulator_control_ops isl91302a_mreg_ctrl_ops = {
.register_read = isl91302a_read_byte,
.register_write = isl91302a_write_byte,
.register_update_bits = isl91302a_assign_bit,
};
static int isl91302a_list_voltage(
struct mtk_simple_regulator_desc *mreg_desc,
unsigned int selector)
{
return (selector >= mreg_desc->rdesc.n_voltages) ?
-EINVAL : DIV_ROUND_UP(ISL91302A_MAX_VOLTAGE * selector, 1024);
}
static struct mtk_simple_regulator_desc isl91302a_desc_table[] = {
mreg_decl(isl91302a_gpu, isl91302a_list_voltage,
1024, &isl91302a_mreg_ctrl_ops),
mreg_decl(isl91302a_proc2, isl91302a_list_voltage,
1024, &isl91302a_mreg_ctrl_ops),
mreg_decl(isl91302a_proc1, isl91302a_list_voltage,
1024, &isl91302a_mreg_ctrl_ops),
};
#define ISL91302A_REGULATOR_VOLUP_REG0 ISL91302A_BUCK1_UP_R
#define ISL91302A_REGULATOR_VOLUP_REG1 ISL91302A_BUCK2_UP_R
#define ISL91302A_REGULATOR_VOLUP_REG2 ISL91302A_BUCK3_UP_R
#define ISL91302A_REGULATOR_VOLUP_SHIFT 0
#define ISL91302A_REGULATOR_VOLUP_MASK (0xff)
#define ISL91302A_REGULATOR_VOLLO_REG0 ISL91302A_BUCK1_LO_R
#define ISL91302A_REGULATOR_VOLLO_REG1 ISL91302A_BUCK2_LO_R
#define ISL91302A_REGULATOR_VOLLO_REG2 ISL91302A_BUCK3_LO_R
#define ISL91302A_REGULATOR_VOLLO_SHIFT 6
#define ISL91302A_REGULATOR_VOLLO_MASK (0xc0)
#define ISL91302A_REGULATOR_MODE_REG0 ISL91302A_BUCK1_DCM_R
#define ISL91302A_REGULATOR_MODE_MASK0 (0x04)
#define ISL91302A_REGULATOR_MODE_REG1 ISL91302A_BUCK2_DCM_R
#define ISL91302A_REGULATOR_MODE_MASK1 (0x04)
#define ISL91302A_REGULATOR_MODE_REG2 ISL91302A_BUCK3_DCM_R
#define ISL91302A_REGULATOR_MODE_MASK2 (0x04)
#define ISL91302A_REGULATOR_RAMP_REG0 ISL91302A_BUCK1_RSPCFG1_R
#define ISL91302A_REGULATOR_RAMP_REG1 ISL91302A_BUCK2_RSPCFG1_R
#define ISL91302A_REGULATOR_RAMP_REG2 ISL91302A_BUCK3_RSPCFG1_R
#define ISL91302A_REGULATOR_RAMP_MASK0 ISL91302A_BUCK_RSPCFG1_RSPUP_M
#define ISL91302A_REGULATOR_RAMP_MASK1 ISL91302A_BUCK_RSPCFG1_RSPUP_M
#define ISL91302A_REGULATOR_RAMP_MASK2 ISL91302A_BUCK_RSPCFG1_RSPUP_M
#define ISL91302A_REGULATOR_RAMP_SHIFT0 ISL91302A_BUCK_RSPCFG1_RSPUP_S
#define ISL91302A_REGULATOR_RAMP_SHIFT1 ISL91302A_BUCK_RSPCFG1_RSPUP_S
#define ISL91302A_REGULATOR_RAMP_SHIFT2 ISL91302A_BUCK_RSPCFG1_RSPUP_S
#define ISL91302A_REGULATOR_RAMP_SEL0 ISL91302A_BUCK_RSPSEL_M
#define ISL91302A_REGULATOR_RAMP_SEL1 ISL91302A_BUCK_RSPSEL_M
#define ISL91302A_REGULATOR_RAMP_SEL2 ISL91302A_BUCK_RSPSEL_M
#define ISL91302A_REGULATOR_DECL(_id) \
{ \
.mreg_desc = &isl91302a_desc_table[_id], \
.vol_up_reg = ISL91302A_REGULATOR_VOLUP_REG##_id, \
.vol_up_shift = ISL91302A_REGULATOR_VOLUP_SHIFT, \
.vol_up_mask = ISL91302A_REGULATOR_VOLUP_MASK, \
.vol_lo_reg = ISL91302A_REGULATOR_VOLLO_REG##_id, \
.vol_lo_shift = ISL91302A_REGULATOR_VOLLO_SHIFT, \
.vol_lo_mask = ISL91302A_REGULATOR_VOLLO_MASK, \
.mode_reg = ISL91302A_REGULATOR_MODE_REG##_id, \
.mode_bit = ISL91302A_REGULATOR_MODE_MASK##_id, \
.ramp_reg = ISL91302A_REGULATOR_RAMP_REG##_id, \
.ramp_mask = ISL91302A_REGULATOR_RAMP_MASK##_id, \
.ramp_shift = ISL91302A_REGULATOR_RAMP_SHIFT##_id, \
}
static struct isl91302a_regulator_info isl91302a_regulator_infos[] = {
ISL91302A_REGULATOR_DECL(0), /* GPU */
ISL91302A_REGULATOR_DECL(1), /* PROC2 */
ISL91302A_REGULATOR_DECL(2), /* PROC1 */
};
static struct isl91302a_regulator_info *isl91302a_find_regulator_info(int id)
{
struct isl91302a_regulator_info *info;
int i;
for (i = 0; i < ARRAY_SIZE(isl91302a_regulator_infos); i++) {
info = &isl91302a_regulator_infos[i];
if (info->mreg_desc->rdesc.id == id)
return info;
}
return NULL;
}
static int isl91302a_set_voltage_sel(
struct mtk_simple_regulator_desc *mreg_desc,
unsigned int selector)
{
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
return 0;
#else
struct isl91302a_regulator_info *info =
isl91302a_find_regulator_info(mreg_desc->rdesc.id);
uint32_t data = 0;
int ret;
const int count = mreg_desc->rdesc.n_voltages;
if (selector > count)
return -EINVAL;
data = (selector>>2)&0xff;
ret = isl91302a_assign_bit(mreg_desc->client, info->vol_up_reg,
info->vol_up_mask, data<<info->vol_up_shift);
data = (selector&0x03);
ret |= isl91302a_assign_bit(mreg_desc->client, info->vol_lo_reg,
info->vol_lo_mask, data << info->vol_lo_shift);
return ret;
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
}
static int isl91302a_get_voltage_sel(
struct mtk_simple_regulator_desc *mreg_desc)
{
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
return 0;
#else
struct isl91302a_regulator_info *info =
isl91302a_find_regulator_info(mreg_desc->rdesc.id);
uint32_t regval[2] = {0};
int ret;
ret = isl91302a_read_byte(mreg_desc->client,
info->vol_up_reg, &regval[0]);
ret |= isl91302a_read_byte(mreg_desc->client,
info->vol_lo_reg, &regval[1]);
if (ret < 0)
return ret;
ret = (regval[0]<<2) | ((regval[1]>>6)&0x03);
return ret;
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
}
static int isl91302a_set_mode(
struct mtk_simple_regulator_desc *mreg_desc, unsigned int mode)
{
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
return 0;
#else
struct isl91302a_regulator_info *info =
isl91302a_find_regulator_info(mreg_desc->rdesc.id);
int ret;
switch (mode) {
case REGULATOR_MODE_FAST: /* force pwm mode */
ret = isl91302a_set_bit(mreg_desc->client,
info->mode_reg, info->mode_bit);
break;
case REGULATOR_MODE_NORMAL: /* auto mode */
default:
ret = isl91302a_clr_bit(mreg_desc->client,
info->mode_reg, info->mode_bit);
break;
}
return ret;
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
}
static unsigned int isl91302a_get_mode(
struct mtk_simple_regulator_desc *mreg_desc)
{
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
return 0;
#else
struct isl91302a_regulator_info *info =
isl91302a_find_regulator_info(mreg_desc->rdesc.id);
int ret;
uint32_t regval = 0;
ret = isl91302a_read_byte(mreg_desc->client, info->mode_reg, &regval);
if (ret < 0) {
ISL91302A_pr_notice("%s read mode fail\n", __func__);
return ret;
}
if (regval & info->mode_bit)
return REGULATOR_MODE_FAST;
return REGULATOR_MODE_NORMAL;
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
}
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
static int isl91302a_enable_ipi(struct mtk_simple_regulator_desc *mreg_desc)
{
unsigned int ret = 0;
unsigned char buck_id;
buck_id = mreg_desc->rdesc.id;
if (buck_id != 1) {
pr_notice("%s only support proc2\n", __func__);
return 0;
}
ret = extbuck_ipi_enable(buck_id, 1);
pr_info_ratelimited("%s [%s] id(%d), ret(%d)\n", __func__,
mreg_desc->rdesc.name, buck_id, ret);
dsb(sy);
mdelay(1);
dsb(sy);
if (ret != 0)
return -EINVAL;
return 0;
}
static int isl91302a_disable_ipi(struct mtk_simple_regulator_desc *mreg_desc)
{
unsigned int ret = 0;
unsigned char buck_id;
buck_id = mreg_desc->rdesc.id;
if (buck_id != 1) {
pr_notice("%s only support proc2\n", __func__);
return 0;
}
ret = extbuck_ipi_enable(buck_id, 0);
pr_info_ratelimited("%s [%s] id(%d), ret(%d)\n", __func__,
mreg_desc->rdesc.name, buck_id, ret);
if (ret != 0)
return -EINVAL;
return 0;
}
static int isl91302a_is_enabled_ipi(struct mtk_simple_regulator_desc *mreg_desc)
{
unsigned int ret = 0;
unsigned char buck_id;
buck_id = mreg_desc->rdesc.id;
if (buck_id != 1) {
pr_notice("%s only support proc2\n", __func__);
return 0;
}
ret = extbuck_ipi_enable(buck_id, 0xF);
pr_info_ratelimited("%s [%s] id(%d), ret(%d)\n", __func__,
mreg_desc->rdesc.name, buck_id, ret);
if (ret != 0 && ret != 1)
return -EINVAL;
return ret;
}
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
static struct mtk_simple_regulator_ext_ops isl91302a_regulator_ext_ops = {
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
.enable = isl91302a_enable_ipi,
.disable = isl91302a_disable_ipi,
.is_enabled = isl91302a_is_enabled_ipi,
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
.set_voltage_sel = isl91302a_set_voltage_sel,
.get_voltage_sel = isl91302a_get_voltage_sel,
.get_mode = isl91302a_get_mode,
.set_mode = isl91302a_set_mode,
};
static struct regulator_init_data
isl91302a_buck_init_data[ISL91302A_BUCK_MAX] = {
{
.constraints = {
.name = "ext_buck_gpu",
.min_uV = ISL91302A_MIN_VOLTAGE,
.max_uV = ISL91302A_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE|
REGULATOR_CHANGE_STATUS,
},
},
{
.constraints = {
.name = "ext_buck_proc2",
.min_uV = ISL91302A_MIN_VOLTAGE,
.max_uV = ISL91302A_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE|
REGULATOR_CHANGE_STATUS,
.boot_on = 1,
},
},
{
.constraints = {
.name = "ext_buck_proc1",
.min_uV = ISL91302A_MIN_VOLTAGE,
.max_uV = ISL91302A_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE|
REGULATOR_CHANGE_STATUS,
.always_on = 1,
},
},
};
static int isl91302a_set_ramp_val(struct mtk_simple_regulator_desc *mreg_desc,
unsigned char regval, unsigned char fast_en)
{
struct isl91302a_regulator_info *info =
isl91302a_find_regulator_info(mreg_desc->rdesc.id);
int ret = 0;
if (fast_en)
ret = isl91302a_set_bit(mreg_desc->client,
info->ramp_reg, info->ramp_sel);
else
ret = isl91302a_clr_bit(mreg_desc->client,
info->ramp_reg, info->ramp_sel);
ret |= isl91302a_assign_bit(mreg_desc->client, info->ramp_reg,
info->ramp_mask, regval << info->ramp_shift);
return ret;
}
static int isl91302a_buck_set_ramp_dly(
struct mtk_simple_regulator_desc *mreg_desc, int ramp_dly)
{
int ret = 0;
switch (ramp_dly) {
default:
pr_info("%s Invalid ramp delay, set to default 2.5 mV/us\n",
__func__);
ret = isl91302a_set_ramp_val(mreg_desc, 0, 0);
break;
case 2500:
ret = isl91302a_set_ramp_val(mreg_desc, 0, 0);
break;
case 5000:
ret = isl91302a_set_ramp_val(mreg_desc, 1, 0);
break;
case 10000:
ret = isl91302a_set_ramp_val(mreg_desc, 0, 1);
break;
case 12500:
ret = isl91302a_set_ramp_val(mreg_desc, 2, 0);
break;
case 20000:
ret = isl91302a_set_ramp_val(mreg_desc, 1, 1);
break;
case 25000:
ret = isl91302a_set_ramp_val(mreg_desc, 3, 0);
break;
case 50000:
ret = isl91302a_set_ramp_val(mreg_desc, 2, 1);
break;
case 100000:
ret = isl91302a_set_ramp_val(mreg_desc, 3, 1);
break;
}
return ret;
}
int isl91302a_regulator_init(struct isl91302a_chip *chip)
{
int ret = 0, i = 0;
if (chip == NULL) {
ISL91302A_pr_notice("%s Null chip info\n", __func__);
return -1;
}
for (i = 0; i < ARRAY_SIZE(isl91302a_desc_table); i++) {
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
isl91302a_desc_table[i].client = chip->spi;
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
isl91302a_desc_table[i].def_init_data =
&isl91302a_buck_init_data[i];
ret = mtk_simple_regulator_register(&isl91302a_desc_table[i],
chip->dev, &isl91302a_regulator_ext_ops, NULL);
if (ret < 0) {
ISL91302A_pr_notice(
"%s register mtk simple regulator fail\n"
, __func__);
}
isl91302a_buck_set_ramp_dly(
&isl91302a_desc_table[i], ISL91302A_RAMP_RATE);
}
return 0;
}
int isl91302a_regulator_deinit(struct isl91302a_chip *chip)
{
int ret = 0, i = 0;
for (i = 0; i < ARRAY_SIZE(isl91302a_desc_table); i++) {
ret |= mtk_simple_regulator_unregister(
&isl91302a_desc_table[i]);
}
return ret;
}
@@ -0,0 +1,382 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/spi/spi.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <mtk_spi.h>
#include <linux/delay.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#ifdef CONFIG_RT_REGMAP
#include <mt-plat/rt-regmap.h>
#endif /* CONFIG_RT_REGMAP */
#include "isl91302a-spi.h"
#define ISL91302A_DRV_VERSION "1.0.0_M"
static int isl91302a_read_device(void *client, u32 addr, int len, void *dst)
{
int ret = 0;
struct spi_device *spi = (struct spi_device *)client;
struct spi_transfer xfer = {0,}; /* must init spi_transfer here */
struct spi_message msg;
u32 tx_buf;
u32 rx_buf;
if (len != 1) {
pr_notice("%s not support multi read now\n", __func__);
return -EINVAL;
}
/* LSM first, TX: buf, size, reg, 89 */
tx_buf = 0x00010080;
rx_buf = 0xffffffff;
tx_buf |= addr << 8;
xfer.tx_buf = &tx_buf;
xfer.rx_buf = &rx_buf;
xfer.len = 4;
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
ret = spi_sync(spi, &msg);
if (ret < 0 || rx_buf == 0xffffffff)
return ret;
*(unsigned char *)dst = (rx_buf & 0xff000000) >> 24;
#if 0
pr_info("%s addr 0x%02x = 0x%02x\n", __func__, addr, *val);
pr_info("%s tx_buf = 0x%08x\n", __func__, tx_buf);
pr_info("%s rx_buf = 0x%08x\n", __func__, rx_buf);
#endif
return ret;
}
int isl91302a_write_device(void *client,
uint32_t addr, int len, const void *src)
{
int ret = 0;
struct spi_device *spi = (struct spi_device *)client;
struct spi_transfer xfer = {0,}; /* must init spi_transfer here */
struct spi_message msg;
unsigned char regval;
u32 tx_buf;
u32 rx_buf;
if (len != 1) {
pr_notice("%s not support multi write now\n", __func__);
return -EINVAL;
}
tx_buf = 0x00010000;
rx_buf = 0xffffffff;
regval = *(unsigned char *)src;
tx_buf |= ((regval << 24) | (addr << 8));
xfer.tx_buf = &tx_buf;
xfer.rx_buf = &rx_buf;
xfer.len = 4;
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
ret = spi_sync(spi, &msg);
if (ret < 0 || rx_buf == 0xffffffff)
return ret;
#if 0
pr_info("%s addr 0x%02x = 0x%02x\n", __func__, addr, value);
pr_info("%s tx_buf = 0x%08x\n", __func__, tx_buf);
pr_info("%s rx_buf = 0x%08x\n", __func__, rx_buf);
#endif
return ret;
}
#ifdef CONFIG_RT_REGMAP
RT_REG_DECL(ISL91302A_CHIPNAME_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_FLT_RECORDTEMP_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_MODECTRL_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_IRQ_MASK_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK1_DCM_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK1_UP_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK1_LO_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK1_RSPCFG1_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK2_DCM_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK2_UP_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK2_LO_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK2_RSPCFG1_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK3_DCM_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK3_UP_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK3_LO_R, 1, RT_VOLATILE, {});
RT_REG_DECL(ISL91302A_BUCK3_RSPCFG1_R, 1, RT_VOLATILE, {});
static const rt_register_map_t isl91302a_regmap[] = {
RT_REG(ISL91302A_CHIPNAME_R),
RT_REG(ISL91302A_FLT_RECORDTEMP_R),
RT_REG(ISL91302A_MODECTRL_R),
RT_REG(ISL91302A_IRQ_MASK_R),
RT_REG(ISL91302A_BUCK1_DCM_R),
RT_REG(ISL91302A_BUCK1_UP_R),
RT_REG(ISL91302A_BUCK1_LO_R),
RT_REG(ISL91302A_BUCK1_RSPCFG1_R),
RT_REG(ISL91302A_BUCK2_DCM_R),
RT_REG(ISL91302A_BUCK2_UP_R),
RT_REG(ISL91302A_BUCK2_LO_R),
RT_REG(ISL91302A_BUCK2_RSPCFG1_R),
RT_REG(ISL91302A_BUCK3_DCM_R),
RT_REG(ISL91302A_BUCK3_UP_R),
RT_REG(ISL91302A_BUCK3_LO_R),
RT_REG(ISL91302A_BUCK3_RSPCFG1_R),
};
static struct rt_regmap_properties isl91302a_regmap_props = {
.name = "isl91302a",
.aliases = "isl91302a",
.register_num = ARRAY_SIZE(isl91302a_regmap),
.rm = isl91302a_regmap,
.rt_regmap_mode = RT_CACHE_DISABLE,
};
static struct rt_regmap_fops isl91302a_regmap_fops = {
.read_device = isl91302a_read_device,
.write_device = isl91302a_write_device,
};
#endif /* CONFIG_RT_REGMAP */
int isl91302a_read_byte(void *client, uint32_t addr, uint32_t *value)
{
int ret;
struct spi_device *spi = (struct spi_device *)client;
struct isl91302a_chip *chip = spi_get_drvdata(spi);
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_read(chip->regmap_dev, addr, 1, value);
#else
ret = isl91302a_read_device(chip->spi, addr, 1, value);
#endif /* CONFIG_RT_REGMAP */
if (ret < 0)
pr_notice("%s read addr0x%02x fail\n", __func__, addr);
return ret;
}
EXPORT_SYMBOL(isl91302a_read_byte);
int isl91302a_write_byte(void *client, uint32_t addr, uint32_t data)
{
int ret = 0;
struct spi_device *spi = (struct spi_device *)client;
struct isl91302a_chip *chip = spi_get_drvdata(spi);
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_write(chip->regmap_dev, addr, 1, &data);
#else
ret = isl91302a_write_device(chip->spi, addr, 1, &data);
#endif /* CONFIG_RT_REGMAP */
if (ret < 0)
pr_notice("%s write addr0x%02x fail\n", __func__, addr);
return ret;
}
int isl91302a_assign_bit(void *client,
uint32_t reg, uint32_t mask, uint32_t data)
{
int ret = 0;
struct spi_device *spi = (struct spi_device *)client;
struct isl91302a_chip *ri = spi_get_drvdata(spi);
unsigned char tmp = 0;
uint32_t regval = 0;
mutex_lock(&ri->io_lock);
ret = isl91302a_read_byte(spi, reg, &regval);
if (ret < 0) {
pr_notice("%s fail reg0x%02x data0x%02x\n",
__func__, reg, data);
goto OUT_ASSIGN;
}
tmp = ((regval & 0xff) & ~mask);
tmp |= (data & mask);
ret = isl91302a_write_byte(spi, reg, tmp);
if (ret < 0)
pr_notice("%s fail reg0x%02x data0x%02x\n",
__func__, reg, tmp);
OUT_ASSIGN:
mutex_unlock(&ri->io_lock);
return ret;
}
EXPORT_SYMBOL(isl91302a_assign_bit);
static struct mt_chip_conf isl91302a_spi_config = {
/* setuptime, holdtime --> timing for waveform of SPI */
.setuptime = 3,
.holdtime = 3,
/* high_time, low_time --> set SCK */
.high_time = 10,
.low_time = 10,
/* CS pin idle time */
.cs_idletime = 2,
/* cpol, cpha -->set type */
.cpol = 0,
.cpha = 0,
/* rx_mlsb, tx_mlsb --> MSB first or not */
.rx_mlsb = 1,
.tx_mlsb = 1,
/* tx_endian, rx_endian -->
* Defines whether to reverse the endian order
*/
.tx_endian = 0,
.rx_endian = 0,
/* com_mod --> FIFO/DMA mode */
.com_mod = FIFO_TRANSFER,
/* pause --> if want to always let CS active, set this flag to 1*/
.pause = 0,
/* tckdly --> tune timing */
.tckdly = 0,
/* ?? */
.ulthgh_thrsh = 0,
.cs_pol = 0,
.sample_sel = 0,
.finish_intr = 1,
.deassert = 0,
.ulthigh = 0,
};
static void isl91302a_spi_init(struct spi_device *spi)
{
pr_info("%s inited\n", __func__);
spi->bits_per_word = 32;
spi->controller_data = &isl91302a_spi_config;
mdelay(100);
}
static void isl91302a_reg_init(struct spi_device *spi)
{
int ret = 0;
/* Sleeping voltage inti setting for SPM*/
/* VDVFS1 */
ret = isl91302a_write_byte(spi, 0x7e, 0x76);
ret |= isl91302a_write_byte(spi, 0x7f, 0x00);
/* VDVFS2 */
ret |= isl91302a_write_byte(spi, 0x64, 0x76);
ret |= isl91302a_write_byte(spi, 0x65, 0x00);
if (ret < 0)
ISL91302A_pr_notice("%s init fail\n", __func__);
}
static int isl91302a_check_id(struct spi_device *spi)
{
int ret;
unsigned char data;
ret = isl91302a_read_device(spi, ISL91302A_CHIPNAME_R, 1, &data);
if (ret < 0) {
pr_notice("%s IO fail\n", __func__);
return -EIO;
}
if (data != ISL91302A_CHIPNAME) {
pr_notice("%s ID(0x%02x) not match\n", __func__, data);
return -EINVAL;
}
return 0;
}
static int isl91302a_spi_probe(struct spi_device *spi)
{
struct isl91302a_chip *chip;
int ret;
pr_info("%s\n", __func__);
chip = devm_kzalloc(&spi->dev,
sizeof(struct isl91302a_chip), GFP_KERNEL);
chip->spi = spi;
chip->dev = &spi->dev;
mutex_init(&chip->io_lock);
spi_set_drvdata(spi, chip);
isl91302a_spi_init(spi);
ret = isl91302a_check_id(spi);
if (ret < 0)
return ret;
#ifdef CONFIG_RT_REGMAP
chip->regmap_dev = rt_regmap_device_register_ex(&isl91302a_regmap_props,
&isl91302a_regmap_fops, &spi->dev, spi, -1, chip);
if (!chip->regmap_dev) {
pr_notice("%s register regmap fail\n", __func__);
return -EINVAL;
}
#endif /* #ifdef CONFIG_RT_REGMAP */
isl91302a_reg_init(spi);
ret = isl91302a_regulator_init(chip);
if (ret < 0) {
ISL91302A_pr_notice("%s regulator init fail\n", __func__);
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(chip->regmap_dev);
#endif /* CONFIG_RT_REGMAP */
return -EINVAL;
}
pr_info("%s --OK!!--\n", __func__);
return 0;
}
static int isl91302a_spi_remove(struct spi_device *spi)
{
struct isl91302a_chip *chip = spi_get_drvdata(spi);
if (chip) {
isl91302a_regulator_deinit(chip);
mutex_destroy(&chip->io_lock);
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(chip->regmap_dev);
#endif /* #ifdef CONFIG_RT_REGMAP */
}
return 0;
}
static const struct of_device_id isl91302a_id_table[] = {
{.compatible = "mediatek,isl91302a",},
};
static struct spi_driver isl91302a_spi_driver = {
.driver = {
.name = "isl91302a",
.bus = &spi_bus_type,
.owner = THIS_MODULE,
.of_match_table = isl91302a_id_table,
},
.probe = isl91302a_spi_probe,
.remove = isl91302a_spi_remove,
};
static int __init isl91302a_init(void)
{
pr_notice("%s ver(%s)\n", __func__, ISL91302A_DRV_VERSION);
return spi_register_driver(&isl91302a_spi_driver);
}
static void __exit isl91302a_exit(void)
{
spi_unregister_driver(&isl91302a_spi_driver);
}
subsys_initcall(isl91302a_init);
module_exit(isl91302a_exit);
MODULE_DESCRIPTION("ISL91302A Regulator Driver");
MODULE_VERSION(ISL91302A_DRV_VERSION);
MODULE_AUTHOR("Sakya <jeff_chang@richtek.com>");
MODULE_LICENSE("GPL");
@@ -0,0 +1,97 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __LINUX_ISL91302A_SPI_H
#define __LINUX_ISL91302A_SPI_H
#include <linux/mutex.h>
#include <linux/regulator/consumer.h>
struct isl91302a_chip {
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
struct spi_device *spi;
struct mutex io_lock;
#ifdef CONFIG_RT_REGMAP
struct rt_regmap_device *regmap_dev;
#endif /* CONFIG_RT_REGMAP */
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
struct device *dev;
};
#define ISL91302A_CHIPNAME (0x03)
/* register map */
#define ISL91302A_CHIPNAME_R (0x01)
#define ISL91302A_FLT_RECORDTEMP_R (0x13)
#define ISL91302A_MODECTRL_R (0x24)
#define ISL91302A_IRQ_MASK_R (0x32)
#define ISL91302A_BUCK1_DCM_R (0x3E)
#define ISL91302A_BUCK1_UP_R (0x48)
#define ISL91302A_BUCK1_LO_R (0x49)
#define ISL91302A_BUCK1_RSPCFG1_R (0x54)
#define ISL91302A_BUCK2_DCM_R (0x5B)
#define ISL91302A_BUCK2_UP_R (0x62)
#define ISL91302A_BUCK2_LO_R (0x63)
#define ISL91302A_BUCK2_RSPCFG1_R (0x6E)
#define ISL91302A_BUCK3_DCM_R (0x75)
#define ISL91302A_BUCK3_UP_R (0x7C)
#define ISL91302A_BUCK3_LO_R (0x7D)
#define ISL91302A_BUCK3_RSPCFG1_R (0x88)
/* 4.DVS slew rat */
#define ISL91302A_BUCK_RSPCFG1_RSPUP_M (0x70)
#define ISL91302A_BUCK_RSPCFG1_RSPUP_S 4
#define ISL91302A_BUCK_RSPSEL_M (0x40)
/* 6.Interrupt : OTP/OCP/OV */
#define FLT_RECORDTEMP_FLT_TEMPSDR_M (0x08)
#define FLT_RECORDTEMP_FLT_TEMPWARNR_M (0x04)
#define FLT_RECORDTEMP_FLT_TEMPWARNF_M (0x02)
#define FLT_RECORDTEMP_FLT_TEMPSDF_M (0x01)
#define FLT_RECORDBUCK1_FLT_BUCK1_WOC_M (0x40)
#define FLT_RECORDBUCK1_FLT_BUCK1_OV_M (0x20)
#define FLT_RECORDBUCK1_FLT_BUCK1_UV_M (0x10)
#define FLT_RECORDBUCK2_FLT_BUCK2_WOC_M (0x40)
#define FLT_RECORDBUCK2_FLT_BUCK2_OV_M (0x20)
#define FLT_RECORDBUCK2_FLT_BUCK2_UV_M (0x10)
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
static inline int isl91302a_read_byte(void *client, uint32_t addr,
uint32_t *val)
{
pr_notice("%s not support in sspm\n", __func__);
return -EINVAL;
}
static inline int isl91302a_write_byte(void *client, uint32_t addr,
uint32_t value)
{
pr_notice("%s not support in sspm\n", __func__);
return -EINVAL;
}
static inline int isl91302a_assign_bit(void *client, uint32_t reg,
uint32_t mask, uint32_t data)
{
pr_notice("%s not support in sspm\n", __func__);
return -EINVAL;
}
#else
extern int isl91302a_read_byte(void *client, uint32_t addr, uint32_t *val);
extern int isl91302a_write_byte(void *client, uint32_t addr, uint32_t value);
extern int isl91302a_assign_bit(void *client, uint32_t reg,
uint32_t mask, uint32_t data);
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
extern int isl91302a_regulator_init(struct isl91302a_chip *chip);
extern int isl91302a_regulator_deinit(struct isl91302a_chip *chip);
#define isl91302a_set_bit(spi, reg, mask) \
isl91302a_assign_bit(spi, reg, mask, mask)
#define isl91302a_clr_bit(spi, reg, mask) \
isl91302a_assign_bit(spi, reg, mask, 0x00)
#define ISL91302A_INFO(format, args...) pr_info(format, ##args)
#define ISL91302A_pr_notice(format, args...) pr_notice(format, ##args)
#endif /* __LINUX_ISL91302A_SPI_H */
@@ -0,0 +1,389 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/i2c.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <mt-plat/upmu_common.h>
#include "mt6311-i2c.h"
/*
* Global Variable
*/
/* mt6311 i2c device for mt6311 dirver */
static struct i2c_client *new_client;
static const struct i2c_device_id mt6311_i2c_id[] = {
{"mt6311", 0},
{}
};
static const struct of_device_id mt6311_of_ids[] = {
{.compatible = "mediatek,vproc_buck"},
{},
};
static DEFINE_MUTEX(mt6311_i2c_access);
static int g_mt6311_driver_ready;
static int g_mt6311_hw_exist;
static unsigned char is_mt6311_checked;
/*
* Exported API
*/
int is_mt6311_sw_ready(void)
{
return g_mt6311_driver_ready;
}
int is_mt6311_exist(void)
{
if (is_mt6311_checked == 0) {
#if defined(CONFIG_MTK_PMIC_CHIP_MT6356)
/* get the MT6311 status which is recorded in
* MT6356 register at Preloader
*/
pmic_read_interface(MT6356_TOP_MDB_CONF0,
&g_mt6311_hw_exist, 0x1, 15);
#endif
is_mt6311_checked = 1;
}
return g_mt6311_hw_exist;
}
/*
* Internal Function
*/
static int mt6311_read_device(
unsigned char addr, unsigned int len, unsigned char *data)
{
return i2c_smbus_read_i2c_block_data(new_client, addr, len, data);
}
static int mt6311_write_device(
unsigned char addr, unsigned int len, unsigned char *data)
{
return i2c_smbus_write_i2c_block_data(new_client, addr, len, data);
}
/*
* MT6311 read/write API
*/
int mt6311_read_byte(unsigned char addr, unsigned char *data)
{
int ret = 0;
mutex_lock(&mt6311_i2c_access);
ret = mt6311_read_device(addr, 1, data);
mutex_unlock(&mt6311_i2c_access);
if (ret < 0) {
pr_notice(MT6311TAG "read Reg[0x%x] fail, ret = %d\n"
, addr, ret);
return ret;
}
return 0;
}
int mt6311_write_byte(unsigned char addr, unsigned char data)
{
int ret = 0;
mutex_lock(&mt6311_i2c_access);
ret = mt6311_write_device(addr, 1, &data);
mutex_unlock(&mt6311_i2c_access);
if (ret < 0) {
pr_notice(MT6311TAG "write Reg[0x%x]=0x%x fail, ret = %d\n"
, addr, data, ret);
return ret;
}
return 0;
}
int mt6311_assign_bit(unsigned char reg, unsigned char mask, unsigned char data)
{
unsigned char tmp = 0;
unsigned char regval = 0;
int ret = 0;
mutex_lock(&mt6311_i2c_access);
ret = mt6311_read_device(reg, 1, &regval);
if (ret < 0) {
pr_notice(MT6311TAG "[%s] read fail(ret=%d), Reg[0x%x] data=0x%x, mask=0x%x\n"
, __func__, ret, reg, data, mask);
goto OUT_ASSIGN;
}
tmp = ((regval & 0xff) & ~mask);
tmp |= (data & mask);
ret = mt6311_write_device(reg, 1, &tmp);
if (ret < 0) {
pr_notice(MT6311TAG "[%s] assign bit fail(ret=%d), Reg[0x%x] data=0x%x, mask=0x%x\n"
, __func__, ret, reg, data, mask);
goto OUT_ASSIGN;
}
OUT_ASSIGN:
mutex_unlock(&mt6311_i2c_access);
return ret;
}
int mt6311_read_interface(unsigned char reg, unsigned char *data,
unsigned char mask, unsigned char shift)
{
unsigned char tmp = 0;
unsigned char regval = 0;
int ret = 0;
mutex_lock(&mt6311_i2c_access);
ret = mt6311_read_device(reg, 1, &regval);
tmp = regval;
if (ret < 0) {
pr_notice(MT6311TAG "[%s] read fail(ret=%d), Reg[0x%x], mask=0x%x, shift=%d\n"
, __func__, ret, reg, mask, shift);
goto OUT_ASSIGN;
}
tmp &= (mask << shift);
*data = (tmp >> shift);
OUT_ASSIGN:
mutex_unlock(&mt6311_i2c_access);
return ret;
}
int mt6311_config_interface(unsigned char reg, unsigned char data,
unsigned char mask, unsigned char shift)
{
unsigned char tmp = 0;
unsigned char regval = 0;
int ret = 0;
mutex_lock(&mt6311_i2c_access);
ret = mt6311_read_device(reg, 1, &regval);
tmp = regval;
if (ret < 0) {
pr_notice(MT6311TAG "[%s] read fail(ret=%d), Reg[0x%x] data=0x%x, mask=0x%x, shift=%d\n"
, __func__, ret, reg, data, mask, shift);
goto OUT_ASSIGN;
}
tmp &= ~(mask << shift);
tmp |= (data << shift);
ret = mt6311_write_device(reg, 1, &tmp);
if (ret < 0) {
pr_notice("[%s] write fail(ret=%d), Reg[0x%x] data=0x%x, mask=0x%x, shift=%d\n"
, __func__, ret, reg, data, mask, shift);
goto OUT_ASSIGN;
}
OUT_ASSIGN:
mutex_unlock(&mt6311_i2c_access);
return ret;
}
static int mt6311_check_id(void)
{
int ret = 0;
unsigned char data = 0;
ret = mt6311_read_device(MT6311_CID, 1, &data);
if (ret < 0) {
/* MT6311 IO fail */
pr_notice(MT6311TAG "MT6311 check id fail\n");
return -EIO;
}
if (data != MT6311_CID_CODE) {
/*MT6311 CID(0x%02x) not match */
pr_notice(MT6311TAG "MT6311 id(0x%x) error\n", data);
return -EINVAL;
}
return 0;
}
static int mt6311_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
MT6311LOG("MT6311 probe\n"); /*mt6311_probe*/
new_client = client;
ret = mt6311_check_id();
if (ret < 0)
return ret;
g_mt6311_hw_exist = 1;
#if 0
/* initial setting */
#endif
#ifdef IPIMB_MT6311
pr_notice(MT6311TAG "regulator not support for SSPM\n");
return 0;
#else
ret = mt6311_regulator_init(&client->dev);
if (ret < 0) {
/*mt6311_probe regulator init fail*/
MT6311LOG("MT6311 regulator init fail\n");
return -EINVAL;
}
g_mt6311_driver_ready = 1;
MT6311LOG("MT6311 probe done\n"); /*mt6311_probe --OK!!--*/
return 0;
#endif
}
static int mt6311_i2c_remove(struct i2c_client *client)
{
#ifdef IPIMB_MT6311
pr_notice(MT6311TAG "regulator not support for SSPM\n");
#else
mt6311_regulator_deinit();
#endif
return 0;
}
static struct i2c_driver mt6311_driver = {
.driver = {
.name = "mt6311",
.of_match_table = of_match_ptr(mt6311_of_ids),
},
.probe = mt6311_i2c_probe,
.remove = mt6311_i2c_remove,
.id_table = mt6311_i2c_id,
};
/*
* mt6311_access
*/
static unsigned char g_reg_value_mt6311;
static ssize_t show_mt6311_access(
struct device *dev, struct device_attribute *attr, char *buf)
{
pr_notice(MT6311TAG "[%s] 0x%x\n", __func__, g_reg_value_mt6311);
return sprintf(buf, "0x%x\n", g_reg_value_mt6311);
}
static ssize_t store_mt6311_access(
struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
#ifdef IPIMB_MT6311
pr_notice(MT6311TAG "mt6311_access not support for SSPM\n");
return size;
#else
int ret;
char *pvalue = NULL, *addr, *val;
unsigned int reg_value = 0;
unsigned int reg_address = 0;
pr_notice(MT6311TAG "[%s]\n", __func__);
if (buf != NULL && size != 0) {
pr_notice(MT6311TAG "[%s] size is %d, buf is %s\n"
, __func__, (int)size, buf);
pvalue = (char *)buf;
addr = strsep(&pvalue, " ");
val = strsep(&pvalue, " ");
if (addr)
ret = kstrtou32(addr, 16, (unsigned int *)&reg_address);
if (val) {
ret = kstrtou32(val, 16, (unsigned int *)&reg_value);
pr_notice(MT6311TAG "[%s] write mt6311 reg 0x%x with value 0x%x!\n"
, __func__, reg_address, reg_value);
ret = mt6311_config_interface(reg_address
, reg_value, 0xFF, 0x0);
} else {
ret = mt6311_read_interface(reg_address
, &g_reg_value_mt6311, 0xFF, 0x0);
pr_notice(MT6311TAG "[%s] read mt6311 reg 0x%x with value 0x%x !\n"
, __func__, reg_address, g_reg_value_mt6311);
pr_notice(MT6311TAG "[%s] use \"cat mt6311_access\" to get value\n"
, __func__);
}
}
return size;
#endif
}
/*664*/
static DEVICE_ATTR(mt6311_access
, 0664, show_mt6311_access, store_mt6311_access);
/*
* mt6311_user_space_probe
*/
static int mt6311_user_space_probe(struct platform_device *dev)
{
int ret_device_file = 0;
ret_device_file = device_create_file(&(dev->dev)
, &dev_attr_mt6311_access);
return 0;
}
static struct platform_device mt6311_user_space_device = {
.name = "mt6311-user",
.id = -1,
};
static struct platform_driver mt6311_user_space_driver = {
.probe = mt6311_user_space_probe,
.driver = {
.name = "mt6311-user",
},
};
static int __init mt6311_init(void)
{
int ret = 0;
/* MT6311 i2c driver register */
#ifdef IPIMB_MT6311
pr_notice(MT6311TAG "Kernel driver not support for SSPM\n");
#else
ret = i2c_add_driver(&mt6311_driver);
if (ret != 0) {
pr_notice(MT6311TAG "failed to register mt6311 i2c driver\n");
return ret;
}
MT6311LOG("MT6311 i2c driver probe done\n");
#endif
if (is_mt6311_exist()) {
ret = platform_device_register(&mt6311_user_space_device);
if (ret)
pr_notice(MT6311TAG "failed to create mt6311_access file(device register fail)\n"
);
ret = platform_driver_register(&mt6311_user_space_driver);
if (ret)
pr_notice(MT6311TAG "failed to create mt6311_access file(driver register fail)\n"
);
MT6311LOG("MT6311 user space driver probe done\n");
} else {
MT6311LOG("MT6311 not exist!, user space driver not probe\n");
}
return ret;
}
static void __exit mt6311_exit(void)
{
i2c_del_driver(&mt6311_driver);
}
module_init(mt6311_init);
module_exit(mt6311_exit);
MODULE_AUTHOR("Jeter Chen");
MODULE_DESCRIPTION("MT6311 Device Driver");
MODULE_LICENSE("GPL");
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,242 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include "mt6311-i2c.h"
#include <linux/regulator/machine.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/mediatek/mtk_regulator_core.h>
#ifdef IPIMB_MT6311
#include <mach/mtk_pmic_ipi.h>
#endif /* IPIMB */
#include <linux/delay.h>
#define MT6311_MIN_VOLTAGE (600000)
#define MT6311_MAX_VOLTAGE (1393750)
#define MT6311_step_uV 6250
#define MT6311_enable_bit 0
#define MT6311_enable_mask 1
#define MT6311_mode_bit 6
#define MT6311_mode_mask 1
#define mt6311_proc_vol_reg (MT6311_PMIC_VDVFS11_VOSEL_ON_ADDR)
#define mt6311_proc_vol_mask (MT6311_PMIC_VDVFS11_VOSEL_ON_MASK)
#define mt6311_proc_vol_shift (MT6311_PMIC_VDVFS11_VOSEL_ON_SHIFT)
#define mt6311_proc_enable_reg (MT6311_PMIC_VDVFS11_EN_ADDR)
#define mt6311_proc_enable_bit (MT6311_enable_bit)
#define mt6311_proc_min_uV (MT6311_MIN_VOLTAGE)
#define mt6311_proc_max_uV (MT6311_MAX_VOLTAGE)
#define mt6311_proc_id (0)
#define mt6311_proc_mode_reg (MT6311_PMIC_RG_VDVFS11_MODESET_ADDR)
#define mt6311_proc_mode_bit (MT6311_mode_bit)
#define mt6311_n_voltages \
((MT6311_MAX_VOLTAGE - MT6311_MIN_VOLTAGE) / MT6311_step_uV + 1)
static int mt6311_list_voltage(
struct mtk_simple_regulator_desc *mreg_desc,
unsigned int selector)
{
return (selector >= mreg_desc->rdesc.n_voltages) ?
-EINVAL : (mreg_desc->min_uV + selector * MT6311_step_uV);
}
static struct mtk_simple_regulator_desc mt6311_desc_table[] = {
mreg_decl(mt6311_proc, mt6311_list_voltage, mt6311_n_voltages, NULL),
};
static int mt6311_set_voltage_sel(
struct mtk_simple_regulator_desc *mreg_desc,
unsigned int selector)
{
int ret;
MT6311LOG("[%s] (%s) selector = %d\n"
, __func__, mreg_desc->rdesc.name, selector);
if (selector > mreg_desc->rdesc.n_voltages)
return -EINVAL;
MT6311LOG("[%s] (%s) Vout = %d\n"
, __func__, mreg_desc->rdesc.name
, mt6311_list_voltage(mreg_desc, selector));
ret = mt6311_assign_bit(mreg_desc->vol_reg
, mreg_desc->vol_mask, selector);
MT6311LOG("[%s] (%s) ret = %d\n", __func__, mreg_desc->rdesc.name, ret);
return ret;
}
static int mt6311_get_voltage_sel(
struct mtk_simple_regulator_desc *mreg_desc)
{
int ret;
unsigned char data;
ret = mt6311_read_byte(mreg_desc->vol_reg, &data);
if (ret < 0)
return ret;
data = (data & mreg_desc->vol_mask) >> mreg_desc->vol_shift;
MT6311LOG("[%s] (%s) selector = %d\n"
, __func__, mreg_desc->rdesc.name, data);
return data;
}
static int mt6311_enable(struct mtk_simple_regulator_desc *mreg_desc)
{
int ret = 0;
MT6311LOG("[%s] enable (%s)\n", __func__, mreg_desc->rdesc.name);
ret = mt6311_config_interface(mreg_desc->enable_reg
, 1, MT6311_enable_mask, mreg_desc->enable_bit);
if (ret < 0)
pr_notice(MT6311TAG "[%s] enable (%s) fail, ret = %d\n",
__func__, mreg_desc->rdesc.name, ret);
return ret;
}
static int mt6311_disable(struct mtk_simple_regulator_desc *mreg_desc)
{
int ret = 0;
MT6311LOG("[%s] disable (%s)\n", __func__, mreg_desc->rdesc.name);
if (mreg_desc->rdev->use_count == 0) {
pr_notice(MT6311TAG "MT6311 should not be disable (use_count=%d)\n"
, mreg_desc->rdev->use_count);
return -1;
}
ret = mt6311_config_interface(mreg_desc->enable_reg
, 0, MT6311_enable_mask, mreg_desc->enable_bit);
if (ret < 0)
pr_notice(MT6311TAG "[%s] disable (%s) fail, ret = %d\n",
__func__, mreg_desc->rdesc.name, ret);
return ret;
}
static int mt6311_is_enabled(struct mtk_simple_regulator_desc *mreg_desc)
{
unsigned char en = 0;
int ret = 0;
ret = mt6311_read_interface(mreg_desc->enable_reg
, &en, MT6311_enable_mask, mreg_desc->enable_bit);
if (ret < 0) {
pr_notice(MT6311TAG "[%s] Check (%s) status fail, ret = %d\n",
__func__, mreg_desc->rdesc.name, ret);
return ret;
}
return en;
}
static int mt6311_set_mode(
struct mtk_simple_regulator_desc *mreg_desc, unsigned int mode)
{
int ret;
switch (mode) {
case 1: /* force pwm mode */
ret = mt6311_config_interface(mt6311_proc_mode_reg
, mode, MT6311_mode_mask, MT6311_mode_bit);
break;
case 0: /* auto mode */
ret = mt6311_config_interface(mt6311_proc_mode_reg
, mode, MT6311_mode_mask, MT6311_mode_bit);
break;
default:
pr_notice(MT6311TAG "[%s] Set Wrong mode = %d\n"
, __func__, mode);
return -1;
}
return ret;
}
static unsigned int mt6311_get_mode(
struct mtk_simple_regulator_desc *mreg_desc)
{
unsigned char mode = 0;
int ret;
ret = mt6311_read_interface(mt6311_proc_mode_reg
, &mode, MT6311_mode_mask, MT6311_mode_bit);
if (ret < 0) {
pr_notice(MT6311TAG "[%s] read mode fail, ret = %d\n"
, __func__, ret);
return 2;
}
return mode;
}
static struct mtk_simple_regulator_ext_ops mt6311_regulator_ext_ops = {
.enable = mt6311_enable,
.disable = mt6311_disable,
.is_enabled = mt6311_is_enabled,
.set_voltage_sel = mt6311_set_voltage_sel,
.get_voltage_sel = mt6311_get_voltage_sel,
.set_mode = mt6311_set_mode,
.get_mode = mt6311_get_mode,
};
static struct regulator_init_data mt6311_buck_init_data[] = {
{
.constraints = {
.name = "ext_buck_proc",
.min_uV = MT6311_MIN_VOLTAGE,
.max_uV = MT6311_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE|
REGULATOR_CHANGE_STATUS,
},
},
};
int mt6311_vdvfs11_set_mode(unsigned char mode)
{
int ret = 0;
#ifdef IPIMB_MT6311
ret = mt6311_ipi_set_mode(mode);
#else
ret = mt6311_config_interface(MT6311_PMIC_RG_VDVFS11_MODESET_ADDR, mode,
MT6311_PMIC_RG_VDVFS11_MODESET_MASK,
MT6311_PMIC_RG_VDVFS11_MODESET_SHIFT);
#endif
return ret;
}
int mt6311_regulator_init(struct device *dev)
{
int ret = 0, i = 0;
for (i = 0; i < ARRAY_SIZE(mt6311_desc_table); i++) {
mt6311_desc_table[i].def_init_data =
&mt6311_buck_init_data[i];
ret = mtk_simple_regulator_register(&mt6311_desc_table[i],
dev, &mt6311_regulator_ext_ops, NULL);
if (ret < 0)
pr_notice(MT6311TAG "%s register mtk simple regulator fail\n"
, __func__);
}
return 0;
}
int mt6311_regulator_deinit(void)
{
int ret = 0, i = 0;
for (i = 0; i < ARRAY_SIZE(mt6311_desc_table); i++)
ret |= mtk_simple_regulator_unregister(&mt6311_desc_table[i]);
return ret;
}
@@ -0,0 +1,21 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __LINUX_MT6311_H
#define __LINUX_MT6311_H
extern void mt6311_clr_thr_l_int_status(void);
extern void mt6311_clr_thr_h_int_status(void);
extern void mt6311_set_rg_int_en(unsigned char val);
extern unsigned char mt6311_get_rg_thr_l_int_status(void);
extern unsigned char mt6311_get_rg_thr_h_int_status(void);
extern unsigned char mt6311_get_pmu_thr_status(void);
extern void mt6311_set_rg_strup_thr_110_clr(unsigned char val);
extern void mt6311_set_rg_strup_thr_125_clr(unsigned char val);
extern void mt6311_set_rg_strup_thr_110_irq_en(unsigned char val);
extern void mt6311_set_rg_strup_thr_125_irq_en(unsigned char val);
extern void mt6311_set_rg_thrdet_sel(unsigned char val);
#endif /* __LINUX_MT6311_H */
@@ -0,0 +1,139 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include "mt6311-i2c.h"
#include "mt6311.h"
unsigned int thr_l_int_status;
unsigned int thr_h_int_status;
void mt6311_clr_thr_l_int_status(void)
{
thr_l_int_status = 0;
MT6311LOG("[%s]\n", __func__);
}
void mt6311_clr_thr_h_int_status(void)
{
thr_h_int_status = 0;
MT6311LOG("[%s]\n", __func__);
}
void mt6311_set_rg_int_en(unsigned char val)
{
unsigned char ret = 0;
ret = mt6311_config_interface(
(unsigned char) (MT6311_TOP_INT_CON),
(unsigned char) (val),
(unsigned char) (MT6311_PMIC_RG_INT_EN_MASK),
(unsigned char) (MT6311_PMIC_RG_INT_EN_SHIFT));
}
unsigned char mt6311_get_rg_thr_l_int_status(void)
{
unsigned char ret = 0;
unsigned char val = 0;
ret = mt6311_read_interface(
(unsigned char) (MT6311_TOP_INT_MON),
(&val),
(unsigned char) (MT6311_PMIC_RG_THR_L_INT_STATUS_MASK),
(unsigned char) (MT6311_PMIC_RG_THR_L_INT_STATUS_SHIFT)
);
return val;
}
unsigned char mt6311_get_rg_thr_h_int_status(void)
{
unsigned char ret = 0;
unsigned char val = 0;
ret = mt6311_read_interface(
(unsigned char) (MT6311_TOP_INT_MON),
(&val),
(unsigned char) (MT6311_PMIC_RG_THR_H_INT_STATUS_MASK),
(unsigned char) (MT6311_PMIC_RG_THR_H_INT_STATUS_SHIFT)
);
return val;
}
unsigned char mt6311_get_pmu_thr_status(void)
{
unsigned char ret = 0;
unsigned char val = 0;
ret = mt6311_read_interface(
(unsigned char) (MT6311_STRUP_CON2),
(&val),
(unsigned char) (MT6311_PMIC_PMU_THR_STATUS_MASK),
(unsigned char) (MT6311_PMIC_PMU_THR_STATUS_SHIFT)
);
return val;
}
void mt6311_set_rg_strup_thr_110_clr(unsigned char val)
{
unsigned char ret = 0;
ret = mt6311_config_interface(
(unsigned char) (MT6311_STRUP_CON14),
(unsigned char) (val),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_110_CLR_MASK),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_110_CLR_SHIFT)
);
}
void mt6311_set_rg_strup_thr_125_clr(unsigned char val)
{
unsigned char ret = 0;
ret = mt6311_config_interface(
(unsigned char) (MT6311_STRUP_CON14),
(unsigned char) (val),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_125_CLR_MASK),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_125_CLR_SHIFT)
);
}
void mt6311_set_rg_strup_thr_110_irq_en(unsigned char val)
{
unsigned char ret = 0;
ret = mt6311_config_interface(
(unsigned char) (MT6311_STRUP_CON14),
(unsigned char) (val),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_110_IRQ_EN_MASK),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_110_IRQ_EN_SHIFT)
);
}
void mt6311_set_rg_strup_thr_125_irq_en(unsigned char val)
{
unsigned char ret = 0;
ret = mt6311_config_interface(
(unsigned char) (MT6311_STRUP_CON14),
(unsigned char) (val),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_125_IRQ_EN_MASK),
(unsigned char) (MT6311_PMIC_RG_STRUP_THR_125_IRQ_EN_SHIFT)
);
}
void mt6311_set_rg_thrdet_sel(unsigned char val)
{
unsigned char ret = 0;
ret = mt6311_config_interface(
(unsigned char) (MT6311_STRUP_ANA_CON0),
(unsigned char) (val),
(unsigned char) (MT6311_PMIC_RG_THRDET_SEL_MASK),
(unsigned char) (MT6311_PMIC_RG_THRDET_SEL_SHIFT)
);
}
@@ -0,0 +1,551 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/version.h>
#include <linux/slab.h>
#include <linux/of_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#ifdef CONFIG_RT_REGMAP
#include <mt-plat/rt-regmap.h>
#endif /* CONFIG_RT_REGMAP */
#include "mt6691-regulator.h"
struct regulator_chip {
struct regulator_desc desc;
unsigned char vol_reg;
unsigned char vol_mask;
unsigned char mode_reg;
unsigned char mode_bit;
unsigned char enable_reg;
unsigned char enable_bit;
};
/*
* Exported API
*/
static int g_is_mt6691_exist;
int is_mt6691_exist(void)
{
#if defined(MT6691_IS_EXIST_NAME)
struct regulator *reg;
reg = regulator_get(NULL, MT6691_IS_EXIST_NAME);
pr_info("%s: regulator_get=%s\n", __func__, MT6691_IS_EXIST_NAME);
if (reg == NULL)
return 0;
regulator_put(reg);
return 1;
#else
pr_notice("g_is_mt6691_exist=%d\n", g_is_mt6691_exist);
return g_is_mt6691_exist;
#endif
}
static int mt6691_read_device(void *client, u32 addr,
int len, void *dst)
{
struct i2c_client *i2c = (struct i2c_client *)client;
return i2c_smbus_read_i2c_block_data(i2c, addr, len, dst);
}
static int mt6691_write_device(void *client, u32 addr,
int len, const void *src)
{
struct i2c_client *i2c = (struct i2c_client *)client;
return i2c_smbus_write_i2c_block_data(i2c, addr, len, src);
}
#ifdef CONFIG_RT_REGMAP
RT_REG_DECL(MT6691_REG_VSEL0, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(MT6691_REG_VSEL1, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(MT6691_REG_CTRL1, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(MT6691_REG_ID1, 1, RT_VOLATILE, {});
RT_REG_DECL(MT6691_REG_ID2, 1, RT_VOLATILE, {});
RT_REG_DECL(MT6691_REG_MONITOR, 1, RT_VOLATILE, {});
RT_REG_DECL(MT6691_REG_CTRL2, 1, RT_VOLATILE, {});
RT_REG_DECL(MT6691_REG_CTRL3, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(MT6691_REG_CTRL4, 1, RT_WBITS_WR_ONCE, {});
static const rt_register_map_t mt6691_regmap[] = {
RT_REG(MT6691_REG_VSEL0),
RT_REG(MT6691_REG_VSEL1),
RT_REG(MT6691_REG_CTRL1),
RT_REG(MT6691_REG_ID1),
RT_REG(MT6691_REG_ID2),
RT_REG(MT6691_REG_MONITOR),
RT_REG(MT6691_REG_CTRL2),
RT_REG(MT6691_REG_CTRL3),
RT_REG(MT6691_REG_CTRL4),
};
static struct rt_regmap_fops mt6691_regmap_fops = {
.read_device = mt6691_read_device,
.write_device = mt6691_write_device,
};
#endif /* CONFIG_RT_REGMAP */
int mt6691_read_byte(void *client,
uint32_t addr, uint32_t *val)
{
int ret = 0;
struct i2c_client *i2c = (struct i2c_client *)client;
ret = mt6691_read_device(i2c, addr, 1, val);
if (ret < 0)
pr_notice("%s read 0x%02x fail\n", __func__, addr);
return ret;
}
int mt6691_write_byte(void *client, uint32_t addr, uint32_t value)
{
int ret = 0;
struct i2c_client *i2c = (struct i2c_client *)client;
ret = mt6691_write_device(i2c, addr, 1, &value);
if (ret < 0)
pr_notice("%s write 0x%02x fail\n", __func__, addr);
return ret;
}
int mt6691_assign_bit(void *client, uint32_t reg, int32_t mask, uint32_t data)
{
struct i2c_client *i2c = (struct i2c_client *)client;
struct mt6691_regulator_info *ri = i2c_get_clientdata(i2c);
unsigned char tmp = 0;
uint32_t regval = 0;
int ret = 0;
mutex_lock(&ri->io_lock);
ret = mt6691_read_byte(i2c, reg, &regval);
if (ret < 0) {
pr_notice("%s read fail reg0x%02x data0x%02x\n",
__func__, reg, data);
goto OUT_ASSIGN;
}
tmp = ((regval & 0xff) & ~mask);
tmp |= (data & mask);
ret = mt6691_write_byte(i2c, reg, tmp);
if (ret < 0)
pr_notice("%s write fail reg0x%02x data0x%02x\n",
__func__, reg, tmp);
OUT_ASSIGN:
mutex_unlock(&ri->io_lock);
return ret;
}
#define mt6691_set_bit(i2c, reg, mask) \
mt6691_assign_bit(i2c, reg, mask, mask)
#define mt6691_clr_bit(i2c, reg, mask) \
mt6691_assign_bit(i2c, reg, mask, 0x00)
static int mt6691_regmap_init(struct mt6691_regulator_info *info)
{
#ifdef CONFIG_RT_REGMAP
info->regmap_props = devm_kzalloc(info->dev,
sizeof(struct rt_regmap_properties), GFP_KERNEL);
info->regmap_props->name = info->reg_chip->desc.name;
info->regmap_props->aliases = info->reg_chip->desc.name;
info->regmap_props->register_num = ARRAY_SIZE(mt6691_regmap);
info->regmap_props->rm = mt6691_regmap;
info->regmap_props->rt_regmap_mode = RT_CACHE_WR_THROUGH;
info->regmap_dev = rt_regmap_device_register(info->regmap_props,
&mt6691_regmap_fops, info->dev, info->i2c, info);
if (!info->regmap_dev)
return -EINVAL;
#endif /* CONFIG_RT_REGMAP */
return 0;
}
static int mt6691_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned int *selector)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
if (min_uV < 1300000)
*selector = (min_uV - 300000) / 5000;
else
*selector = (min_uV - 1300000) / 10000 + 200;
if (*selector > 255)
*selector = 255;
return mt6691_write_byte(info->i2c,
info->reg_chip->vol_reg, *selector);
}
static int mt6691_get_voltage(struct regulator_dev *rdev)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
int ret;
uint32_t reg_val = 0;
ret = mt6691_read_byte(info->i2c, info->reg_chip->vol_reg, &reg_val);
if (ret < 0) {
pr_notice("%s read voltage fail\n", __func__);
return ret;
}
if (reg_val > 200)
return 1300000 + (reg_val - 200) * 10000;
return 300000 + reg_val * 5000;
}
static int hl7593_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned int *selector)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
*selector = (min_uV - 600000) / 6250;
return mt6691_assign_bit(info->i2c, info->reg_chip->vol_reg,
info->reg_chip->vol_mask, *selector);
}
static int hl7593_get_voltage(struct regulator_dev *rdev)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
int ret;
uint32_t reg_val = 0;
ret = mt6691_read_byte(info->i2c, info->reg_chip->vol_reg, &reg_val);
if (ret < 0) {
pr_notice("%s read voltage fail\n", __func__);
return ret;
}
reg_val &= info->reg_chip->vol_mask;
return 600000 + reg_val * 6250;
}
static int mt6691_set_mode(struct regulator_dev *rdev, unsigned int mode)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
int ret;
switch (mode) {
case REGULATOR_MODE_FAST: /* force pwm mode */
ret = mt6691_set_bit(info->i2c, info->reg_chip->mode_reg,
info->reg_chip->mode_bit);
break;
case REGULATOR_MODE_NORMAL:
default:
ret = mt6691_clr_bit(info->i2c, info->reg_chip->mode_reg,
info->reg_chip->mode_bit);
break;
}
return ret;
}
static unsigned int mt6691_get_mode(struct regulator_dev *rdev)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
int ret;
uint32_t regval = 0;
ret = mt6691_read_byte(info->i2c, info->reg_chip->mode_reg, &regval);
if (ret < 0) {
pr_notice("%s read mode fail\n", __func__);
return ret;
}
if (regval & info->reg_chip->mode_bit)
return REGULATOR_MODE_FAST;
return REGULATOR_MODE_NORMAL;
}
static int mt6691_enable(struct regulator_dev *rdev)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
return mt6691_set_bit(info->i2c, info->reg_chip->enable_reg,
info->reg_chip->enable_bit);
}
static int mt6691_disable(struct regulator_dev *rdev)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
if (rdev->use_count == 0) {
pr_info("ext_buck should not be disable (use_count=%d)\n"
, rdev->use_count);
return -1;
}
return mt6691_clr_bit(info->i2c, info->reg_chip->enable_reg,
info->reg_chip->enable_bit);
}
static int mt6691_is_enabled(struct regulator_dev *rdev)
{
struct mt6691_regulator_info *info = rdev_get_drvdata(rdev);
int ret;
uint32_t reg_val;
ret = mt6691_read_byte(info->i2c, info->reg_chip->enable_reg, &reg_val);
if (ret < 0)
return ret;
return (reg_val & info->reg_chip->enable_bit) ? 1 : 0;
}
static struct regulator_ops mt6691_regulator_ops = {
.set_voltage = mt6691_set_voltage,
.get_voltage = mt6691_get_voltage,
.set_mode = mt6691_set_mode,
.get_mode = mt6691_get_mode,
.enable = mt6691_enable,
.disable = mt6691_disable,
.is_enabled = mt6691_is_enabled,
};
static struct regulator_ops hl7593_regulator_ops = {
.set_voltage = hl7593_set_voltage,
.get_voltage = hl7593_get_voltage,
.set_mode = mt6691_set_mode,
.get_mode = mt6691_get_mode,
.enable = mt6691_enable,
.disable = mt6691_disable,
.is_enabled = mt6691_is_enabled,
};
#define REG_CHIP(_id, _vsel) \
{ \
.desc = { \
.id = _id, \
.name = "mt6691_buck"#_id, \
.n_voltages = 201, \
.ops = &mt6691_regulator_ops, \
.type = REGULATOR_VOLTAGE, \
.owner = THIS_MODULE, \
}, \
.vol_reg = MT6691_REG_VSEL##_vsel, \
.vol_mask = 0xFF, \
.mode_reg = MT6691_CTRL_1, \
.mode_bit = (1 << _vsel), \
.enable_reg = MT6691_REG_CTRL2, \
.enable_bit = (1 << _vsel), \
}
#define HL7593_REG_CHIP(_id, _vsel) \
{ \
.desc = { \
.id = _id, \
.name = "hl7593_buck"#_id, \
.n_voltages = 128, \
.ops = &hl7593_regulator_ops, \
.type = REGULATOR_VOLTAGE, \
.owner = THIS_MODULE, \
}, \
.vol_reg = MT6691_REG_VSEL##_vsel, \
.vol_mask = 0x7F, \
.mode_reg = MT6691_CTRL_1, \
.mode_bit = (1 << _vsel), \
.enable_reg = MT6691_REG_VSEL##_vsel, \
.enable_bit = (1 << 7), \
}
static struct regulator_chip mt6691_datas[] = {
REG_CHIP(0, 0), /* VDD2 1.125V */
REG_CHIP(1, 1), /* VDDQ 0.6V */
REG_CHIP(2, 0), /* VMDDR 0.75V */
REG_CHIP(3, 0), /* VUFS12 1.225V */
HL7593_REG_CHIP(2, 0), /* VMDDR 0.75V */
HL7593_REG_CHIP(3, 0), /* VUFS12 1.2V */
};
struct regulator_dev *mt6691_regulator_register(
const struct regulator_desc *desc,
struct device *dev,
struct regulator_init_data *init_data,
void *driver_data)
{
struct regulator_config config = {
.dev = dev,
.init_data = init_data,
.driver_data = driver_data,
.of_node = dev->of_node,
};
return regulator_register(desc, &config);
}
static int mt6691_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct mt6691_regulator_info *info;
struct regulator_init_data *init_data = NULL;
int ret;
switch (i2c->addr) {
case 0x50: /* MT6691ZXP */
case 0x57: /* MT6691OOP */
case 0x51: /* MT6691SVP */
case 0x56: /* MT6691OTP */
break;
default:
dev_info(&i2c->dev, "%s invalid Slave Addr\n", __func__);
return -ENODEV;
}
info = devm_kzalloc(&i2c->dev,
sizeof(struct mt6691_regulator_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
init_data = of_get_regulator_init_data(&i2c->dev, i2c->dev.of_node,
NULL);
if (init_data) {
dev_info(&i2c->dev,
"regulator_name = %s, min_uV =%d, max_uV = %d\n",
init_data->constraints.name,
init_data->constraints.min_uV,
init_data->constraints.max_uV);
} else {
dev_info(&i2c->dev, "%s: no init data\n", __func__);
return -EINVAL;
}
info->i2c = i2c;
info->dev = &i2c->dev;
info->reg_chip = of_device_get_match_data(&i2c->dev);
mutex_init(&info->io_lock);
i2c_set_clientdata(i2c, info);
#if 0
g_is_mt6691_exist = 1;
if (mt6691_read_byte(info->i2c, MT6691_REG_MONITOR, &ret) >= 0)
g_is_mt6691_exist &= 1;
else
g_is_mt6691_exist &= 0;
dev_info(&i2c->dev, "i2c_slv=0x%x ret=0x%x g_is_mt6691_exist=%d\n",
i2c->addr, ret, g_is_mt6691_exist);
return 0;
#else
info->regulator = mt6691_regulator_register(&info->reg_chip->desc,
&i2c->dev,
init_data,
info);
if (IS_ERR(info->regulator)) {
switch (i2c->addr) {
case 0x51: /* MT6691SVP */
i2c->addr = 0x61; /* HL7593WL0A */
info->reg_chip = &mt6691_datas[4];
break;
case 0x56: /* MT6691OTP */
i2c->addr = 0x60; /* HL7593WL07 */
info->reg_chip = &mt6691_datas[5];
break;
default:
pr_notice("mt6691 register regulator fail\n");
return -EINVAL;
}
info->regulator =
mt6691_regulator_register(&info->reg_chip->desc,
&i2c->dev,
init_data,
info);
if (IS_ERR(info->regulator)) {
pr_notice("mt6691 register regulator fail\n");
return -EINVAL;
}
}
g_is_mt6691_exist = 1;
info->regulator->constraints->valid_modes_mask |=
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST);
info->regulator->constraints->valid_ops_mask |=
REGULATOR_CHANGE_MODE;
ret = mt6691_regmap_init(info);
if (ret < 0) {
dev_info(&i2c->dev, "%s mt6691 regmap init fail\n", __func__);
return -EINVAL;
}
pr_info("%s Successfully\n", __func__);
return 0;
#endif
}
static int mt6691_i2c_remove(struct i2c_client *i2c)
{
struct mt6691_regulator_info *info = i2c_get_clientdata(i2c);
if (info) {
regulator_unregister(info->regulator);
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(info->regmap_dev);
#endif /* CONFIG_RT_REGMAP */
mutex_destroy(&info->io_lock);
}
return 0;
}
/* Must reserve one empty object at the end */
static const struct of_device_id rt_match_table[] = {
{ /* VDD2=1.125V (0x57) */
.compatible = MT6691_CMPT_STR_0,
.data = &mt6691_datas[0],
}, { /* VDDQ=1.125V (0x57) */
.compatible = MT6691_CMPT_STR_1,
.data = &mt6691_datas[1],
}, { /* VMDDR=0.75V (0x51) */
.compatible = MT6691_CMPT_STR_2,
.data = &mt6691_datas[2],
}, { /* VUFS12=1.225V (0x56) */
.compatible = "mediatek,ext_buck_vufs12",
.data = &mt6691_datas[3],
}, {
/* Sentinel */
},
};
static const struct i2c_device_id rt_dev_id[] = {
{"mt6691", 0},
{ },
};
static struct i2c_driver mt6691_i2c_driver = {
.driver = {
.name = "mt6691",
.owner = THIS_MODULE,
.of_match_table = rt_match_table,
},
.probe = mt6691_i2c_probe,
.remove = mt6691_i2c_remove,
.id_table = rt_dev_id,
};
static int __init mt6691_i2c_init(void)
{
pr_info("%s\n", __func__);
return i2c_add_driver(&mt6691_i2c_driver);
}
subsys_initcall(mt6691_i2c_init);
static void __exit mt6691_i2c_exit(void)
{
i2c_del_driver(&mt6691_i2c_driver);
}
module_exit(mt6691_i2c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jeff Chang <jeff_chang@richtek.com>");
MODULE_VERSION(MT6691_DRV_VERSION);
MODULE_DESCRIPTION("Regulator driver for MT6691");
@@ -0,0 +1,75 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __MT6691_REGULATOR_H
#define __MT6691_REGULATOR_H
#include <linux/mutex.h>
#define MT6691_DRV_VERSION "1.0.0_MTK"
struct mt6691_regulator_info {
struct device *dev;
struct i2c_client *i2c;
struct mutex io_lock;
#ifdef CONFIG_RT_REGMAP
struct rt_regmap_device *regmap_dev;
struct rt_regmap_properties *regmap_props;
#endif /* #ifdef CONFIG_RT_REGMAP */
struct regulator_dev *regulator;
const struct regulator_chip *reg_chip;
int id;
int pin_sel;
};
/* pmic extbuck extern functions */
extern int is_mt6691_exist(void);
/* Custom MT6691_NAME */
#define MT6691_NAME_0 "ext_buck_lp4"
#define MT6691_NAME_1 "ext_buck_lp4x"
#define MT6691_NAME_2 "ext_buck_vmddr"
/* MT6691 operation register */
#define MT6691_REG_VSEL0 (0x00)
#define MT6691_REG_VSEL1 (0x01)
#define MT6691_REG_CTRL1 (0x02)
#define MT6691_REG_ID1 (0x03)
#define MT6691_REG_ID2 (0x04)
#define MT6691_REG_MONITOR (0x05)
#define MT6691_REG_CTRL2 (0x06)
#define MT6691_REG_CTRL3 (0x07)
#define MT6691_REG_CTRL4 (0x08)
/* Hidden mode */
/* #define MT6691_REG_CTRL5 (0x09) */
#if defined(MT6691_NAME_0)
#define MT6691_CMPT_STR_0 "mediatek,ext_buck_lp4"
#define MT6691_VSEL_0 MT6691_REG_VSEL0
#define MT6691_CTRL_0 MT6691_REG_CTRL1
#define MT6691_CTRL_BIT_0 0x01
#define MT6691_EN_0 MT6691_REG_CTRL2
#define MT6691_EN_BIT_0 0x01
#endif
#if defined(MT6691_NAME_1)
#define MT6691_CMPT_STR_1 "mediatek,ext_buck_lp4x"
#define MT6691_VSEL_1 MT6691_REG_VSEL1
#define MT6691_CTRL_1 MT6691_REG_CTRL1
#define MT6691_CTRL_BIT_1 0x02
#define MT6691_EN_1 MT6691_REG_CTRL2
#define MT6691_EN_BIT_1 0x02
#endif
#if defined(MT6691_NAME_2)
#define MT6691_CMPT_STR_2 "mediatek,ext_buck_vmddr"
#define MT6691_VSEL_2 MT6691_REG_VSEL0
#define MT6691_CTRL_2 MT6691_REG_CTRL1
#define MT6691_CTRL_BIT_2 0x01
#define MT6691_EN_2 MT6691_REG_CTRL2
#define MT6691_EN_BIT_2 0x01
#endif
#endif /*--__MT6691_REGULATOR_H--*/
@@ -0,0 +1,283 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include "rt5734-spi.h"
#include <linux/regulator/machine.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/mediatek/mtk_regulator_core.h>
#define RT5734_BUCK_DRV_VERSION "1.0.0_MTK"
#define RT5734_BUCK_MAX 3
struct rt5734_regulator_info {
struct mtk_simple_regulator_desc *mreg_desc;
uint32_t mode_reg;
uint32_t mode_bit;
unsigned char ramp_up_reg;
unsigned char ramp_down_reg;
unsigned char ramp_up_mask;
unsigned char ramp_up_shift;
unsigned char ramp_down_mask;
unsigned char ramp_down_shift;
};
#define RT5734_MIN_VOLTAGE (300000)
#define RT5734_MAX_VOLTAGE (1850000)
#define RT5734_RAMP_RATE (8000) /* uV/us */
/* buck 1 */
#define rt5734_gpu_vol_reg (RT5734_BUCK1_R)
#define rt5734_gpu_vol_mask (0xff)
#define rt5734_gpu_vol_shift (0)
#define rt5734_gpu_enable_reg RT5734_BUCK1_MODE_R
#define rt5734_gpu_enable_bit (0x01)
#define rt5734_gpu_min_uV (RT5734_MIN_VOLTAGE)
#define rt5734_gpu_max_uV (RT5734_MAX_VOLTAGE)
#define rt5734_gpu_id (0)
/* buck 2 */
#define rt5734_proc2_vol_reg (RT5734_BUCK2_R)
#define rt5734_proc2_vol_mask (0xff)
#define rt5734_proc2_vol_shift (0)
#define rt5734_proc2_enable_reg RT5734_BUCK2_MODE_R
#define rt5734_proc2_enable_bit (0x01)
#define rt5734_proc2_min_uV (RT5734_MIN_VOLTAGE)
#define rt5734_proc2_max_uV (RT5734_MAX_VOLTAGE)
#define rt5734_proc2_id (1)
/* buck 3 */
#define rt5734_proc1_vol_reg (RT5734_BUCK3_R)
#define rt5734_proc1_vol_mask (0xff)
#define rt5734_proc1_vol_shift (0)
#define rt5734_proc1_enable_reg RT5734_BUCK3_MODE_R
#define rt5734_proc1_enable_bit (0x01)
#define rt5734_proc1_min_uV (RT5734_MIN_VOLTAGE)
#define rt5734_proc1_max_uV (RT5734_MAX_VOLTAGE)
#define rt5734_proc1_id (2)
static struct mtk_simple_regulator_control_ops rt5734_mreg_ctrl_ops = {
.register_read = rt5734_read_byte,
.register_write = rt5734_write_byte,
.register_update_bits = rt5734_assign_bit,
};
static int rt5734_list_voltage(
struct mtk_simple_regulator_desc *mreg_desc,
unsigned int selector)
{
unsigned int vout = 0;
if (selector > 300)
vout = 1300000 + selector * 10000;
else
vout = mreg_desc->min_uV + 5000 * selector;
if (vout > mreg_desc->max_uV)
return -EINVAL;
return vout;
}
static struct mtk_simple_regulator_desc rt5734_desc_table[] = {
mreg_decl(rt5734_gpu, rt5734_list_voltage,
256, &rt5734_mreg_ctrl_ops),
mreg_decl(rt5734_proc2, rt5734_list_voltage,
256, &rt5734_mreg_ctrl_ops),
mreg_decl(rt5734_proc1, rt5734_list_voltage,
256, &rt5734_mreg_ctrl_ops),
};
#define RT5734_REGULATOR_MODE_REG0 RT5734_BUCK1_MODE_R
#define RT5734_REGULATOR_MODE_REG1 RT5734_BUCK2_MODE_R
#define RT5734_REGULATOR_MODE_REG2 RT5734_BUCK3_MODE_R
#define RT5734_REGULATOR_MODE_MASK0 (0x20)
#define RT5734_REGULATOR_MODE_MASK1 (0x20)
#define RT5734_REGULATOR_MODE_MASK2 (0x20)
#define RT5734_REGULATOR_RAMP_UP_REG0 RT5734_BUCK1_RSPCFG1_R
#define RT5734_REGULATOR_RAMP_UP_REG1 RT5734_BUCK2_RSPCFG1_R
#define RT5734_REGULATOR_RAMP_UP_REG2 RT5734_BUCK3_RSPCFG1_R
#define RT5734_REGULATOR_RAMP_DOWN_REG0 RT5734_BUCK1_RSPCFG1_R
#define RT5734_REGULATOR_RAMP_DOWN_REG1 RT5734_BUCK2_RSPCFG1_R
#define RT5734_REGULATOR_RAMP_DOWN_REG2 RT5734_BUCK3_RSPCFG1_R
#define RT5734_REGULATOR_DECL(_id) \
{ \
.mreg_desc = &rt5734_desc_table[_id], \
.mode_reg = RT5734_REGULATOR_MODE_REG##_id, \
.mode_bit = RT5734_REGULATOR_MODE_MASK##_id, \
.ramp_up_reg = RT5734_REGULATOR_RAMP_UP_REG##_id, \
.ramp_down_reg = RT5734_REGULATOR_RAMP_DOWN_REG##_id, \
.ramp_up_mask = (0x70), \
.ramp_down_mask = (0x07), \
.ramp_up_shift = 4, \
.ramp_down_shift = 0, \
}
static struct rt5734_regulator_info rt5734_regulator_infos[] = {
RT5734_REGULATOR_DECL(0), /* GPU */
RT5734_REGULATOR_DECL(1), /* PROC2 */
RT5734_REGULATOR_DECL(2), /* PROC1 */
};
static struct rt5734_regulator_info *rt5734_find_regulator_info(int id)
{
struct rt5734_regulator_info *info;
int i;
for (i = 0; i < ARRAY_SIZE(rt5734_regulator_infos); i++) {
info = &rt5734_regulator_infos[i];
if (info->mreg_desc->rdesc.id == id)
return info;
}
return NULL;
}
static int rt5734_set_mode(
struct mtk_simple_regulator_desc *mreg_desc, unsigned int mode)
{
struct rt5734_regulator_info *info =
rt5734_find_regulator_info(mreg_desc->rdesc.id);
int ret;
switch (mode) {
case REGULATOR_MODE_FAST: /* force pwm mode */
ret = rt5734_set_bit(mreg_desc->client,
info->mode_reg, info->mode_bit);
break;
case REGULATOR_MODE_NORMAL: /* auto mode */
default:
ret = rt5734_clr_bit(mreg_desc->client,
info->mode_reg, info->mode_bit);
break;
}
return ret;
}
static unsigned int rt5734_get_mode(
struct mtk_simple_regulator_desc *mreg_desc)
{
struct rt5734_regulator_info *info =
rt5734_find_regulator_info(mreg_desc->rdesc.id);
int ret;
uint32_t regval = 0;
ret = rt5734_read_byte(mreg_desc->client, info->mode_reg, &regval);
if (ret < 0) {
RT5734_pr_notice("%s read mode fail\n", __func__);
return ret;
}
if (regval & info->mode_bit)
return REGULATOR_MODE_FAST;
return REGULATOR_MODE_NORMAL;
}
static struct mtk_simple_regulator_ext_ops rt5734_regulator_ext_ops = {
.get_mode = rt5734_get_mode,
.set_mode = rt5734_set_mode,
};
static struct regulator_init_data
rt5734_buck_init_data[RT5734_BUCK_MAX] = {
{
.constraints = {
.name = "ext_buck_gpu",
.min_uV = RT5734_MIN_VOLTAGE,
.max_uV = RT5734_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE,
.always_on = 1,
},
},
{
.constraints = {
.name = "ext_buck_proc2",
.min_uV = RT5734_MIN_VOLTAGE,
.max_uV = RT5734_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE,
.always_on = 1,
},
},
{
.constraints = {
.name = "ext_buck_proc1",
.min_uV = RT5734_MIN_VOLTAGE,
.max_uV = RT5734_MAX_VOLTAGE,
.valid_modes_mask =
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST),
.valid_ops_mask =
REGULATOR_CHANGE_MODE|REGULATOR_CHANGE_VOLTAGE,
.always_on = 1,
},
},
};
static int rt5734_set_ramp_dly(struct mtk_simple_regulator_desc *mreg_desc,
int ramp_dly)
{
struct rt5734_regulator_info *info =
rt5734_find_regulator_info(mreg_desc->rdesc.id);
int ret = 0;
unsigned char regval;
if (ramp_dly > 63)
regval = 63;
else
regval = ramp_dly;
ret = rt5734_assign_bit(mreg_desc->client, info->ramp_up_reg,
info->ramp_up_mask, regval << info->ramp_up_shift);
ret = rt5734_assign_bit(mreg_desc->client, info->ramp_down_reg,
info->ramp_down_mask, regval << info->ramp_down_shift);
return ret;
}
int rt5734_regulator_init(struct rt5734_chip *chip)
{
int ret = 0, i = 0;
if (chip == NULL) {
RT5734_pr_notice("%s Null chip info\n", __func__);
return -1;
}
for (i = 0; i < ARRAY_SIZE(rt5734_desc_table); i++) {
rt5734_desc_table[i].client = chip->spi;
rt5734_desc_table[i].def_init_data =
&rt5734_buck_init_data[i];
ret = mtk_simple_regulator_register(&rt5734_desc_table[i],
chip->dev, &rt5734_regulator_ext_ops, NULL);
if (ret < 0) {
RT5734_pr_notice(
"%s register mtk simple regulator fail\n"
, __func__);
}
ret = rt5734_set_ramp_dly(
&rt5734_desc_table[i], RT5734_RAMP_RATE);
if (ret < 0) {
RT5734_pr_notice("%s (%s)set ramp dly fail\n", __func__,
rt5734_desc_table[i].rdesc.name);
}
}
pr_info("%s Successfully\n", __func__);
return 0;
}
int rt5734_regulator_deinit(struct rt5734_chip *chip)
{
int ret = 0, i = 0;
for (i = 0; i < ARRAY_SIZE(rt5734_desc_table); i++) {
ret |= mtk_simple_regulator_unregister(
&rt5734_desc_table[i]);
}
return ret;
}
@@ -0,0 +1,512 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/spi/spi.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <mtk_spi.h>
#include <linux/delay.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#ifdef CONFIG_RT_REGMAP
#include <mt-plat/rt-regmap.h>
#endif /* CONFIG_RT_REGMAP */
#include "rt5734-spi.h"
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#include <mach/mtk_pmic_ipi.h>
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
#define RT5734_DRV_VERSION "1.0.0_MTK"
#define RT5734_IRQ_ENABLE 0
static int rt5734_read_device(void *client, u32 addr, int len, void *dst)
{
int ret;
#ifdef CONIFG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
return 0;
#else
struct spi_device *spi = (struct spi_device *)client;
struct spi_transfer xfer = {0,}; /* must init spi_transfer here */
struct spi_message msg;
u32 tx_buf;
u32 rx_buf;
if (len != 1) {
pr_notice("%s not support multi read now\n", __func__);
return -EINVAL;
}
/* LSM first, TX: buf, size, reg, 89 */
tx_buf = 0x00010080;
rx_buf = 0xffffffff;
tx_buf |= addr << 8;
xfer.tx_buf = &tx_buf;
xfer.rx_buf = &rx_buf;
xfer.len = 4;
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
ret = spi_sync(spi, &msg);
if (ret < 0 || rx_buf == 0xffffffff)
return ret;
*(unsigned char *)dst = (rx_buf & 0xff000000) >> 24;
#if 0
pr_info("%s addr 0x%02x = 0x%02x\n", __func__, addr, *val);
pr_info("%s tx_buf = 0x%08x\n", __func__, tx_buf);
pr_info("%s rx_buf = 0x%08x\n", __func__, rx_buf);
#endif
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
return ret;
}
int rt5734_write_device(void *client,
uint32_t addr, int len, const void *src)
{
int ret;
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support sspm\n", __func__);
return 0;
#else
struct spi_device *spi = (struct spi_device *)client;
struct spi_transfer xfer = {0,}; /* must init spi_transfer here */
struct spi_message msg;
unsigned char regval;
u32 tx_buf;
u32 rx_buf;
if (len != 1) {
pr_notice("%s not support multi write now\n", __func__);
return -EINVAL;
}
tx_buf = 0x00010000;
rx_buf = 0xffffffff;
regval = *(unsigned char *)src;
tx_buf |= ((regval << 24) | (addr << 8));
xfer.tx_buf = &tx_buf;
xfer.rx_buf = &rx_buf;
xfer.len = 4;
spi_message_init(&msg);
spi_message_add_tail(&xfer, &msg);
ret = spi_sync(spi, &msg);
if (ret < 0 || rx_buf == 0xffffffff)
return ret;
#if 0
pr_info("%s addr 0x%02x = 0x%02x\n", __func__, addr, value);
pr_info("%s tx_buf = 0x%08x\n", __func__, tx_buf);
pr_info("%s rx_buf = 0x%08x\n", __func__, rx_buf);
#endif
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
return ret;
}
#ifdef CONFIG_RT_REGMAP
RT_REG_DECL(RT5734_CHIPNAME_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_FLT_RECORDTEMP_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_IRQ_MASK_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK1_DCM_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK1_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK1_MODE_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK1_RSPCFG1_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK2_DCM_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK2_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK2_MODE_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK2_RSPCFG1_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK3_DCM_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK3_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK3_MODE_R, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5734_BUCK3_RSPCFG1_R, 1, RT_VOLATILE, {});
static const rt_register_map_t rt5734_regmap[] = {
RT_REG(RT5734_CHIPNAME_R),
RT_REG(RT5734_FLT_RECORDTEMP_R),
RT_REG(RT5734_IRQ_MASK_R),
RT_REG(RT5734_BUCK1_DCM_R),
RT_REG(RT5734_BUCK1_R),
RT_REG(RT5734_BUCK1_MODE_R),
RT_REG(RT5734_BUCK1_RSPCFG1_R),
RT_REG(RT5734_BUCK2_DCM_R),
RT_REG(RT5734_BUCK2_R),
RT_REG(RT5734_BUCK2_MODE_R),
RT_REG(RT5734_BUCK2_RSPCFG1_R),
RT_REG(RT5734_BUCK3_DCM_R),
RT_REG(RT5734_BUCK3_R),
RT_REG(RT5734_BUCK3_MODE_R),
RT_REG(RT5734_BUCK3_RSPCFG1_R),
};
static struct rt_regmap_properties rt5734_regmap_props = {
.name = "rt5734",
.aliases = "rt5734",
.register_num = ARRAY_SIZE(rt5734_regmap),
.rm = rt5734_regmap,
.rt_regmap_mode = RT_CACHE_DISABLE,
};
static struct rt_regmap_fops rt5734_regmap_fops = {
.read_device = rt5734_read_device,
.write_device = rt5734_write_device,
};
#endif /* CONFIG_RT_REGMAP */
int rt5734_read_byte(void *client, uint32_t addr, uint32_t *value)
{
int ret;
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
ret = 0;
#else
struct spi_device *spi = (struct spi_device *)client;
struct rt5734_chip *chip = spi_get_drvdata(spi);
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_read(chip->regmap_dev, addr, 1, value);
#else
ret = rt5734_read_device(chip->spi, addr, 1, value);
#endif /* CONFIG_RT_REGMAP */
if (ret < 0)
pr_notice("%s read addr0x%02x fail\n", __func__, addr);
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
return ret;
}
EXPORT_SYMBOL(rt5734_read_byte);
int rt5734_write_byte(void *client, uint32_t addr, uint32_t data)
{
int ret = 0;
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
ret = 0;
#else
struct spi_device *spi = (struct spi_device *)client;
struct rt5734_chip *chip = spi_get_drvdata(spi);
#ifdef CONFIG_RT_REGMAP
ret = rt_regmap_block_write(chip->regmap_dev, addr, 1, &data);
#else
ret = rt5734_write_device(chip->spi, addr, 1, &data);
#endif /* CONFIG_RT_REGMAP */
if (ret < 0)
pr_notice("%s write addr0x%02x fail\n", __func__, addr);
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
return ret;
}
int rt5734_assign_bit(void *client,
uint32_t reg, uint32_t mask, uint32_t data)
{
int ret = 0;
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
pr_notice("%s not support for sspm\n", __func__);
return 0;
#else
struct spi_device *spi = (struct spi_device *)client;
struct rt5734_chip *ri = spi_get_drvdata(spi);
unsigned char tmp = 0;
uint32_t regval = 0;
mutex_lock(&ri->io_lock);
ret = rt5734_read_byte(spi, reg, &regval);
if (ret < 0) {
pr_notice("%s fail reg0x%02x data0x%02x\n",
__func__, reg, data);
goto OUT_ASSIGN;
}
tmp = ((regval & 0xff) & ~mask);
tmp |= (data & mask);
ret = rt5734_write_byte(spi, reg, tmp);
if (ret < 0)
pr_notice("%s fail reg0x%02x data0x%02x\n",
__func__, reg, tmp);
OUT_ASSIGN:
mutex_unlock(&ri->io_lock);
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
return ret;
}
EXPORT_SYMBOL(rt5734_assign_bit);
static struct mt_chip_conf rt5734_spi_config = {
/* setuptime, holdtime --> timing for waveform of SPI */
.setuptime = 3,
.holdtime = 3,
/* high_time, low_time --> set SCK */
.high_time = 10,
.low_time = 10,
/* CS pin idle time */
.cs_idletime = 2,
/* cpol, cpha -->set type */
.cpol = 0,
.cpha = 0,
/* rx_mlsb, tx_mlsb --> MSB first or not */
.rx_mlsb = 1,
.tx_mlsb = 1,
/* tx_endian, rx_endian -->
* Defines whether to reverse the endian order
*/
.tx_endian = 0,
.rx_endian = 0,
/* com_mod --> FIFO/DMA mode */
.com_mod = FIFO_TRANSFER,
/* pause --> if want to always let CS active, set this flag to 1*/
.pause = 1,
/* tckdly --> tune timing */
.tckdly = 0,
/* ?? */
.ulthgh_thrsh = 0,
.cs_pol = 0,
.sample_sel = 0,
.finish_intr = 1,
.deassert = 0,
.ulthigh = 0,
};
static void rt5734_spi_init(struct spi_device *spi)
{
pr_info("%s inited\n", __func__);
spi->bits_per_word = 32;
spi->controller_data = &rt5734_spi_config;
mdelay(100);
}
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
static void rt5734_reg_init(struct spi_device *spi)
{
}
static int rt5734_check_id(struct spi_device *spi)
{
int ret;
unsigned char data;
ret = rt5734_read_device(spi, RT5734_CHIPNAME_R, 1, &data);
if (ret < 0) {
pr_notice("%s IO fail\n", __func__);
return -EIO;
}
if (data != RT5734_CHIPNAME) {
pr_notice("%s ID(0x%02x) not match\n", __func__, data);
return -EINVAL;
}
return 0;
}
#endif /* CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
#if RT5734_IRQ_ENABLE
enum {
RT5734_EVT_OT_SHUTDOWN_FALLING = 1,
RT5734_EVT_OT_SHUTDOWN_RISING,
RT5734_EVT_MAX,
};
static void rt5734_irq_evt_handler(void *info, int eventno)
{
struct rt5734_chip *chip = info;
dev_info(chip->dev, "%s eventno = %d\n", __func__, eventno);
switch (eventno) {
case RT5734_EVT_OT_SHUTDOWN_RISING:
pr_notice("%s Enter OT Shutdown\n", __func__);
break;
case RT5734_EVT_OT_SHUTDOWN_FALLING:
pr_notice("%s Exit OT Shutdown\n", __func__);
break;
}
}
typedef void (*rt_irq_handler)(void *info, int eventno);
static rt_irq_handler rt5734_handler[RT5734_EVT_MAX] = {
[RT5734_EVT_OT_SHUTDOWN_RISING] = rt5734_irq_evt_handler,
[RT5734_EVT_OT_SHUTDOWN_FALLING] = rt5734_irq_evt_handler,
};
static irqreturn_t rt5734_irq_handler(int irqno, void *param)
{
struct rt5734_chip *chip = param;
uint32_t regval = 0;
int ret, i;
ret = rt5734_read_byte(chip->spi,
RT5734_FLT_RECORDTEMP_R, &regval);
if (ret < 0) {
pr_notice("%s get irq regval fail\n", __func__);
return IRQ_HANDLED;
}
if (regval) {
pr_info("%s thermal event 0x%02x\n", __func__, regval);
for (i = 0; i < RT5734_EVT_MAX; i++) {
if ((regval & (1 << i)) && rt5734_handler[i])
rt5734_handler[i](chip, i);
}
}
return IRQ_HANDLED;
}
static int rt5734_init_irq(struct rt5734_chip *chip, struct device *dev)
{
struct device_node *np = dev->of_node;
int ret;
uint32_t regval = 0;
if (np)
chip->irq = irq_of_parse_and_map(np, 0);
else {
pr_notice("%s no dts node\n", __func__);
return -ENODEV;
}
/* mask IRQ first */
ret = rt5734_write_byte(chip->spi, RT5734_IRQ_MASK_R, 0x83);
if (ret < 0) {
pr_notice("%s mask IRQ fail\n", __func__);
return -EINVAL;
}
/* clear IRQ */
rt5734_read_byte(chip->spi, RT5734_FLT_RECORDTEMP_R, &regval);
ret = devm_request_threaded_irq(chip->dev, chip->irq,
rt5734_irq_handler, NULL, IRQF_TRIGGER_FALLING|IRQF_ONESHOT,
"rt5734-irq", chip);
if (ret < 0) {
pr_notice("%s request irq fail\n", __func__);
return -EINVAL;
}
/* unmask IRQ */
ret = rt5734_write_byte(chip->spi, RT5734_IRQ_MASK_R, 0x00);
if (ret < 0) {
pr_notice("%s unmask IRQ fail\n", __func__);
return -EINVAL;
}
enable_irq_wake(chip->irq);
return 0;
}
#endif /* if RT5734_IRQ_ENABLE */
static int rt5734_spi_probe(struct spi_device *spi)
{
struct rt5734_chip *chip;
int ret;
pr_info("%s\n", __func__);
chip = devm_kzalloc(&spi->dev,
sizeof(struct rt5734_chip), GFP_KERNEL);
chip->spi = spi;
chip->dev = &spi->dev;
mutex_init(&chip->io_lock);
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
spi_set_drvdata(spi, chip);
#else
pr_info("%s SSPM not need spi_set_drvdata\n", __func__);
#endif /* if not CONFIG_MTK_TINYSYS_SSPM_SUPPORT */
rt5734_spi_init(spi);
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
ret = rt5734_check_id(spi);
if (ret < 0)
return ret;
#else
pr_info("%s SSPM not need check_id\n", __func__);
#endif /*-- !CONFIG_MTK_TINYSYS_SSPM_SUPPORT--*/
#ifdef CONFIG_RT_REGMAP
chip->regmap_dev = rt_regmap_device_register_ex(&rt5734_regmap_props,
&rt5734_regmap_fops, &spi->dev, spi, -1, chip);
if (!chip->regmap_dev) {
pr_notice("%s register regmap fail\n", __func__);
return -EINVAL;
}
#endif /* #ifdef CONFIG_RT_REGMAP */
#ifndef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
rt5734_reg_init(spi);
#else
pr_info("%s SSPM not need reg_init\n", __func__);
#endif /*-- !CONFIG_MTK_TINYSYS_SSPM_SUPPORT--*/
ret = rt5734_regulator_init(chip);
if (ret < 0) {
RT5734_pr_notice("%s regulator init fail\n", __func__);
return -EINVAL;
}
pr_info("%s --OK!!--\n", __func__);
return 0;
#if RT5734_IRQ_ENABLE
fail_irq:
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(chip->regmap_dev);
#endif /* CONFIG_RT_REGMAP */
#endif /* CONFIG_IRQ_ENABLE */
return ret;
}
static int rt5734_spi_remove(struct spi_device *spi)
{
struct rt5734_chip *chip = spi_get_drvdata(spi);
if (chip) {
rt5734_regulator_deinit(chip);
mutex_destroy(&chip->io_lock);
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(chip->regmap_dev);
#endif /* #ifdef CONFIG_RT_REGMAP */
}
return 0;
}
static const struct of_device_id rt5734_id_table[] = {
{.compatible = "mediatek,rt5734",},
};
static struct spi_driver rt5734_spi_driver = {
.driver = {
.name = "rt5734",
.bus = &spi_bus_type,
.owner = THIS_MODULE,
.of_match_table = rt5734_id_table,
},
.probe = rt5734_spi_probe,
.remove = rt5734_spi_remove,
};
static int __init rt5734_init(void)
{
pr_notice("%s ver(%s)\n", __func__, RT5734_DRV_VERSION);
return spi_register_driver(&rt5734_spi_driver);
}
static void __exit rt5734_exit(void)
{
spi_unregister_driver(&rt5734_spi_driver);
}
subsys_initcall(rt5734_init);
module_exit(rt5734_exit);
MODULE_DESCRIPTION("RT5734 Regulator Driver");
MODULE_VERSION(RT5734_DRV_VERSION);
MODULE_AUTHOR("Sakya <jeff_chang@richtek.com>");
MODULE_LICENSE("GPL");
@@ -0,0 +1,69 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __LINUX_RT5734_SPI_H
#define __LINUX_RT5734_SPI_H
#include <linux/mutex.h>
struct rt5734_chip {
struct spi_device *spi;
struct device *dev;
struct mutex io_lock;
#ifdef CONFIG_RT_REGMAP
struct rt_regmap_device *regmap_dev;
#endif /* CONFIG_RT_REGMAP */
int irq;
};
#define RT5734_CHIPNAME (0x01)
/* register map */
#define RT5734_CHIPNAME_R (0x01)
#define RT5734_FLT_RECORDTEMP_R (0x13)
#define RT5734_IRQ_MASK_R (0x32)
#define RT5734_BUCK1_DCM_R (0x3E)
#define RT5734_BUCK1_R (0x48)
#define RT5734_BUCK1_MODE_R (0x49)
#define RT5734_BUCK1_RSPCFG1_R (0x54)
#define RT5734_BUCK2_DCM_R (0x5B)
#define RT5734_BUCK2_R (0x62)
#define RT5734_BUCK2_MODE_R (0x63)
#define RT5734_BUCK2_RSPCFG1_R (0x6E)
#define RT5734_BUCK3_DCM_R (0x75)
#define RT5734_BUCK3_R (0x7C)
#define RT5734_BUCK3_MODE_R (0x7D)
#define RT5734_BUCK3_RSPCFG1_R (0x88)
/* 6.Interrupt : OTP/OCP/OV */
#define FLT_RECORDTEMP_FLT_TEMPSDR_M (0x08)
#define FLT_RECORDTEMP_FLT_TEMPWARNR_M (0x04)
#define FLT_RECORDTEMP_FLT_TEMPWARNF_M (0x02)
#define FLT_RECORDTEMP_FLT_TEMPSDF_M (0x01)
#define FLT_RECORDBUCK1_FLT_BUCK1_WOC_M (0x40)
#define FLT_RECORDBUCK1_FLT_BUCK1_OV_M (0x20)
#define FLT_RECORDBUCK1_FLT_BUCK1_UV_M (0x10)
#define FLT_RECORDBUCK2_FLT_BUCK2_WOC_M (0x40)
#define FLT_RECORDBUCK2_FLT_BUCK2_OV_M (0x20)
#define FLT_RECORDBUCK2_FLT_BUCK2_UV_M (0x10)
extern int rt5734_read_byte(void *client, uint32_t addr, uint32_t *val);
extern int rt5734_write_byte(void *client, uint32_t addr, uint32_t value);
extern int rt5734_assign_bit(void *client, uint32_t reg,
uint32_t mask, uint32_t data);
extern int rt5734_regulator_init(struct rt5734_chip *chip);
extern int rt5734_regulator_deinit(struct rt5734_chip *chip);
#define rt5734_set_bit(spi, reg, mask) \
rt5734_assign_bit(spi, reg, mask, mask)
#define rt5734_clr_bit(spi, reg, mask) \
rt5734_assign_bit(spi, reg, mask, 0x00)
#define RT5734_INFO(format, args...) pr_info(format, ##args)
#define RT5734_pr_notice(format, args...) pr_notice(format, ##args)
#endif /* __LINUX_RT5734_SPI_H */
@@ -0,0 +1,527 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/version.h>
#include <linux/slab.h>
#include <linux/of.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#ifdef CONFIG_RT_REGMAP
#include <mt-plat/rt-regmap.h>
#endif /* CONFIG_RT_REGMAP */
#include <mt-plat/upmu_common.h>
#include "rt5738-regulator.h"
static const char * const rt5738_text[] = {
"rt57380",
"rt57381",
"rt57382",
};
/*
* Exported API
*/
static int g_is_rt5738_exist;
int is_rt5738_exist(void)
{
#if defined(RT5738_IS_EXIST_NAME)
struct regulator *reg;
reg = regulator_get(NULL, RT5738_IS_EXIST_NAME);
pr_info("%s: regulator_get=%s\n", __func__, RT5738_IS_EXIST_NAME);
if (reg == NULL)
return 0;
regulator_put(reg);
return 1;
#else
pr_notice("g_is_rt5738_exist=%d\n", g_is_rt5738_exist);
return g_is_rt5738_exist;
#endif
}
static int rt5738_read_device(void *client, u32 addr,
int len, void *dst)
{
struct i2c_client *i2c = (struct i2c_client *)client;
return i2c_smbus_read_i2c_block_data(i2c, addr, len, dst);
}
static int rt5738_write_device(void *client, u32 addr,
int len, const void *src)
{
struct i2c_client *i2c = (struct i2c_client *)client;
return i2c_smbus_write_i2c_block_data(i2c, addr, len, src);
}
#ifdef CONFIG_RT_REGMAP
RT_REG_DECL(RT5738_REG_VSEL0, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(RT5738_REG_VSEL1, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(RT5738_REG_CTRL1, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(RT5738_REG_ID1, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5738_REG_ID2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5738_REG_MONITOR, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5738_REG_CTRL2, 1, RT_VOLATILE, {});
RT_REG_DECL(RT5738_REG_CTRL3, 1, RT_WBITS_WR_ONCE, {});
RT_REG_DECL(RT5738_REG_CTRL4, 1, RT_WBITS_WR_ONCE, {});
static const rt_register_map_t rt5738_regmap[] = {
RT_REG(RT5738_REG_VSEL0),
RT_REG(RT5738_REG_VSEL1),
RT_REG(RT5738_REG_CTRL1),
RT_REG(RT5738_REG_ID1),
RT_REG(RT5738_REG_ID2),
RT_REG(RT5738_REG_MONITOR),
RT_REG(RT5738_REG_CTRL2),
RT_REG(RT5738_REG_CTRL3),
RT_REG(RT5738_REG_CTRL4),
};
static struct rt_regmap_fops rt5738_regmap_fops = {
.read_device = rt5738_read_device,
.write_device = rt5738_write_device,
};
#endif /* CONFIG_RT_REGMAP */
int rt5738_read_byte(void *client,
uint32_t addr, uint32_t *val)
{
int ret = 0;
struct i2c_client *i2c = (struct i2c_client *)client;
ret = rt5738_read_device(i2c, addr, 1, val);
if (ret < 0)
pr_notice("%s read 0x%02x fail\n", __func__, addr);
return ret;
}
int rt5738_write_byte(void *client,
uint32_t addr, uint32_t value)
{
int ret = 0;
struct i2c_client *i2c = (struct i2c_client *)client;
ret = rt5738_write_device(i2c, addr, 1, &value);
if (ret < 0)
pr_notice("%s write 0x%02x fail\n", __func__, addr);
return ret;
}
int rt5738_assign_bit(void *client, uint32_t reg,
uint32_t mask, uint32_t data)
{
struct i2c_client *i2c = (struct i2c_client *)client;
struct rt5738_regulator_info *ri = i2c_get_clientdata(i2c);
unsigned char tmp = 0;
uint32_t regval = 0;
int ret = 0;
mutex_lock(&ri->io_lock);
ret = rt5738_read_byte(i2c, reg, &regval);
if (ret < 0) {
pr_notice("%s read fail reg0x%02x data0x%02x\n",
__func__, reg, data);
goto OUT_ASSIGN;
}
tmp = ((regval & 0xff) & ~mask);
tmp |= (data & mask);
ret = rt5738_write_byte(i2c, reg, tmp);
if (ret < 0)
pr_notice("%s write fail reg0x%02x data0x%02x\n",
__func__, reg, tmp);
OUT_ASSIGN:
mutex_unlock(&ri->io_lock);
return ret;
}
#define rt5738_set_bit(i2c, reg, mask) \
rt5738_assign_bit(i2c, reg, mask, mask)
#define rt5738_clr_bit(i2c, reg, mask) \
rt5738_assign_bit(i2c, reg, mask, 0x00)
static int rt5738_regmap_init(struct rt5738_regulator_info *info)
{
#ifdef CONFIG_RT_REGMAP
info->regmap_props = devm_kzalloc(info->dev,
sizeof(struct rt_regmap_properties), GFP_KERNEL);
info->regmap_props->name = rt5738_text[info->id];
info->regmap_props->aliases = rt5738_text[info->id];
info->regmap_props->register_num = ARRAY_SIZE(rt5738_regmap);
info->regmap_props->rm = rt5738_regmap;
info->regmap_props->rt_regmap_mode = RT_CACHE_WR_THROUGH;
info->regmap_dev = rt_regmap_device_register(info->regmap_props,
&rt5738_regmap_fops, info->dev, info->i2c, info);
if (!info->regmap_dev)
return -EINVAL;
#endif /* CONFIG_RT_REGMAP */
return 0;
}
static struct regulator_chip rt5738_datas[] = {
{
.vol_reg = RT5738_VSEL_0,
.mode_reg = RT5738_CTRL_0,
.mode_bit = RT5738_CTRL_BIT_0,
.enable_reg = RT5738_EN_0,
.enable_bit = RT5738_EN_BIT_0,
},
{
.vol_reg = RT5738_VSEL_1,
.mode_reg = RT5738_CTRL_1,
.mode_bit = RT5738_CTRL_BIT_1,
.enable_reg = RT5738_EN_1,
.enable_bit = RT5738_EN_BIT_1,
},
#if defined(RT5738_NAME_2)
{
.vol_reg = RT5738_VSEL_2,
.mode_reg = RT5738_CTRL_2,
.mode_bit = RT5738_CTRL_BIT_2,
.enable_reg = RT5738_EN_2,
.enable_bit = RT5738_EN_BIT_2,
},
#endif
};
static int rt5738_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, unsigned int *selector)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
if (min_uV < 1300000)
*selector = (min_uV - 300000) / 5000;
else
*selector = (min_uV - 1300000) / 10000 + 200;
if (*selector > 255)
*selector = 255;
return rt5738_write_byte(info->i2c, chip->vol_reg, *selector);
}
static int rt5738_get_voltage(struct regulator_dev *rdev)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
int ret;
uint32_t reg_val = 0;
ret = rt5738_read_byte(info->i2c, chip->vol_reg, &reg_val);
if (ret < 0) {
pr_notice("%s read voltage fail\n", __func__);
return ret;
}
if (reg_val > 200)
return 1300000 + (reg_val - 200) * 10000;
return 300000 + reg_val * 5000;
}
static int rt5738_set_mode(struct regulator_dev *rdev, unsigned int mode)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
int ret;
switch (mode) {
case REGULATOR_MODE_FAST: /* force pwm mode */
ret = rt5738_set_bit(info->i2c, chip->mode_reg, chip->mode_bit);
break;
case REGULATOR_MODE_NORMAL:
default:
ret = rt5738_clr_bit(info->i2c, chip->mode_reg, chip->mode_bit);
break;
}
return ret;
}
static unsigned int rt5738_get_mode(struct regulator_dev *rdev)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
int ret;
uint32_t regval = 0;
ret = rt5738_read_byte(info->i2c, chip->mode_reg, &regval);
if (ret < 0) {
pr_notice("%s read mode fail\n", __func__);
return ret;
}
if (regval & chip->mode_bit)
return REGULATOR_MODE_FAST;
return REGULATOR_MODE_NORMAL;
}
static int rt5738_enable(struct regulator_dev *rdev)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
return rt5738_set_bit(info->i2c, chip->enable_reg, chip->enable_bit);
}
static int rt5738_disable(struct regulator_dev *rdev)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
if (rdev->use_count == 0) {
pr_info("ext_buck should not be disable (use_count=%d)\n"
, rdev->use_count);
return -1;
}
return rt5738_clr_bit(info->i2c, chip->enable_reg, chip->enable_bit);
}
static int rt5738_is_enabled(struct regulator_dev *rdev)
{
struct rt5738_regulator_info *info = rdev_get_drvdata(rdev);
struct regulator_chip *chip = info->reg_chip;
int ret;
uint32_t reg_val;
ret = rt5738_read_byte(info->i2c, chip->enable_reg, &reg_val);
if (ret < 0)
return ret;
return (reg_val&chip->enable_bit) ? 1 : 0;
}
static struct regulator_ops rt5738_regulator_ops = {
.set_voltage = rt5738_set_voltage,
.get_voltage = rt5738_get_voltage,
.set_mode = rt5738_set_mode,
.get_mode = rt5738_get_mode,
.enable = rt5738_enable,
.disable = rt5738_disable,
.is_enabled = rt5738_is_enabled,
};
#define REG_DESC(_name, _id) { \
.id = _id, \
.name = _name, \
.n_voltages = 201, \
.ops = &rt5738_regulator_ops, \
.type = REGULATOR_VOLTAGE, \
.owner = THIS_MODULE, \
}
static struct regulator_desc rt5738_regulator_desc[] = {
REG_DESC("rt5738_buck0", 0),
REG_DESC("rt5738_buck1", 1),
#if defined(RT5738_NAME_2)
REG_DESC("rt5738_buck2", 2),
#endif
};
static int rt5738_parse_dt(
struct rt5738_regulator_info *info, struct device *dev)
{
struct device_node *np = dev->of_node;
u32 val;
int ret;
if (!np) {
pr_notice("%s cant find node (0x%02x)\n",
__func__, info->i2c->addr);
return 0;
}
ret = of_property_read_u32(np, "vsel_pin", &val);
if (ret >= 0) {
pr_info("%s set vsel_pin(%x)\n", __func__, val);
info->pin_sel = val;
info->id = val;
} else {
pr_notice("%s use chip default vsel_pin(0)\n", __func__);
info->pin_sel = 0;
info->id = 0;
}
return ret;
}
struct regulator_dev *rt5738_regulator_register(
struct regulator_desc *desc,
struct device *dev,
struct regulator_init_data *init_data,
void *driver_data)
{
struct regulator_config config = {
.dev = dev,
.init_data = init_data,
.driver_data = driver_data,
};
return regulator_register(desc, &config);
}
static int rt5738_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct rt5738_regulator_info *info;
struct regulator_init_data *init_data = NULL;
int ret;
pr_info("%s ver(%s) slv(0x%02x)\n",
__func__, RT5738_DRV_VERSION, i2c->addr);
switch (i2c->addr) {
case 0x50: /* RT5738_A */
case 0x57: /* RT5738_B */
return -ENODEV;
case 0x52: /* RT5738_C */
case 0x51: /* RT5738_G */
case 0x53: /* RT5738_H */
break;
case 0x55: /* RT5738_F */
return -ENODEV;
default:
pr_notice("%s invalid Slave Addr\n", __func__);
return -ENODEV;
}
info = devm_kzalloc(&i2c->dev,
sizeof(struct rt5738_regulator_info), GFP_KERNEL);
if (!info)
return -ENOMEM;
ret = rt5738_parse_dt(info, &i2c->dev);
if (ret < 0) {
pr_notice("%s parse dt (0x%02x) fail\n", __func__, i2c->addr);
return -EINVAL;
}
init_data = of_get_regulator_init_data(&i2c->dev,
i2c->dev.of_node,
NULL);
if (init_data) {
dev_info(&i2c->dev,
"regulator_name = %s, min_uV =%d, max_uV = %d\n"
, init_data->constraints.name
, init_data->constraints.min_uV
, init_data->constraints.max_uV);
pr_info("rt5738 regulator_name = %s, min_uV =%d, max_uV = %d\n"
, init_data->constraints.name
, init_data->constraints.min_uV
, init_data->constraints.max_uV);
} else {
dev_info(&i2c->dev, "%s: no init data\n", __func__);
return -EINVAL;
}
info->i2c = i2c;
info->dev = &i2c->dev;
info->desc = &rt5738_regulator_desc[info->pin_sel];
info->reg_chip = &rt5738_datas[info->pin_sel];
mutex_init(&info->io_lock);
i2c_set_clientdata(i2c, info);
ret = rt5738_regmap_init(info);
if (ret < 0) {
pr_notice("%s rt5738 regmap init fail\n", __func__);
return -EINVAL;
}
#if 1
g_is_rt5738_exist = 0;
if (rt5738_read_byte(info->i2c, RT5738_REG_MONITOR, &ret) >= 0)
g_is_rt5738_exist = 1;
pr_notice("i2c_addr=%d ret=%d g_is_rt5738_exist=%d\n"
, i2c->addr
, ret
, g_is_rt5738_exist);
return 0;
#else
info->regulator = rt5738_regulator_register(info->desc,
&i2c->dev,
init_data,
info);
if (!info->regulator) {
pr_notice("%s rt5738 register regulator fail\n", __func__);
return -EINVAL;
}
info->regulator->constraints->valid_modes_mask |=
(REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST);
info->regulator->constraints->valid_ops_mask |=
REGULATOR_CHANGE_MODE;
pr_info("%s Successfully\n", __func__);
return 0;
#endif
}
static int rt5738_i2c_remove(struct i2c_client *i2c)
{
struct rt5738_regulator_info *info = i2c_get_clientdata(i2c);
if (info) {
regulator_unregister(info->regulator);
#ifdef CONFIG_RT_REGMAP
rt_regmap_device_unregister(info->regmap_dev);
#endif /* CONFIG_RT_REGMAP */
mutex_destroy(&info->io_lock);
}
return 0;
}
/* Must reserve one empty object at the end */
static const struct of_device_id rt_match_table[] = {
{ .compatible = RT5738_CMPT_STR_0, },
{ .compatible = RT5738_CMPT_STR_1, },
#if defined(RT5738_NAME_2)
{ .compatible = RT5738_CMPT_STR_2, },
#endif
{ },
};
static const struct i2c_device_id rt_dev_id[] = {
{"rt5738", 0},
{ },
};
static struct i2c_driver rt5738_i2c_driver = {
.driver = {
.name = "rt5738",
.owner = THIS_MODULE,
.of_match_table = rt_match_table,
},
.probe = rt5738_i2c_probe,
.remove = rt5738_i2c_remove,
.id_table = rt_dev_id,
};
static int __init rt5738_i2c_init(void)
{
pr_info("%s\n", __func__);
return i2c_add_driver(&rt5738_i2c_driver);
}
subsys_initcall(rt5738_i2c_init);
static void __exit rt5738_i2c_exit(void)
{
i2c_del_driver(&rt5738_i2c_driver);
}
module_exit(rt5738_i2c_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jeff Chang <jeff_chang@richtek.com>");
MODULE_VERSION(RT5738_DRV_VERSION);
MODULE_DESCRIPTION("Regulator driver for RT5738");
@@ -0,0 +1,40 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#ifndef __RT5738_REGULATOR_H
#define __RT5738_REGULATOR_H
#include <linux/mutex.h>
#include "mtk_rt5738.h"
#define RT5738_DRV_VERSION "1.0.0_MTK"
struct regulator_chip {
unsigned char vol_reg;
unsigned char mode_reg;
unsigned char mode_bit;
unsigned char enable_reg;
unsigned char enable_bit;
};
struct rt5738_regulator_info {
struct device *dev;
struct i2c_client *i2c;
struct mutex io_lock;
#ifdef CONFIG_RT_REGMAP
struct rt_regmap_device *regmap_dev;
struct rt_regmap_properties *regmap_props;
#endif /* #ifdef CONFIG_RT_REGMAP */
struct regulator_desc *desc;
struct regulator_dev *regulator;
struct regulator_chip *reg_chip;
int id;
int pin_sel;
};
/* pmic extbuck extern functions */
extern int is_rt5738_exist(void);
#endif /*--__RT5738_REGULATOR_H--*/
@@ -0,0 +1,70 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2021 MediaTek Inc.
*/
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include "isl91302a-spi.h"
#define VPROC2_DRV_VERSION "1.0.0_PLAT"
static int vproc2_plat_probe(struct platform_device *pdev)
{
struct isl91302a_chip *chip;
int ret = 0;
pr_info("%s ver(%s)\n", __func__, VPROC2_DRV_VERSION);
chip = devm_kzalloc(&pdev->dev,
sizeof(struct isl91302a_chip), GFP_KERNEL);
chip->dev = &pdev->dev;
platform_set_drvdata(pdev, chip);
ret = isl91302a_regulator_init(chip);
if (ret < 0) {
pr_notice("%s regulator init fail\n", __func__);
return -EINVAL;
}
return ret;
}
static int vproc2_plat_remove(struct platform_device *pdev)
{
struct isl91302a_chip *chip = platform_get_drvdata(pdev);
if (chip)
isl91302a_regulator_deinit(chip);
return 0;
}
static const struct of_device_id vproc2_id_table[] = {
{.compatible = "mediatek,vproc2_sspm_plat",},
};
static struct platform_driver vproc2_plat_driver = {
.driver = {
.name = "vproc2_plat",
.owner = THIS_MODULE,
},
.probe = vproc2_plat_probe,
.remove = vproc2_plat_remove,
};
static int __init vproc2_init(void)
{
pr_info("%s ver(%s)\n", __func__, VPROC2_DRV_VERSION);
return platform_driver_register(&vproc2_plat_driver);
}
static void __exit vproc2_exit(void)
{
platform_driver_unregister(&vproc2_plat_driver);
}
subsys_initcall(vproc2_init);
module_exit(vproc2_exit);
MODULE_DESCRIPTION("Vproc2 IPI Driver");
MODULE_VERSION(VPROC2_DRV_VERSION);
MODULE_AUTHOR("Sakya <jeff_chang@richtek.com>");
MODULE_LICENSE("GPL");
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,164 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_BUCK_H_
#define _MT_PMIC_API_BUCK_H_
void vmd1_pmic_setting_on(void);
void vmd1_pmic_setting_off(void);
int vcore_pmic_set_mode(unsigned char mode);
int vproc_pmic_set_mode(unsigned char mode);
void wk_auxadc_bgd_ctrl(unsigned char en);
void wk_auxadc_bgd_ctrl_dbg(void);
#ifdef LP_GOLDEN_SETTING
#define LGS
#endif
#ifdef LP_GOLDEN_SETTING_W_SPM
#define LGSWS
#endif
#if defined(LGS) || defined(LGSWS)
#define PMIC_LP_BUCK_ENTRY(reg) {reg, MT6357_BUCK_##reg##_CON0}
#define PMIC_LP_LDO_ENTRY(reg) {reg, MT6357_LDO_##reg##_CON0}
#define PMIC_LP_LDO_VCN33_0_ENTRY(reg) {reg, MT6357_LDO_VCN33_CON0_0}
#define PMIC_LP_LDO_VCN33_1_ENTRY(reg) {reg, MT6357_LDO_VCN33_CON0_1}
#define PMIC_LP_LDO_VLDO28_0_ENTRY(reg) {reg, MT6357_LDO_VLDO28_CON0_0}
#define PMIC_LP_LDO_VLDO28_1_ENTRY(reg) {reg, MT6357_LDO_VLDO28_CON0_1}
#define PMIC_LP_LDO_VUSB33_0_ENTRY(reg) {reg, MT6357_LDO_VUSB33_CON0_0}
#define PMIC_LP_LDO_VUSB33_1_ENTRY(reg) {reg, MT6357_LDO_VUSB33_CON0_1}
#endif
enum BUCK_LDO_EN_USER {
SW,
SPM = SW,
SRCLKEN0,
SRCLKEN1,
SRCLKEN2,
SRCLKEN3,
};
#define HW_OFF 0
#define HW_LP 1
#define SW_OFF 0
#define SW_ON 1
#define SW_LP 3
#define SPM_OFF 0
#define SPM_ON 1
#define SPM_LP 3
enum PMU_LP_TABLE_ENUM {
VPROC,
VCORE,
VMODEM,
VS1,
VPA,
VSRAM_PROC,
VSRAM_OTHERS,
VFE28,
VXO22,
VRF18,
VRF12,
VEFUSE,
VCN33_0,
VCN33_1,
VCN28,
VCN18,
VCAMA,
VCAMD,
VCAMIO,
VLDO28_0,
VLDO28_1,
VAUX18,
VAUD28,
VIO28,
VIO18,
VDRAM,
VMC,
VMCH,
VEMC,
VSIM1,
VSIM2,
VIBR,
VUSB33_0,
VUSB33_1,
TREF,
TABLE_COUNT_END
};
struct PMU_LP_TABLE_ENTRY {
enum PMU_LP_TABLE_ENUM flagname;
#if defined(LGS) || defined(LGSWS)
unsigned short en_adr;
#endif
};
extern int pmic_buck_vproc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vcore_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vmodem_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vs1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vpa_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_proc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_others_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vfe28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vxo22_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vrf18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vrf12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vefuse_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcama_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcamd_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcamio_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vldo28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vaux18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vaud28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vio28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vio18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vdram_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmch_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vemc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsim1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsim2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vibr_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vusb33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_tref_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
#endif
@@ -0,0 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_LDO_H_
#define _MT_PMIC_API_LDO_H_
#endif /* _MT_PMIC_API_LDO_H_ */
@@ -0,0 +1,64 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_INFO_H_
#define _MT_PMIC_INFO_H_
/*
* The CHIP INFO
*/
#define PMIC6357_E1_CID_CODE 0x5710
#define PMIC6357_E2_CID_CODE 0x5720
#define PMIC6357_E3_CID_CODE 0x5730
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#define IPIMB
#endif
/*
* Debugfs
*/
#define PMICTAG "[PMIC] "
extern unsigned int gPMICDbgLvl;
extern unsigned int gPMICHKDbgLvl;
extern unsigned int gPMICCOMDbgLvl;
extern unsigned int gPMICIRQDbgLvl;
extern unsigned int gPMICREGDbgLvl;
#define PMIC_LOG_DBG 4
#define PMIC_LOG_INFO 3
#define PMIC_LOG_NOT 2
#define PMIC_LOG_WARN 1
#define PMIC_LOG_ERR 0
#define PMICLOG(fmt, arg...) do { \
if (gPMICDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define HKLOG(fmt, arg...) do { \
if (gPMICHKDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define COMLOG(fmt, arg...) do { \
if (gPMICCOMDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define IRQLOG(fmt, arg...) do { \
if (gPMICIRQDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define RGLTRLOG(fmt, arg...) do { \
if (gPMICREGDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
extern void wk_pmic_enable_sdn_delay(void);
#endif /* _MT_PMIC_INFO_H_ */
@@ -0,0 +1,53 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_PMIC_IRQ_H
#define __MT_PMIC_IRQ_H
#define PMIC_INT_WIDTH 16
#define PMIC_SP_IRQ_GEN(_used, _level_trig, _name) \
{ \
.used = _used, \
.level_trig = _level_trig, \
.name = #_name, \
}
#define PMIC_SP_INTS_GEN(sp, _con_len, _sp_irqs, _top_int_bit) \
{ \
.enable = MT6357_##sp##_INT_CON0, \
.mask = MT6357_##sp##_INT_MASK_CON0, \
.status = MT6357_##sp##_INT_STATUS0, \
.raw_status = MT6357_##sp##_INT_RAW_STATUS0, \
.con_len = _con_len, \
.int_offset = SP_##sp##_START, \
.sp_irqs = _sp_irqs, \
.top_int_bit = _top_int_bit, \
}
struct pmic_sp_irq {
unsigned short used;
unsigned short level_trig;
const char *name;
void (*callback)(void);
void (*oc_callback)(enum PMIC_IRQ_ENUM intNo,
const char *name);
unsigned int times;
};
struct pmic_sp_interrupt {
unsigned int enable;
unsigned int mask;
unsigned int status;
unsigned int raw_status;
unsigned int con_len;
unsigned int int_offset; /* start intNo of this subpack */
struct pmic_sp_irq (*sp_irqs)[PMIC_INT_WIDTH];
unsigned int top_int_bit;
};
#define ENABLE_ALL_OC_IRQ 0
#endif /*--PMIC_IRQ_H--*/
@@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_REGULATOR_H_
#define _MT_PMIC_REGULATOR_H_
#endif /* _MT_PMIC_REGULATOR_H_ */
@@ -0,0 +1,164 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_REGULATOR_CODEGEN_H_
#define _MT_REGULATOR_CODEGEN_H_
extern struct mtk_regulator mt_ldos[], mt_bucks[];
extern struct of_regulator_match pmic_regulator_buck_matches[];
extern struct of_regulator_match pmic_regulator_ldo_matches[];
extern int mt_ldos_size, mt_bucks_size;
extern int pmic_regulator_ldo_matches_size, pmic_regulator_buck_matches_size;
/* -------Code Gen Start-------*/
/* Non regular voltage regulator */
#define NON_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, array, \
array_idx, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ARRAY_SIZE(array), \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.pvoltages = (void *)(array), \
.idxs = (void *)(array_idx), \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6357_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6357_upmu_set_rg_##_name##_vosel, \
.da_en_cb = mt6357_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6357_upmu_get_rg_##_name##_vosel, \
.isUsedable = (use), \
}
/* Regular voltage regulator */
#define REGULAR_VOLTAGE_REGULATOR_LDO_GEN(_name, _type, min, max, \
step, min_sel, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6357_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6357_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6357_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6357_upmu_get_da_##_name##_vosel, \
.isUsedable = (use), \
}
#define REGULAR_VOLTAGE_REGULATOR_BUCK_GEN(_name, _type, min, max, \
step, min_sel, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6357_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6357_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6357_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6357_upmu_get_da_##_name##_vosel, \
.isUsedable = (use), \
}
/* Fixed voltage regulator */
#define FIXED_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, fixed, mode, use)\
{ \
.desc = { \
.name = #_name, \
.n_voltages = 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.fixed_uV = (fixed), \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6357_upmu_set_rg_##_type##_##_name##_en, \
.da_en_cb = mt6357_upmu_get_da_##_name##_en, \
.isUsedable = (use), \
}
enum MT6357_POWER_BUCK {
MT6357_POWER_BUCK_VS1,
MT6357_POWER_BUCK_VMODEM,
MT6357_POWER_BUCK_VCORE,
MT6357_POWER_BUCK_VPROC,
MT6357_POWER_BUCK_VPA,
MT6357_BUCK_COUNT_END
};
enum MT6357_POWER_LDO {
MT6357_POWER_LDO_VFE28,
MT6357_POWER_LDO_VXO22,
MT6357_POWER_LDO_VRF18,
MT6357_POWER_LDO_VRF12,
MT6357_POWER_LDO_VEFUSE,
MT6357_POWER_LDO_VCN33_BT,
MT6357_POWER_LDO_VCN33_WIFI,
MT6357_POWER_LDO_VCN28,
MT6357_POWER_LDO_VCN18,
MT6357_POWER_LDO_VCAMA,
MT6357_POWER_LDO_VCAMD,
MT6357_POWER_LDO_VCAMIO,
MT6357_POWER_LDO_VLDO28,
MT6357_POWER_LDO_VSRAM_OTHERS,
MT6357_POWER_LDO_VSRAM_PROC,
MT6357_POWER_LDO_VAUX18,
MT6357_POWER_LDO_VAUD28,
MT6357_POWER_LDO_VIO28,
MT6357_POWER_LDO_VIO18,
MT6357_POWER_LDO_VDRAM,
MT6357_POWER_LDO_VMC,
MT6357_POWER_LDO_VMCH,
MT6357_POWER_LDO_VEMC,
MT6357_POWER_LDO_VSIM1,
MT6357_POWER_LDO_VSIM2,
MT6357_POWER_LDO_VIBR,
MT6357_POWER_LDO_VUSB33,
MT6357_LDO_COUNT_END
};
#endif /* _MT_REGULATOR_CODEGEN_H_ */
@@ -0,0 +1,58 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_RT5738_H
#define __MT_RT5738_H
/* Custom RT5738_NAME */
#define RT5738_NAME_0 "ext_buck_lp4"
#define RT5738_NAME_1 "ext_buck_lp4x"
#define RT5738_NAME_2 "ext_buck_vgpu"
/*#define RT5738_IS_EXIST_NAME RT5738_NAME_2 */
/* RT5738 operation register */
#define RT5738_REG_VSEL0 (0x00)
#define RT5738_REG_VSEL1 (0x01)
#define RT5738_REG_CTRL1 (0x02)
#define RT5738_REG_ID1 (0x03)
#define RT5738_REG_ID2 (0x04)
#define RT5738_REG_MONITOR (0x05)
#define RT5738_REG_CTRL2 (0x06)
#define RT5738_REG_CTRL3 (0x07)
#define RT5738_REG_CTRL4 (0x08)
/* Hidden mode */
/* #define RT5738_REG_CTRL5 (0x09) */
#if defined(RT5738_NAME_0)
#define RT5738_CMPT_STR_0 "mediatek,ext_buck_lp4"
#define RT5738_VSEL_0 RT5738_REG_VSEL0
#define RT5738_CTRL_0 RT5738_REG_CTRL1
#define RT5738_CTRL_BIT_0 0x01
#define RT5738_EN_0 RT5738_REG_MONITOR
#define RT5738_EN_BIT_0 0x01
#endif
#if defined(RT5738_NAME_1)
#define RT5738_CMPT_STR_1 "mediatek,ext_buck_lp4x"
#define RT5738_VSEL_1 RT5738_REG_VSEL1
#define RT5738_CTRL_1 RT5738_REG_CTRL1
#define RT5738_CTRL_BIT_1 0x02
#define RT5738_EN_1 RT5738_REG_MONITOR
#define RT5738_EN_BIT_1 0x02
#endif
#if defined(RT5738_NAME_2)
#define RT5738_CMPT_STR_2 "mediatek,ext_buck_vgpu"
#define RT5738_VSEL_2 RT5738_REG_VSEL1
#define RT5738_CTRL_2 RT5738_REG_CTRL1
#define RT5738_CTRL_BIT_2 0x01
#define RT5738_EN_2 RT5738_REG_MONITOR
#define RT5738_EN_BIT_2 0x01
#endif
#endif /*--__MT_RT5738_H--*/
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,196 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_BUCK_H_
#define _MT_PMIC_API_BUCK_H_
#include <mach/upmu_hw.h>
void vmd1_pmic_setting_on(void);
void vmd1_pmic_setting_off(void);
#ifdef LP_GOLDEN_SETTING
#define LGS
#endif
#ifdef LP_GOLDEN_SETTING_W_SPM
#define LGSWS
#endif
#if defined(LGS) || defined(LGSWS)
#define PMIC_LP_BUCK_ENTRY(reg) {reg, MT6358_BUCK_##reg##_CON0}
#define PMIC_LP_LDO_ENTRY(reg) {reg, MT6358_LDO_##reg##_CON0}
#define PMIC_LP_LDO_VCN33_0_ENTRY(reg) {reg, MT6358_LDO_VCN33_CON0_0}
#define PMIC_LP_LDO_VCN33_1_ENTRY(reg) {reg, MT6358_LDO_VCN33_CON0_1}
#define PMIC_LP_LDO_VLDO28_0_ENTRY(reg) {reg, MT6358_LDO_VLDO28_CON0_0}
#define PMIC_LP_LDO_VLDO28_1_ENTRY(reg) {reg, MT6358_LDO_VLDO28_CON0_1}
#define PMIC_LP_LDO_VUSB_0_ENTRY(reg) {reg, MT6358_LDO_VUSB_CON0_0}
#define PMIC_LP_LDO_VUSB_1_ENTRY(reg) {reg, MT6358_LDO_VUSB_CON0_1}
#endif
enum BUCK_LDO_EN_USER {
SW,
SPM = SW,
SRCLKEN0,
SRCLKEN1,
SRCLKEN2,
SRCLKEN3,
};
#define HW_OFF 0
#define HW_LP 1
#define SW_OFF 0
#define SW_ON 1
#define SW_LP 3
#define SPM_OFF 0
#define SPM_ON 1
#define SPM_LP 3
enum PMU_LP_TABLE_ENUM {
VPROC11,
VCORE,
VGPU,
VMODEM,
VS1,
VS2,
VPA,
VDRAM1,
VPROC12,
VSRAM_GPU,
VSRAM_OTHERS,
VSRAM_PROC11,
VXO22,
VRF18,
VRF12,
VEFUSE,
VCN33_0,
VCN33_1,
VCN28,
VCN18,
VCAMA1,
VCAMD,
VCAMA2,
VSRAM_PROC12,
VCAMIO,
VLDO28_0,
VLDO28_1,
VA12,
VAUX18,
VAUD28,
VIO28,
VIO18,
VFE28,
VDRAM2,
VMC,
VMCH,
VEMC,
VSIM1,
VSIM2,
VIBR,
VUSB_0,
VUSB_1,
VBIF28,
#if defined(USE_PMIC_MT6366) && USE_PMIC_MT6366
VM18,
VMDDR,
VSRAM_CORE,
#endif
TABLE_COUNT_END
};
struct PMU_LP_TABLE_ENTRY {
enum PMU_LP_TABLE_ENUM flagname;
#if defined(LGS) || defined(LGSWS)
unsigned short en_adr;
#endif
};
extern int pmic_buck_vproc11_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vcore_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vgpu_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vmodem_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vs1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vs2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vpa_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vdram1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vproc12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_gpu_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_others_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_proc11_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vxo22_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vrf18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vrf12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vefuse_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcama1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcamd_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcama2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_proc12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcamio_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vldo28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_va12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vaux18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vaud28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vio28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vio18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vfe28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vdram2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmch_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vemc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsim1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsim2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vibr_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vusb_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vbif28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
#if defined(USE_PMIC_MT6366) && USE_PMIC_MT6366
extern int pmic_ldo_vm18_lp(enum BUCK_LDO_EN_USER user, unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmddr_lp(enum BUCK_LDO_EN_USER user, unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_core_lp(enum BUCK_LDO_EN_USER user, unsigned char op_en,
unsigned char op_cfg);
#endif
#endif
@@ -0,0 +1,67 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_INFO_H_
#define _MT_PMIC_INFO_H_
/*
* The CHIP INFO
*/
#define PMIC6358_E1_CID_CODE 0x5810
#define PMIC6358_E2_CID_CODE 0x5820
#define PMIC6358_E3_CID_CODE 0x5830
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#define IPIMB /* disable for Bring up */
#endif
/*
* Debugfs
*/
#define PMICTAG "[PMIC] "
extern unsigned int gPMICDbgLvl;
extern unsigned int gPMICHKDbgLvl;
extern unsigned int gPMICIRQDbgLvl;
extern unsigned int gPMICREGDbgLvl;
#define PMIC_LOG_DBG 4
#define PMIC_LOG_INFO 3
#define PMIC_LOG_NOT 2
#define PMIC_LOG_WARN 1
#define PMIC_LOG_ERR 0
#define PMICLOG(fmt, arg...) do { \
if (gPMICDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define HKLOG(fmt, arg...) do { \
if (gPMICHKDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define IRQLOG(fmt, arg...) do { \
if (gPMICIRQDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define RGLTRLOG(fmt, arg...) do { \
if (gPMICREGDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
/* MT6358 Export API */
extern unsigned int pmic_scp_set_vcore(unsigned int voltage);
extern unsigned int pmic_scp_set_vcore_sleep(unsigned int voltage);
extern unsigned int pmic_scp_set_vsram_vcore(unsigned int voltage);
extern unsigned int pmic_scp_set_vsram_vcore_sleep(unsigned int voltage);
extern void wk_pmic_enable_sdn_delay(void);
#if defined(CONFIG_MACH_MT6781)
extern unsigned int is_pmic_new_power_grid(void);
extern void record_is_pmic_new_power_grid(struct platform_device *pdev);
#endif
#endif /* _MT_PMIC_INFO_H_ */
@@ -0,0 +1,54 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_PMIC_IRQ_H
#define __MT_PMIC_IRQ_H
#define PMIC_INT_WIDTH 16
#define PMIC_SP_IRQ_GEN(_used, _name) \
{ \
.used = _used, \
.name = #_name, \
}
#define PMIC_SP_INTS_GEN(sp, _con_len, _sp_irqs, _top_int_bit) \
{ \
.enable = MT6358_##sp##_INT_CON0, \
.mask = MT6358_##sp##_INT_MASK_CON0, \
.status = MT6358_##sp##_INT_STATUS0, \
.raw_status = MT6358_##sp##_INT_RAW_STATUS0, \
.con_len = _con_len, \
.int_offset = SP_##sp##_START, \
.sp_irqs = _sp_irqs, \
.top_int_bit = _top_int_bit, \
}
struct pmic_sp_irq {
unsigned short used;
const char *name;
void (*callback)(void);
void (*oc_callback)(enum PMIC_IRQ_ENUM intNo, const char *int_name);
unsigned int times;
};
struct pmic_sp_interrupt {
unsigned int enable;
unsigned int mask;
unsigned int status;
unsigned int raw_status;
unsigned int con_len;
unsigned int int_offset; /* start intNo of this subpack */
struct pmic_sp_irq (*sp_irqs)[PMIC_INT_WIDTH];
unsigned int top_int_bit;
};
#if defined(MTK_EVB_PLATFORM) || defined(CONFIG_FPGA_EARLY_PORTING)
#define ENABLE_ALL_OC_IRQ 0
#else
#define ENABLE_ALL_OC_IRQ 0
#endif
#endif /*--PMIC_IRQ_H--*/
@@ -0,0 +1,168 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_REGULATOR_CODEGEN_H_
#define _MT_REGULATOR_CODEGEN_H_
extern struct mtk_regulator mt_ldos[], mt_bucks[];
extern struct of_regulator_match pmic_regulator_buck_matches[];
extern struct of_regulator_match pmic_regulator_ldo_matches[];
extern int mt_ldos_size, mt_bucks_size;
extern int pmic_regulator_ldo_matches_size, pmic_regulator_buck_matches_size;
/* -------Code Gen Start-------*/
/* Non regular voltage regulator */
#define NON_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, array, \
array_idx, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ARRAY_SIZE(array), \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.pvoltages = (array), \
.idxs = (array_idx), \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6358_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6358_upmu_set_rg_##_name##_vosel, \
.da_en_cb = mt6358_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6358_upmu_get_rg_##_name##_vosel, \
.isUsedable = (use), \
}
/* Regular voltage regulator */
#define REGULAR_VOLTAGE_REGULATOR_LDO_GEN(_name, _type, min, max, \
step, min_sel, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6358_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6358_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6358_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6358_upmu_get_da_##_name##_vosel, \
.isUsedable = (use), \
}
#define REGULAR_VOLTAGE_REGULATOR_BUCK_GEN(_name, _type, min, max, \
step, min_sel, mode, _modeset_reg, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
.valid_modes_mask = REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST,\
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6358_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6358_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6358_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6358_upmu_get_da_##_name##_vosel, \
.modeset_reg = _modeset_reg, \
.isUsedable = (use), \
}
/* Fixed voltage regulator */
#define FIXED_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, fixed, mode, use)\
{ \
.desc = { \
.name = #_name, \
.n_voltages = 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.fixed_uV = (fixed), \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664,\
show_regulator_status, store_regulator_status),\
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6358_upmu_set_rg_##_type##_##_name##_en, \
.da_en_cb = mt6358_upmu_get_da_##_name##_en, \
.isUsedable = (use), \
}
enum MT6358_POWER_BUCK {
MT6358_POWER_BUCK_VDRAM1,
MT6358_POWER_BUCK_VCORE,
MT6358_POWER_BUCK_VPA,
MT6358_POWER_BUCK_VPROC11,
MT6358_POWER_BUCK_VPROC12,
MT6358_POWER_BUCK_VGPU,
MT6358_POWER_BUCK_VS2,
MT6358_POWER_BUCK_VMODEM,
MT6358_POWER_BUCK_VS1,
MT6358_BUCK_COUNT_END
};
enum MT6358_POWER_LDO {
MT6358_POWER_LDO_VDRAM2,
MT6358_POWER_LDO_VSIM1,
MT6358_POWER_LDO_VIBR,
MT6358_POWER_LDO_VRF12,
MT6358_POWER_LDO_VIO18,
MT6358_POWER_LDO_VUSB,
MT6358_POWER_LDO_VCAMIO,
MT6358_POWER_LDO_VCAMD,
MT6358_POWER_LDO_VCN18,
MT6358_POWER_LDO_VFE28,
MT6358_POWER_LDO_VSRAM_PROC11,
MT6358_POWER_LDO_VCN28,
MT6358_POWER_LDO_VSRAM_OTHERS,
MT6358_POWER_LDO_VSRAM_GPU,
MT6358_POWER_LDO_VXO22,
MT6358_POWER_LDO_VEFUSE,
MT6358_POWER_LDO_VAUX18,
MT6358_POWER_LDO_VMCH,
MT6358_POWER_LDO_VBIF28,
MT6358_POWER_LDO_VSRAM_PROC12,
MT6358_POWER_LDO_VCAMA1,
MT6358_POWER_LDO_VEMC,
MT6358_POWER_LDO_VIO28,
MT6358_POWER_LDO_VA12,
MT6358_POWER_LDO_VRF18,
MT6358_POWER_LDO_VCN33_BT,
MT6358_POWER_LDO_VCN33_WIFI,
MT6358_POWER_LDO_VCAMA2,
MT6358_POWER_LDO_VMC,
MT6358_POWER_LDO_VLDO28,
MT6358_POWER_LDO_VAUD28,
MT6358_POWER_LDO_VSIM2,
MT6358_POWER_LDO_VA09,
MT6358_LDO_COUNT_END
};
#endif /* _MT_REGULATOR_CODEGEN_H_ */
@@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2022 MediaTek Inc.
* Author Mufaddal Ali<mufaddal.ali@mediatek.com>
*/
int mt6359_gauge_get_batadc(void);
int mt6359_gauge_get_v_bat_temp(void);
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,315 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_BUCK_H_
#define _MT_PMIC_API_BUCK_H_
void vmd1_pmic_setting_on(void);
void vmd1_pmic_setting_off(void);
#ifdef LP_GOLDEN_SETTING
#define LGS
#endif
#ifdef LP_GOLDEN_SETTING_W_SPM
#define LGSWS
#endif
#if defined(LGS) || defined(LGSWS)
#define PMIC_LP_BUCK_ENTRY(reg) {reg, MT6359_BUCK_##reg##_CON0}
#define PMIC_LP_LDO_ENTRY(reg) {reg, MT6359_LDO_##reg##_CON0}
#define PMIC_LP_LDO_VCN33_0_ENTRY(reg) {reg, MT6359_LDO_VCN33_CON0_0}
#define PMIC_LP_LDO_VCN33_1_ENTRY(reg) {reg, MT6359_LDO_VCN33_CON0_1}
#define PMIC_LP_LDO_VLDO28_0_ENTRY(reg) {reg, MT6359_LDO_VLDO28_CON0_0}
#define PMIC_LP_LDO_VLDO28_1_ENTRY(reg) {reg, MT6359_LDO_VLDO28_CON0_1}
#define PMIC_LP_LDO_VUSB_0_ENTRY(reg) {reg, MT6359_LDO_VUSB_CON0_0}
#define PMIC_LP_LDO_VUSB_1_ENTRY(reg) {reg, MT6359_LDO_VUSB_CON0_1}
#endif
enum BUCK_LDO_EN_USER {
SRCLKEN0,
SRCLKEN1,
SRCLKEN2,
SRCLKEN3,
SRCLKEN4,
SRCLKEN5,
SRCLKEN6,
SRCLKEN7,
SRCLKEN8,
SRCLKEN9,
SRCLKEN10,
SRCLKEN11,
SRCLKEN12,
SRCLKEN13,
SRCLKEN14,
SW,
SPM = SW,
};
#define HW_OFF 0
#define HW_LP 1
#define HW_ULP 2
#define SW_OFF 0
#define SW_ON 1
#define SW_LP 3
#define SPM_OFF 0
#define SPM_ON 1
#define SPM_LP 3
enum PMU_LP_TABLE_ENUM {
VCORE,
VPU,
VPROC1,
VPROC2,
VGPU11,
VGPU12,
VMODEM,
VS1,
VS2,
VPA,
VSRAM_PROC1,
VSRAM_PROC2,
VSRAM_OTHERS,
VSRAM_MD,
VCAMIO,
VM18,
VCN18,
VCN13,
VRF18,
VIO18,
VEFUSE,
VRF12,
VRFCK,
VA12,
VA09,
VBBCK,
VFE28,
VBIF28,
VAUD18,
VAUX18,
VXO22,
VCN33_1_0,
VCN33_1_1,
VCN33_2_0,
VCN33_2_1,
VUSB_0,
VUSB_1,
VEMC,
VIO28,
VSIM1,
VSIM2,
VUFS,
VIBR,
TABLE_COUNT_END
};
struct PMU_LP_TABLE_ENTRY {
enum PMU_LP_TABLE_ENUM flagname;
#if defined(LGS) || defined(LGSWS)
unsigned short en_adr;
#endif
};
extern int pmic_buck_vcore_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vpu_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vproc1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vproc2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vgpu11_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vgpu12_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vmodem_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vs1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vs2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vpa_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_proc1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_proc2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_others_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_md_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcamio_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vm18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn13_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vrf18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vio18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vefuse_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vrf12_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vrfck_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_va12_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_va09_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vbbck_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vfe28_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vbif28_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vaud18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vaux18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vxo22_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn33_1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn33_2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vusb_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vemc_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vio28_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsim1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsim2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vufs_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vibr_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
#endif
@@ -0,0 +1,65 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_INFO_H_
#define _MT_PMIC_INFO_H_
/*
* The CHIP INFO
*/
#define PMIC6359_E1_CID_CODE 0x5910
#define PMIC6359_E2_CID_CODE 0x5920
#define PMIC6359_E3_CID_CODE 0x5930
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#define IPIMB
/* disable for Bring up */
#endif
/*
* Debugfs
*/
#define PMICTAG "[PMIC] "
extern unsigned int gPMICDbgLvl;
extern unsigned int gPMICHKDbgLvl;
extern unsigned int gPMICIRQDbgLvl;
extern unsigned int gPMICREGDbgLvl;
#define PMIC_LOG_DBG 4
#define PMIC_LOG_INFO 3
#define PMIC_LOG_NOT 2
#define PMIC_LOG_WARN 1
#define PMIC_LOG_ERR 0
#define PMICLOG(fmt, arg...) do { \
if (gPMICDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define HKLOG(fmt, arg...) do { \
if (gPMICHKDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define IRQLOG(fmt, arg...) do { \
if (gPMICIRQDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define RGLTRLOG(fmt, arg...) do { \
if (gPMICREGDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
/* MT6359 Export API */
extern int pmic_scp_ctrl_enable(bool vcore_en, bool vsram_en,
bool is_pmrc_mode);
extern unsigned int pmic_scp_set_vcore(unsigned int voltage);
extern unsigned int pmic_scp_set_vsram_vcore(unsigned int voltage);
extern unsigned int pmic_scp_set_vsram_vcore_sleep(unsigned int voltage);
extern void wk_pmic_enable_sdn_delay(void);
#endif /* _MT_PMIC_INFO_H_ */
@@ -0,0 +1,56 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_PMIC_IRQ_H
#define __MT_PMIC_IRQ_H
#define PMIC_INT_WIDTH 16
#define PMIC_SP_IRQ_GEN(_used, _level_trig, _name) \
{ \
.used = _used, \
.level_trig = _level_trig, \
.name = #_name, \
}
#define PMIC_SP_INTS_GEN(sp, _con_len, _sp_irqs, _top_int_bit) \
{ \
.enable = MT6359_##sp##_INT_CON0, \
.mask = MT6359_##sp##_INT_MASK_CON0, \
.status = MT6359_##sp##_INT_STATUS0, \
.raw_status = MT6359_##sp##_INT_RAW_STATUS0, \
.con_len = _con_len, \
.int_offset = SP_##sp##_START, \
.sp_irqs = _sp_irqs, \
.top_int_bit = _top_int_bit, \
}
struct pmic_sp_irq {
unsigned short used;
unsigned short level_trig;
const char *name;
void (*callback)(void);
void (*oc_callback)(enum PMIC_IRQ_ENUM intNo, const char *name);
unsigned int times;
};
struct pmic_sp_interrupt {
unsigned int enable;
unsigned int mask;
unsigned int status;
unsigned int raw_status;
unsigned int con_len;
unsigned int int_offset; /* start intNo of this subpack */
struct pmic_sp_irq (*sp_irqs)[PMIC_INT_WIDTH];
unsigned int top_int_bit;
};
#if defined(MTK_EVB_PLATFORM) || defined(CONFIG_FPGA_EARLY_PORTING)
#define ENABLE_ALL_OC_IRQ 0
#else
#define ENABLE_ALL_OC_IRQ 0
#endif
#endif /*--PMIC_IRQ_H--*/
@@ -0,0 +1,172 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_REGULATOR_CODEGEN_H_
#define _MT_REGULATOR_CODEGEN_H_
extern struct mtk_regulator mt_ldos[], mt_bucks[];
extern struct of_regulator_match pmic_regulator_buck_matches[];
extern struct of_regulator_match pmic_regulator_ldo_matches[];
extern int mt_ldos_size, mt_bucks_size;
extern int pmic_regulator_ldo_matches_size, pmic_regulator_buck_matches_size;
/* -------Code Gen Start-------*/
/* Non regular voltage regulator */
#define NON_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, array, \
array_idx, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ARRAY_SIZE(array), \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.pvoltages = (array), \
.idxs = (array_idx), \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6359_upmu_set_rg_##_name##_vosel, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.da_vol_cb = mt6359_upmu_get_rg_##_name##_vosel, \
.isUsedable = (use), \
}
/* Regular voltage regulator */
#define REGULAR_VOLTAGE_REGULATOR_LDO_GEN(_name, _type, min, max, \
step, min_sel, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6359_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.da_vol_cb = mt6359_upmu_get_da_##_name##_vosel, \
.isUsedable = (use), \
}
#define REGULAR_VOLTAGE_REGULATOR_BUCK_GEN(_name, _type, min, max, \
step, min_sel, mode, _modeset_reg, _lp_mode_reg, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
.valid_modes_mask = REGULATOR_MODE_FAST | \
REGULATOR_MODE_NORMAL | \
REGULATOR_MODE_IDLE, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6359_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.da_vol_cb = mt6359_upmu_get_da_##_name##_vosel, \
.modeset_reg = _modeset_reg, \
.lp_mode_reg = _lp_mode_reg, \
.isUsedable = (use), \
}
/* Fixed voltage regulator */
#define FIXED_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, fixed, mode, use)\
{ \
.desc = { \
.name = #_name, \
.n_voltages = 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.fixed_uV = (fixed), \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664,\
show_regulator_status, store_regulator_status),\
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.isUsedable = (use), \
}
enum MT6359_POWER_BUCK {
MT6359_POWER_BUCK_VS1,
MT6359_POWER_BUCK_VGPU11,
MT6359_POWER_BUCK_VMODEM,
MT6359_POWER_BUCK_VPU,
MT6359_POWER_BUCK_VCORE,
MT6359_POWER_BUCK_VS2,
MT6359_POWER_BUCK_VPA,
MT6359_POWER_BUCK_VPROC2,
MT6359_POWER_BUCK_VPROC1,
MT6359_BUCK_COUNT_END
};
enum MT6359_POWER_LDO {
MT6359_POWER_LDO_VAUD18,
MT6359_POWER_LDO_VSIM1,
MT6359_POWER_LDO_VIBR,
MT6359_POWER_LDO_VRF12,
MT6359_POWER_LDO_VUSB,
MT6359_POWER_LDO_VSRAM_PROC2,
MT6359_POWER_LDO_VIO18,
MT6359_POWER_LDO_VCAMIO,
MT6359_POWER_LDO_VCN18,
MT6359_POWER_LDO_VFE28,
MT6359_POWER_LDO_VCN13,
MT6359_POWER_LDO_VCN33_1_BT,
MT6359_POWER_LDO_VCN33_1_WIFI,
MT6359_POWER_LDO_VAUX18,
MT6359_POWER_LDO_VSRAM_OTHERS,
MT6359_POWER_LDO_VEFUSE,
MT6359_POWER_LDO_VXO22,
MT6359_POWER_LDO_VRFCK,
MT6359_POWER_LDO_VBIF28,
MT6359_POWER_LDO_VIO28,
MT6359_POWER_LDO_VEMC,
MT6359_POWER_LDO_VCN33_2_BT,
MT6359_POWER_LDO_VCN33_2_WIFI,
MT6359_POWER_LDO_VA12,
MT6359_POWER_LDO_VA09,
MT6359_POWER_LDO_VRF18,
MT6359_POWER_LDO_VSRAM_MD,
MT6359_POWER_LDO_VUFS,
MT6359_POWER_LDO_VM18,
MT6359_POWER_LDO_VBBCK,
MT6359_POWER_LDO_VSRAM_PROC1,
MT6359_POWER_LDO_VSIM2,
MT6359_LDO_COUNT_END
};
#endif /* _MT_REGULATOR_CODEGEN_H_ */
@@ -0,0 +1,197 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_H_
#define _MT_PMIC_API_H_
extern unsigned int mt6359_upmu_set_rg_buck_vpu_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vpu_en(void);
extern unsigned int mt6359_upmu_get_da_vpu_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vpu_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vpu_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vcore_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vcore_en(void);
extern unsigned int mt6359_upmu_get_da_vcore_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vcore_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vcore_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vgpu11_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vgpu11_en(void);
extern unsigned int mt6359_upmu_get_da_vgpu11_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vgpu11_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vgpu11_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vgpu12_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vgpu12_en(void);
extern unsigned int mt6359_upmu_get_da_vgpu12_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vgpu12_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vgpu12_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vmodem_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vmodem_en(void);
extern unsigned int mt6359_upmu_get_da_vmodem_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vmodem_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vmodem_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vproc1_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vproc1_en(void);
extern unsigned int mt6359_upmu_get_da_vproc1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vproc1_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vproc1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vproc2_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vproc2_en(void);
extern unsigned int mt6359_upmu_get_da_vproc2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vproc2_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vproc2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vs1_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vs1_en(void);
extern unsigned int mt6359_upmu_get_da_vs1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vs1_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vs1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vs2_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vs2_en(void);
extern unsigned int mt6359_upmu_get_da_vs2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vs2_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vs2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_buck_vpa_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vpa_en(void);
extern unsigned int mt6359_upmu_set_rg_buck_vpa_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_buck_vpa_vosel(void);
extern unsigned int mt6359_upmu_get_da_vpa_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vrtc28_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vrtc28_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_proc1_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_proc1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_proc2_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_proc2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_others_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_others_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_md_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_md_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vfe28_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vfe28_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vxo22_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vxo22_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vrf18_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vrf18_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vrf12_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vrf12_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vefuse_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vefuse_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcn33_1_bt_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcn33_1_bt_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcn33_1_wifi_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcn33_1_wifi_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcn33_2_bt_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcn33_2_bt_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcn33_2_wifi_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcn33_2_wifi_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcn13_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcn13_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcn18_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcn18_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_va09_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_va09_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vcamio_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vcamio_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_va12_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_va12_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vaux18_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vaux18_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vaud18_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vaud18_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vio18_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vio18_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vemc_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vemc_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsim1_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsim1_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsim2_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsim2_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vusb_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vusb_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vrfck_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vrfck_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vbbck_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vbbck_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vbif28_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vbif28_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vibr_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vibr_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vio28_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vio28_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vm18_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vm18_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vufs_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vufs_en(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_proc1_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_proc1_en(void);
extern unsigned int mt6359_upmu_get_da_vsram_proc1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_proc2_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_proc2_en(void);
extern unsigned int mt6359_upmu_get_da_vsram_proc2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_others_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_others_en(void);
extern unsigned int mt6359_upmu_get_da_vsram_others_vosel(void);
extern unsigned int mt6359_upmu_set_rg_ldo_vsram_md_en(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_ldo_vsram_md_en(void);
extern unsigned int mt6359_upmu_get_da_vsram_md_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vemc_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vemc_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vfe28_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vfe28_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vaux18_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vaux18_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vusb_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vusb_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vbif28_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vbif28_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn33_1_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn33_1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn33_2_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn33_2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vsim1_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vsim1_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vsim2_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vsim2_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vio28_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vio28_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vibr_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vibr_vosel(void);
extern unsigned int mt6359_upmu_set_rg_va12_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_va12_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vrf18_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vrf18_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vefuse_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vefuse_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn18_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn18_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcamio_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcamio_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vaud18_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vaud18_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vio18_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vio18_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vm18_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vm18_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vufs_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vufs_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vrf12_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vrf12_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn13_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn13_vosel(void);
extern unsigned int mt6359_upmu_set_rg_va09_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_va09_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vxo22_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vxo22_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vrfck_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vrfck_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vbbck_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vbbck_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn33_1_bt_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn33_1_bt_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn33_1_wifi_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn33_1_wifi_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn33_2_bt_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn33_2_bt_vosel(void);
extern unsigned int mt6359_upmu_set_rg_vcn33_2_wifi_vosel(unsigned int val);
extern unsigned int mt6359_upmu_get_rg_vcn33_2_wifi_vosel(void);
#endif /* _MT_PMIC_API_H_ */
@@ -0,0 +1,315 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_BUCK_H_
#define _MT_PMIC_API_BUCK_H_
void vmd1_pmic_setting_on(void);
void vmd1_pmic_setting_off(void);
#ifdef LP_GOLDEN_SETTING
#define LGS
#endif
#ifdef LP_GOLDEN_SETTING_W_SPM
#define LGSWS
#endif
#if defined(LGS) || defined(LGSWS)
#define PMIC_LP_BUCK_ENTRY(reg) {reg, MT6359_BUCK_##reg##_CON0}
#define PMIC_LP_LDO_ENTRY(reg) {reg, MT6359_LDO_##reg##_CON0}
#define PMIC_LP_LDO_VCN33_0_ENTRY(reg) {reg, MT6359_LDO_VCN33_CON0_0}
#define PMIC_LP_LDO_VCN33_1_ENTRY(reg) {reg, MT6359_LDO_VCN33_CON0_1}
#define PMIC_LP_LDO_VLDO28_0_ENTRY(reg) {reg, MT6359_LDO_VLDO28_CON0_0}
#define PMIC_LP_LDO_VLDO28_1_ENTRY(reg) {reg, MT6359_LDO_VLDO28_CON0_1}
#define PMIC_LP_LDO_VUSB_0_ENTRY(reg) {reg, MT6359_LDO_VUSB_CON0_0}
#define PMIC_LP_LDO_VUSB_1_ENTRY(reg) {reg, MT6359_LDO_VUSB_CON0_1}
#endif
enum BUCK_LDO_EN_USER {
SRCLKEN0,
SRCLKEN1,
SRCLKEN2,
SRCLKEN3,
SRCLKEN4,
SRCLKEN5,
SRCLKEN6,
SRCLKEN7,
SRCLKEN8,
SRCLKEN9,
SRCLKEN10,
SRCLKEN11,
SRCLKEN12,
SRCLKEN13,
SRCLKEN14,
SW,
SPM = SW,
};
#define HW_OFF 0
#define HW_LP 1
#define HW_ULP 2
#define SW_OFF 0
#define SW_ON 1
#define SW_LP 3
#define SPM_OFF 0
#define SPM_ON 1
#define SPM_LP 3
enum PMU_LP_TABLE_ENUM {
VCORE,
VPU,
VPROC1,
VPROC2,
VGPU11,
VGPU12,
VMODEM,
VS1,
VS2,
VPA,
VSRAM_PROC1,
VSRAM_PROC2,
VSRAM_OTHERS,
VSRAM_MD,
VCAMIO,
VM18,
VCN18,
VCN13,
VRF18,
VIO18,
VEFUSE,
VRF12,
VRFCK,
VA12,
VA09,
VBBCK,
VFE28,
VBIF28,
VAUD18,
VAUX18,
VXO22,
VCN33_1_0,
VCN33_1_1,
VCN33_2_0,
VCN33_2_1,
VUSB_0,
VUSB_1,
VEMC,
VIO28,
VSIM1,
VSIM2,
VUFS,
VIBR,
TABLE_COUNT_END
};
struct PMU_LP_TABLE_ENTRY {
enum PMU_LP_TABLE_ENUM flagname;
#if defined(LGS) || defined(LGSWS)
unsigned short en_adr;
#endif
};
extern int pmic_buck_vcore_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vpu_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vproc1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vproc2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vgpu11_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vgpu12_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vmodem_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vs1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vs2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_buck_vpa_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_proc1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_proc2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_others_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsram_md_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcamio_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vm18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn13_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vrf18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vio18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vefuse_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vrf12_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vrfck_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_va12_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_va09_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vbbck_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vfe28_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vbif28_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vaud18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vaux18_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vxo22_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn33_1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vcn33_2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vusb_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vemc_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vio28_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsim1_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vsim2_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vufs_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
extern int pmic_ldo_vibr_lp(
enum BUCK_LDO_EN_USER user,
int op_mode,
unsigned char op_en,
unsigned char op_cfg);
#endif
@@ -0,0 +1,65 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_INFO_H_
#define _MT_PMIC_INFO_H_
/*
* The CHIP INFO
*/
#define PMIC6359_E1_CID_CODE 0x5910
#define PMIC6359_E2_CID_CODE 0x5920
#define PMIC6359_E3_CID_CODE 0x5930
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#define IPIMB
/* disable for Bring up */
#endif
/*
* Debugfs
*/
#define PMICTAG "[PMIC] "
extern unsigned int gPMICDbgLvl;
extern unsigned int gPMICHKDbgLvl;
extern unsigned int gPMICIRQDbgLvl;
extern unsigned int gPMICREGDbgLvl;
#define PMIC_LOG_DBG 4
#define PMIC_LOG_INFO 3
#define PMIC_LOG_NOT 2
#define PMIC_LOG_WARN 1
#define PMIC_LOG_ERR 0
#define PMICLOG(fmt, arg...) do { \
if (gPMICDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define HKLOG(fmt, arg...) do { \
if (gPMICHKDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define IRQLOG(fmt, arg...) do { \
if (gPMICIRQDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define RGLTRLOG(fmt, arg...) do { \
if (gPMICREGDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
/* MT6359 Export API */
extern int pmic_scp_ctrl_enable(bool vcore_en, bool vsram_en,
bool is_pmrc_mode);
extern unsigned int pmic_scp_set_vcore(unsigned int voltage);
extern unsigned int pmic_scp_set_vsram_vcore(unsigned int voltage);
extern unsigned int pmic_scp_set_vsram_vcore_sleep(unsigned int voltage);
extern void wk_pmic_enable_sdn_delay(void);
#endif /* _MT_PMIC_INFO_H_ */
@@ -0,0 +1,50 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_PMIC_IRQ_H
#define __MT_PMIC_IRQ_H
#define PMIC_INT_WIDTH 16
#define PMIC_SP_IRQ_GEN(_used, _level_trig, _name) \
{ \
.used = _used, \
.level_trig = _level_trig, \
.name = #_name, \
}
#define PMIC_SP_INTS_GEN(sp, _con_len, _sp_irqs, _top_int_bit) \
{ \
.enable = MT6359_##sp##_INT_CON0, \
.mask = MT6359_##sp##_INT_MASK_CON0, \
.status = MT6359_##sp##_INT_STATUS0, \
.raw_status = MT6359_##sp##_INT_RAW_STATUS0, \
.con_len = _con_len, \
.int_offset = SP_##sp##_START, \
.sp_irqs = _sp_irqs, \
.top_int_bit = _top_int_bit, \
}
struct pmic_sp_irq {
unsigned short used;
unsigned short level_trig;
const char *name;
void (*callback)(void);
void (*oc_callback)(enum PMIC_IRQ_ENUM intNo, const char *name);
unsigned int times;
};
struct pmic_sp_interrupt {
unsigned int enable;
unsigned int mask;
unsigned int status;
unsigned int raw_status;
unsigned int con_len;
unsigned int int_offset; /* start intNo of this subpack */
struct pmic_sp_irq (*sp_irqs)[PMIC_INT_WIDTH];
unsigned int top_int_bit;
};
#endif /*--PMIC_IRQ_H--*/
@@ -0,0 +1,172 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_REGULATOR_CODEGEN_H_
#define _MT_REGULATOR_CODEGEN_H_
extern struct mtk_regulator mt_ldos[], mt_bucks[];
extern struct of_regulator_match pmic_regulator_buck_matches[];
extern struct of_regulator_match pmic_regulator_ldo_matches[];
extern int mt_ldos_size, mt_bucks_size;
extern int pmic_regulator_ldo_matches_size, pmic_regulator_buck_matches_size;
/* -------Code Gen Start-------*/
/* Non regular voltage regulator */
#define NON_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, array, \
array_idx, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ARRAY_SIZE(array), \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.pvoltages = (array), \
.idxs = (array_idx), \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6359_upmu_set_rg_##_name##_vosel, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.da_vol_cb = mt6359_upmu_get_rg_##_name##_vosel, \
.isUsedable = (use), \
}
/* Regular voltage regulator */
#define REGULAR_VOLTAGE_REGULATOR_LDO_GEN(_name, _type, min, max, \
step, min_sel, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6359_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.da_vol_cb = mt6359_upmu_get_da_##_name##_vosel, \
.isUsedable = (use), \
}
#define REGULAR_VOLTAGE_REGULATOR_BUCK_GEN(_name, _type, min, max, \
step, min_sel, mode, _modeset_reg, _lp_mode_reg, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
.valid_modes_mask = REGULATOR_MODE_FAST | \
REGULATOR_MODE_NORMAL | \
REGULATOR_MODE_IDLE, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6359_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.da_vol_cb = mt6359_upmu_get_da_##_name##_vosel, \
.modeset_reg = _modeset_reg, \
.lp_mode_reg = _lp_mode_reg, \
.isUsedable = (use), \
}
/* Fixed voltage regulator */
#define FIXED_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, fixed, mode, use)\
{ \
.desc = { \
.name = #_name, \
.n_voltages = 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.fixed_uV = (fixed), \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664,\
show_regulator_status, store_regulator_status),\
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664,\
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6359_upmu_set_rg_##_type##_##_name##_en, \
.da_en_cb = mt6359_upmu_get_rg_##_type##_##_name##_en, \
.isUsedable = (use), \
}
enum MT6359_POWER_BUCK {
MT6359_POWER_BUCK_VS1,
MT6359_POWER_BUCK_VGPU11,
MT6359_POWER_BUCK_VMODEM,
MT6359_POWER_BUCK_VPU,
MT6359_POWER_BUCK_VCORE,
MT6359_POWER_BUCK_VS2,
MT6359_POWER_BUCK_VPA,
MT6359_POWER_BUCK_VPROC2,
MT6359_POWER_BUCK_VPROC1,
MT6359_BUCK_COUNT_END
};
enum MT6359_POWER_LDO {
MT6359_POWER_LDO_VAUD18,
MT6359_POWER_LDO_VSIM1,
MT6359_POWER_LDO_VIBR,
MT6359_POWER_LDO_VRF12,
MT6359_POWER_LDO_VUSB,
MT6359_POWER_LDO_VSRAM_PROC2,
MT6359_POWER_LDO_VIO18,
MT6359_POWER_LDO_VCAMIO,
MT6359_POWER_LDO_VCN18,
MT6359_POWER_LDO_VFE28,
MT6359_POWER_LDO_VCN13,
MT6359_POWER_LDO_VCN33_1_BT,
MT6359_POWER_LDO_VCN33_1_WIFI,
MT6359_POWER_LDO_VAUX18,
MT6359_POWER_LDO_VSRAM_OTHERS,
MT6359_POWER_LDO_VEFUSE,
MT6359_POWER_LDO_VXO22,
MT6359_POWER_LDO_VRFCK,
MT6359_POWER_LDO_VBIF28,
MT6359_POWER_LDO_VIO28,
MT6359_POWER_LDO_VEMC,
MT6359_POWER_LDO_VCN33_2_BT,
MT6359_POWER_LDO_VCN33_2_WIFI,
MT6359_POWER_LDO_VA12,
MT6359_POWER_LDO_VA09,
MT6359_POWER_LDO_VRF18,
MT6359_POWER_LDO_VSRAM_MD,
MT6359_POWER_LDO_VUFS,
MT6359_POWER_LDO_VM18,
MT6359_POWER_LDO_VBBCK,
MT6359_POWER_LDO_VSRAM_PROC1,
MT6359_POWER_LDO_VSIM2,
MT6359_LDO_COUNT_END
};
#endif /* _MT_REGULATOR_CODEGEN_H_ */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,164 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_BUCK_H_
#define _MT_PMIC_API_BUCK_H_
void vmd1_pmic_setting_on(void);
void vmd1_pmic_setting_off(void);
int vcore_pmic_set_mode(unsigned char mode);
int vproc_pmic_set_mode(unsigned char mode);
void wk_auxadc_bgd_ctrl(unsigned char en);
void wk_auxadc_bgd_ctrl_dbg(void);
#ifdef LP_GOLDEN_SETTING
#define LGS
#endif
#ifdef LP_GOLDEN_SETTING_W_SPM
#define LGSWS
#endif
#if defined(LGS) || defined(LGSWS)
#define PMIC_LP_BUCK_ENTRY(reg) {reg, MT6390_BUCK_##reg##_CON0}
#define PMIC_LP_LDO_ENTRY(reg) {reg, MT6390_LDO_##reg##_CON0}
#define PMIC_LP_LDO_VCN33_0_ENTRY(reg) {reg, MT6390_LDO_VCN33_CON0_0}
#define PMIC_LP_LDO_VCN33_1_ENTRY(reg) {reg, MT6390_LDO_VCN33_CON0_1}
#define PMIC_LP_LDO_VLDO28_0_ENTRY(reg) {reg, MT6390_LDO_VLDO28_CON0_0}
#define PMIC_LP_LDO_VLDO28_1_ENTRY(reg) {reg, MT6390_LDO_VLDO28_CON0_1}
#define PMIC_LP_LDO_VUSB33_0_ENTRY(reg) {reg, MT6390_LDO_VUSB33_CON0_0}
#define PMIC_LP_LDO_VUSB33_1_ENTRY(reg) {reg, MT6390_LDO_VUSB33_CON0_1}
#endif
enum BUCK_LDO_EN_USER {
SW,
SPM = SW,
SRCLKEN0,
SRCLKEN1,
SRCLKEN2,
SRCLKEN3,
};
#define HW_OFF 0
#define HW_LP 1
#define SW_OFF 0
#define SW_ON 1
#define SW_LP 3
#define SPM_OFF 0
#define SPM_ON 1
#define SPM_LP 3
enum PMU_LP_TABLE_ENUM {
VPROC,
VCORE,
VMODEM,
VS1,
VPA,
VSRAM_PROC,
VSRAM_OTHERS,
VFE28,
VXO22,
VRF18,
VRF12,
VEFUSE,
VCN33_0,
VCN33_1,
VCN28,
VCN18,
VCAMA,
VCAMD,
VCAMIO,
VLDO28_0,
VLDO28_1,
VAUX18,
VAUD28,
VIO28,
VIO18,
VDRAM,
VMC,
VMCH,
VEMC,
VSIM1,
VSIM2,
VIBR,
VUSB33_0,
VUSB33_1,
TREF,
TABLE_COUNT_END
};
struct PMU_LP_TABLE_ENTRY {
enum PMU_LP_TABLE_ENUM flagname;
#if defined(LGS) || defined(LGSWS)
unsigned short en_adr;
#endif
};
extern int pmic_buck_vproc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vcore_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vmodem_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vs1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_buck_vpa_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_proc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsram_others_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vfe28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vxo22_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vrf18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vrf12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vefuse_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcn18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcama_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcamd_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vcamio_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vldo28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vaux18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vaud28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vio28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vio18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vdram_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vmch_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vemc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsim1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vsim2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vibr_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_vusb33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
extern int pmic_ldo_tref_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg);
#endif
@@ -0,0 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_API_LDO_H_
#define _MT_PMIC_API_LDO_H_
#endif /* _MT_PMIC_API_LDO_H_ */
@@ -0,0 +1,65 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_INFO_H_
#define _MT_PMIC_INFO_H_
/*
* The CHIP INFO
*/
#define PMIC6357_E1_CID_CODE 0x5710
#define PMIC6357_E2_CID_CODE 0x5720
#define PMIC6357_E3_CID_CODE 0x5730
#define PMIC6390_E1_CID_CODE 0x9010
#ifdef CONFIG_MTK_TINYSYS_SSPM_SUPPORT
#define IPIMB
#endif
/*
* Debugfs
*/
#define PMICTAG "[PMIC] "
extern unsigned int gPMICDbgLvl;
extern unsigned int gPMICHKDbgLvl;
extern unsigned int gPMICCOMDbgLvl;
extern unsigned int gPMICIRQDbgLvl;
extern unsigned int gPMICREGDbgLvl;
#define PMIC_LOG_DBG 4
#define PMIC_LOG_INFO 3
#define PMIC_LOG_NOT 2
#define PMIC_LOG_WARN 1
#define PMIC_LOG_ERR 0
#define PMICLOG(fmt, arg...) do { \
if (gPMICDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define HKLOG(fmt, arg...) do { \
if (gPMICHKDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define COMLOG(fmt, arg...) do { \
if (gPMICCOMDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define IRQLOG(fmt, arg...) do { \
if (gPMICIRQDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
#define RGLTRLOG(fmt, arg...) do { \
if (gPMICREGDbgLvl >= PMIC_LOG_DBG) \
pr_notice(PMICTAG "%s: " fmt, __func__, ##arg); \
} while (0)
extern void wk_pmic_enable_sdn_delay(void);
#endif /* _MT_PMIC_INFO_H_ */
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_PMIC_IRQ_H
#define __MT_PMIC_IRQ_H
#define PMIC_INT_WIDTH 16
#define PMIC_SP_IRQ_GEN(_used, _level_trig, _name) \
{ \
.used = _used, \
.level_trig = _level_trig, \
.name = #_name, \
}
#define PMIC_SP_INTS_GEN(sp, _con_len, _sp_irqs, _top_int_bit) \
{ \
.enable = MT6390_##sp##_INT_CON0, \
.mask = MT6390_##sp##_INT_MASK_CON0, \
.status = MT6390_##sp##_INT_STATUS0, \
.raw_status = MT6390_##sp##_INT_RAW_STATUS0, \
.con_len = _con_len, \
.int_offset = SP_##sp##_START, \
.sp_irqs = _sp_irqs, \
.top_int_bit = _top_int_bit, \
}
struct pmic_sp_irq {
unsigned short used;
unsigned short level_trig;
const char *name;
void (*callback)(void);
void (*oc_callback)(enum PMIC_IRQ_ENUM intNo, const char *name);
unsigned int times;
};
struct pmic_sp_interrupt {
unsigned int enable;
unsigned int mask;
unsigned int status;
unsigned int raw_status;
unsigned int con_len;
unsigned int int_offset; /* start intNo of this subpack */
struct pmic_sp_irq (*sp_irqs)[PMIC_INT_WIDTH];
unsigned int top_int_bit;
};
#define ENABLE_ALL_OC_IRQ 0
#endif /*--PMIC_IRQ_H--*/
@@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_PMIC_REGULATOR_H_
#define _MT_PMIC_REGULATOR_H_
#endif /* _MT_PMIC_REGULATOR_H_ */
@@ -0,0 +1,165 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MT_REGULATOR_CODEGEN_H_
#define _MT_REGULATOR_CODEGEN_H_
extern struct mtk_regulator mt_ldos[], mt_bucks[];
extern struct of_regulator_match pmic_regulator_buck_matches[];
extern struct of_regulator_match pmic_regulator_ldo_matches[];
extern int mt_ldos_size, mt_bucks_size;
extern int pmic_regulator_ldo_matches_size, pmic_regulator_buck_matches_size;
/* -------Code Gen Start-------*/
/* Non regular voltage regulator */
#define NON_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, array, \
array_idx, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ARRAY_SIZE(array), \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.pvoltages = (void *)(array), \
.idxs = (void *)(array_idx), \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6390_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6390_upmu_set_rg_##_name##_vosel, \
.da_en_cb = mt6390_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6390_upmu_get_rg_##_name##_vosel, \
.isUsedable = (use), \
}
/* Regular voltage regulator */
#define REGULAR_VOLTAGE_REGULATOR_LDO_GEN(_name, _type, min, max, \
step, min_sel, mode, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6390_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6390_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6390_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6390_upmu_get_da_##_name##_vosel, \
.isUsedable = (use), \
}
#define REGULAR_VOLTAGE_REGULATOR_BUCK_GEN(_name, _type, min, max, \
step, min_sel, mode, _modeset_reg, use) \
{ \
.desc = { \
.name = #_name, \
.n_voltages = ((max) - (min)) / (step) + 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.min_uV = (min), \
.uV_step = (step), \
.linear_min_sel = min_sel, \
.of_map_mode = mt6390_map_mode, \
}, \
.constraints = { \
.valid_ops_mask = (mode), \
.valid_modes_mask = REGULATOR_MODE_NORMAL|REGULATOR_MODE_FAST,\
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6390_upmu_set_rg_##_type##_##_name##_en, \
.vol_cb = mt6390_upmu_set_rg_##_type##_##_name##_vosel, \
.da_en_cb = mt6390_upmu_get_da_##_name##_en, \
.da_vol_cb = mt6390_upmu_get_da_##_name##_vosel, \
.modeset_reg = _modeset_reg, \
.isUsedable = (use), \
}
/* Fixed voltage regulator */
#define FIXED_REGULAR_VOLTAGE_REGULATOR_GEN(_name, _type, fixed, mode, use)\
{ \
.desc = { \
.name = #_name, \
.n_voltages = 1, \
.ops = &pmic_##_type##_##_name##_ops, \
.type = REGULATOR_VOLTAGE, \
.fixed_uV = (fixed), \
}, \
.init_data = { \
.constraints = { \
.valid_ops_mask = (mode), \
}, \
}, \
.en_att = __ATTR(_type##_##_name##_status, 0664, \
show_regulator_status, store_regulator_status), \
.voltage_att = __ATTR(_type##_##_name##_voltage, 0664, \
show_regulator_voltage, store_regulator_voltage), \
.en_cb = mt6390_upmu_set_rg_##_type##_##_name##_en, \
.da_en_cb = mt6390_upmu_get_da_##_name##_en, \
.isUsedable = (use), \
}
enum MT6390_POWER_BUCK {
MT6390_POWER_BUCK_VS1,
MT6390_POWER_BUCK_VMODEM,
MT6390_POWER_BUCK_VCORE,
MT6390_POWER_BUCK_VPROC,
MT6390_POWER_BUCK_VPA,
MT6390_BUCK_COUNT_END
};
enum MT6390_POWER_LDO {
MT6390_POWER_LDO_VFE28,
MT6390_POWER_LDO_VXO22,
MT6390_POWER_LDO_VRF18,
MT6390_POWER_LDO_VRF12,
MT6390_POWER_LDO_VEFUSE,
MT6390_POWER_LDO_VCN33_BT,
MT6390_POWER_LDO_VCN33_WIFI,
MT6390_POWER_LDO_VCN28,
MT6390_POWER_LDO_VCN18,
MT6390_POWER_LDO_VCAMA,
MT6390_POWER_LDO_VCAMD,
MT6390_POWER_LDO_VCAMIO,
MT6390_POWER_LDO_VLDO28,
MT6390_POWER_LDO_VSRAM_OTHERS,
MT6390_POWER_LDO_VSRAM_PROC,
MT6390_POWER_LDO_VAUX18,
MT6390_POWER_LDO_VAUD28,
MT6390_POWER_LDO_VIO28,
MT6390_POWER_LDO_VIO18,
MT6390_POWER_LDO_VDRAM,
MT6390_POWER_LDO_VMC,
MT6390_POWER_LDO_VMCH,
MT6390_POWER_LDO_VEMC,
MT6390_POWER_LDO_VSIM1,
MT6390_POWER_LDO_VSIM2,
MT6390_POWER_LDO_VIBR,
MT6390_POWER_LDO_VUSB33,
MT6390_LDO_COUNT_END
};
#endif /* _MT_REGULATOR_CODEGEN_H_ */
@@ -0,0 +1,58 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MT_RT5738_H
#define __MT_RT5738_H
/* Custom RT5738_NAME */
#define RT5738_NAME_0 "ext_buck_lp4"
#define RT5738_NAME_1 "ext_buck_lp4x"
#define RT5738_NAME_2 "ext_buck_vgpu"
/*#define RT5738_IS_EXIST_NAME RT5738_NAME_2 */
/* RT5738 operation register */
#define RT5738_REG_VSEL0 (0x00)
#define RT5738_REG_VSEL1 (0x01)
#define RT5738_REG_CTRL1 (0x02)
#define RT5738_REG_ID1 (0x03)
#define RT5738_REG_ID2 (0x04)
#define RT5738_REG_MONITOR (0x05)
#define RT5738_REG_CTRL2 (0x06)
#define RT5738_REG_CTRL3 (0x07)
#define RT5738_REG_CTRL4 (0x08)
/* Hidden mode */
/* #define RT5738_REG_CTRL5 (0x09) */
#if defined(RT5738_NAME_0)
#define RT5738_CMPT_STR_0 "mediatek,ext_buck_lp4"
#define RT5738_VSEL_0 RT5738_REG_VSEL0
#define RT5738_CTRL_0 RT5738_REG_CTRL1
#define RT5738_CTRL_BIT_0 0x01
#define RT5738_EN_0 RT5738_REG_MONITOR
#define RT5738_EN_BIT_0 0x01
#endif
#if defined(RT5738_NAME_1)
#define RT5738_CMPT_STR_1 "mediatek,ext_buck_lp4x"
#define RT5738_VSEL_1 RT5738_REG_VSEL1
#define RT5738_CTRL_1 RT5738_REG_CTRL1
#define RT5738_CTRL_BIT_1 0x02
#define RT5738_EN_1 RT5738_REG_MONITOR
#define RT5738_EN_BIT_1 0x02
#endif
#if defined(RT5738_NAME_2)
#define RT5738_CMPT_STR_2 "mediatek,ext_buck_vgpu"
#define RT5738_VSEL_2 RT5738_REG_VSEL1
#define RT5738_CTRL_2 RT5738_REG_CTRL1
#define RT5738_CTRL_BIT_2 0x01
#define RT5738_EN_2 RT5738_REG_MONITOR
#define RT5738_EN_BIT_2 0x01
#endif
#endif /*--__MT_RT5738_H--*/
@@ -0,0 +1,19 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _MTK_PMIC_COMMON_H_
#define _MTK_PMIC_COMMON_H_
#include <linux/device.h>
#include <linux/pm_wakeup.h>
#define PMIC_ENTRY(reg) {reg, reg##_ADDR, reg##_MASK, reg##_SHIFT}
#define pmic_init_wake_lock(lock, name) wakeup_source_init(lock, name)
#define pmic_wake_lock(lock) __pm_stay_awake(lock)
#define pmic_wake_unlock(lock) __pm_relax(lock)
extern struct wakeup_source pmicThread_lock;
#endif /* _MTK_PMIC_COMMON_H_ */
+169
View File
@@ -0,0 +1,169 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_SW_H_
#define _PMIC_SW_H_
#define PMIC_DEBUG
#include <linux/smp.h>
#include <linux/device.h>
#include <linux/debugfs.h>
#include <linux/printk.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/consumer.h>
#include <mach/upmu_hw.h>
#include <mach/upmu_sw.h>
#include "mtk_pmic_common.h"
#ifdef CONFIG_MTK_PMIC_CHIP_MT6353
#include "mt6353/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6335
#include "mt6335/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
#include "mt6355/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6356
#include "mt6356/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
#include "mt6357/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
#include "mt6358/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359
#include "mt6359/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359P
#include "mt6359p/mtk_pmic_info.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6390
#include "mt6390/mtk_pmic_info.h"
#endif
#define PMIC_EN REGULATOR_CHANGE_STATUS
#define PMIC_VOL REGULATOR_CHANGE_VOLTAGE
#define PMIC_EN_VOL 9
/*
* PMIC EXTERN VARIABLE
*/
/*----- LOW_BATTERY_PROTECT -----*/
extern int g_lowbat_int_bottom;
extern int g_low_battery_level;
/*----- BATTERY_OC_PROTECT -----*/
extern int g_battery_oc_level;
/* for chip version used */
extern unsigned int g_pmic_chip_version;
/* for recording MD power vosel */
extern unsigned short g_vmodem_vosel;
/*
* PMIC EXTERN FUNCTIONS
*/
/*----- BATTERY_OC_PROTECT -----*/
extern void exec_battery_oc_callback(BATTERY_OC_LEVEL battery_oc_level);
extern void bat_oc_h_en_setting(int en_val);
extern void bat_oc_l_en_setting(int en_val);
/*----- CHRDET_PROTECT -----*/
#ifdef CONFIG_MTK_KERNEL_POWER_OFF_CHARGING
extern unsigned int upmu_get_rgs_chrdet(void);
#endif
/*----- PMIC thread -----*/
extern void pmic_enable_charger_detection_int(int x);
/*----- LDO OC -----*/
extern void msdc_sd_power_off(void);
/*----- REGULATOR -----*/
extern int mtk_regulator_init(struct platform_device *dev);
extern unsigned int pmic_config_interface_buck_vsleep_check(unsigned int RegNum,
unsigned int val, unsigned int MASK, unsigned int SHIFT);
extern void pmic_regulator_debug_init(
struct platform_device *dev, struct dentry *debug_dir);
extern void pmic_regulator_suspend(void);
extern void pmic_regulator_resume(void);
/*----- EFUSE -----*/
extern int pmic_read_VMC_efuse(void);
/*----- Others -----*/
extern int PMIC_POWER_HOLD(unsigned int hold);
extern void mt_power_off(void);
extern const PMU_FLAG_TABLE_ENTRY pmu_flags_table[];
extern unsigned int bat_get_ui_percentage(void);
extern signed int fgauge_read_IM_current(void *data);
extern void pmic_auxadc_lock(void);
extern void pmic_auxadc_unlock(void);
extern unsigned int bat_get_ui_percentage(void);
extern signed int fgauge_read_v_by_d(int d_val);
extern signed int fgauge_read_r_bat_by_v(signed int voltage);
extern void kpd_pwrkey_pmic_handler(unsigned long pressed);
extern void kpd_pmic_rstkey_handler(unsigned long pressed);
extern int is_mt6311_sw_ready(void);
extern int is_mt6311_exist(void);
extern int get_mt6311_i2c_ch_num(void);
#if !defined CONFIG_MTK_LEGACY
extern void pmu_drv_tool_customization_init(void);
#endif
extern int batt_init_cust_data(void);
extern unsigned int mt_gpio_to_irq(unsigned int gpio);
extern int mt_gpio_set_debounce(unsigned int gpio, unsigned int debounce);
extern unsigned int upmu_get_rgs_chrdet(void);
#ifdef CONFIG_MTK_PMIC_COMMON
extern int PMIC_check_battery(void);
extern int PMIC_check_wdt_status(void);
extern int PMIC_check_pwrhold_status(void);
extern void PMIC_LP_INIT_SETTING(void);
extern int PMIC_MD_INIT_SETTING_V1(void);
extern void PMIC_PWROFF_SEQ_SETTING(void);
extern int pmic_tracking_init(void);
#endif
extern unsigned int PMIC_CHIP_VER(void);
extern void record_md_vosel(void);
/*---------------------------------------------------*/
struct regulator;
struct mtk_regulator_vosel {
unsigned int def_sel; /*-- default vosel --*/
unsigned int cur_sel; /*-- current vosel --*/
bool restore;
};
struct mtk_regulator {
struct regulator_desc desc;
/* init_data and config may be removed */
struct regulator_init_data init_data;
struct regulator_config config;
struct regulation_constraints constraints;
struct device_attribute en_att;
struct device_attribute voltage_att;
struct regulator_dev *rdev;
PMU_FLAGS_LIST_ENUM en_reg;
PMU_FLAGS_LIST_ENUM vol_reg;
PMU_FLAGS_LIST_ENUM qi_en_reg;
PMU_FLAGS_LIST_ENUM qi_vol_reg;
PMU_FLAGS_LIST_ENUM modeset_reg;
PMU_FLAGS_LIST_ENUM lp_mode_reg;
const int *pvoltages;
const int *idxs;
bool isUsedable;
struct regulator *reg;
int vsleep_en_saved;
/*--- Add to record selector ---*/
struct mtk_regulator_vosel vosel;
/*--- BUCK/LDO ---*/
const char *type;
unsigned int (*en_cb)(unsigned int parm);
unsigned int (*vol_cb)(unsigned int parm);
unsigned int (*da_en_cb)(void);
unsigned int (*da_vol_cb)(void);
};
#endif /* _PMIC_SW_H_ */
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_API_H_
#define _PMIC_API_H_
#ifdef CONFIG_MTK_PMIC_CHIP_MT6353
#include "mt6353/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6335
#include "mt6335/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
#include "mt6355/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6356
#include "mt6356/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
#include "mt6357/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
#include "mt6358/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359
#include "mt6359/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359P
#include "mt6359p/mtk_pmic_api.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6390
#include "mt6390/mtk_pmic_api.h"
#endif
#endif /* _PMIC_API_H_ */
@@ -0,0 +1,44 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_API_BUCK_H_
#define _PMIC_API_BUCK_H_
#ifdef CONFIG_MTK_PMIC_CHIP_MT6353
#include "mt6353/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6335
#include "mt6335/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
#include "mt6355/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6356
#include "mt6356/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
#include "mt6357/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
#include "mt6358/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359
#include "mt6359/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359P
#include "mt6359p/mtk_pmic_api_buck.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6390
#include "mt6390/mtk_pmic_api_buck.h"
#endif
#endif /* _PMIC_API_BUCK_H_ */
@@ -0,0 +1,32 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_API_LDO_H_
#define _PMIC_API_LDO_H_
#ifdef CONFIG_MTK_PMIC_CHIP_MT6353
#include "mt6353/mtk_pmic_api_ldo.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6335
#include "mt6335/mtk_pmic_api_ldo.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
#include "mt6355/mtk_pmic_api_ldo.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6356
#include "mt6356/mtk_pmic_api_ldo.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
#include "mt6357/mtk_pmic_api_ldo.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6390
#include "mt6390/mtk_pmic_api_ldo.h"
#endif
#endif /* _PMIC_API_LDO_H_ */
@@ -0,0 +1,23 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_AUXADC_H_
#define _PMIC_AUXADC_H_
#include <mach/upmu_hw.h>
extern bool is_isense_supported(void);
extern void pmic_auxadc_suspend(void);
extern void pmic_auxadc_resume(void);
extern void wk_auxadc_reset(void);
extern unsigned short pmic_set_hk_reg_value(
PMU_FLAGS_LIST_ENUM flagname, unsigned int val);
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
/* MT6358 add it */
extern int wk_vbat_cali(int vbat_out, int precision_factor);
#endif
#endif /* _PMIC_AUXADC_H_ */
@@ -0,0 +1,15 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_BIF_INTF_H
#define __MTK_BIF_INTF_H
extern int mtk_bif_init(void);
extern int mtk_bif_get_vbat(int *vbat);
extern int mtk_bif_get_tbat(int *tbat);
extern bool mtk_bif_is_hw_exist(void);
extern int pmic_bif_init(void);
#endif /* __MTK_BIF_INTF_H */
@@ -0,0 +1,46 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PMIC_DEBUGFS_H__
#define __PMIC_DEBUGFS_H__
#include <linux/dcache.h>
#define adb_output_reg(reg) \
seq_printf(s, "[pmic_boot_status] " #reg " Reg[0x%x]=0x%x\n", \
reg, upmu_get_reg_value(reg))
#define kernel_output_reg(reg) \
pr_notice("[pmic_boot_status] " #reg " Reg[0x%x]=0x%x\n", \
reg, upmu_get_reg_value(reg))
#define both_output_reg(reg) \
do { \
seq_printf(s, "[pmic_boot_status] " #reg " Reg[0x%x]=0x%x\n", \
reg, upmu_get_reg_value(reg)); \
pr_notice("[pmic_boot_status] " #reg " Reg[0x%x]=0x%x\n", \
reg, upmu_get_reg_value(reg)); \
} while (0)
#define PMIC_LOG_DBG 4
#define PMIC_LOG_INFO 3
#define PMIC_LOG_NOT 2
#define PMIC_LOG_WARN 1
#define PMIC_LOG_ERR 0
/* extern variable */
extern struct dentry *mtk_pmic_dir;
extern unsigned int gPMICDbgLvl;
/* extern function */
extern void kernel_dump_exception_reg(void);
#ifdef CONFIG_MTK_PMIC_COMMON
extern int pmic_debug_init(struct platform_device *dev);
extern unsigned int pmic_dbg_level_set(unsigned int level);
extern void pmic_cmp_register(struct seq_file *m);
extern void pmic_dump_register(struct seq_file *m);
extern void both_dump_exception_reg(struct seq_file *s);
extern int pmic_dump_exception_reg(void);
#endif /*--CONFIG_MTK_PMIC_COMMON--*/
#endif /* __PMIC_DEBUGFS_H__ */
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_IPI_H_
#define _PMIC_IPI_H_
#define PMIC_IPI_SEND_SLOT_SIZE 0x5
#define PMIC_IPI_ACK_SLOT_SIZE 0x2
struct pmic_ipi_cmds {
unsigned int cmd[PMIC_IPI_SEND_SLOT_SIZE];
};
struct pmic_ipi_ret_datas {
unsigned int data[PMIC_IPI_ACK_SLOT_SIZE];
};
extern void aee_rr_rec_set_bit_pmic_ext_buck(int bit, int loc);
#endif /* _PMIC_IPI_H_*/
@@ -0,0 +1,48 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PMIC_IPI_SERVICE_ID_H__
#define __PMIC_IPI_SERVICE_ID_H__
/* Generated timestamp for comparison */
#define CODEGEN_DATECODE 20160309
#define CODEGEN_TIMECODE 152446
/* PMIC IPI service */
#define PMIC_IPI_SERVICE_NUM 5
/* Invalid IPI service ID */
#define INVALID_PMIC_IPI_FUNC 0xFFFFFFFF
/* RESERVED: Reserved */
#define PMIC_IPI_FUNC_RESERVED_START 0x00000000
#define PMIC_IPI_FUNC_RESERVED_RANGE 0x00000100
/* PMICWRAPPER: PMICWrapper functions */
#define PMIC_IPI_FUNC_PMICWRAPPER_START 0x00000100
#define PMIC_IPI_FUNC_PMICWRAPPER_RANGE 0x00000100
/* MAIN_PMIC: Main PMIC functions */
#define PMIC_IPI_FUNC_MAIN_PMIC_START 0x00000200
#define PMIC_IPI_FUNC_MAIN_PMIC_RANGE 0x00000100
/* SUB_PMIC: Sub PMIC functions */
#define PMIC_IPI_FUNC_SUB_PMIC_START 0x00000300
#define PMIC_IPI_FUNC_SUB_PMIC_EN 0x00000301
#define PMIC_IPI_FUNC_SUB_PMIC_RANGE 0x00000100
/* EXT_POWER_XXX: Ext. PMIC functions */
#define PMIC_IPI_FUNC_EXT_POWER_XXX_START 0x00000400
#define PMIC_IPI_FUNC_EXT_POWER_XXX_RANGE 0x00000100
#define MAIN_PMIC_WRITE_REGISTER 0x00000201
#define MAIN_PMIC_READ_REGISTER 0x00000202
#define MAIN_PMIC_REGULATOR 0x00000203
#define SUB_PMIC_CTRL 0x00000204
#define MT6311_FPWM 0x00000205
#define RT5738_FPWM 0x00000206
#endif /* __PMIC_IPI_SERVICE_ID_H__ */
@@ -0,0 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PMIC_IRQ_H
#define __PMIC_IRQ_H
#include <linux/platform_device.h>
#include "mtk_pmic_irq.h"
#ifndef PMIC_INT_WIDTH
#define PMIC_INT_WIDTH 16
#endif
#define PMIC_S_INT_GEN(_name) \
{ \
.name = #_name, \
}
struct pmic_irq_dbg_st {
unsigned int dbg_id;
};
/* pmic irq extern functions */
extern void PMIC_EINT_SETTING(struct platform_device *pdev);
extern int pmic_irq_debug_init(struct dentry *debug_dir);
void buck_oc_detect(void);
#endif /*--PMIC_IRQ_H--*/
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PMIC_LBAT_SERVICE_H__
#define __PMIC_LBAT_SERVICE_H__
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
struct lbat_thd_t;
struct lbat_user {
char name[30];
struct lbat_thd_t *hv_thd;
struct lbat_thd_t *lv1_thd;
struct lbat_thd_t *lv2_thd;
void (*callback)(unsigned int thd_volt);
unsigned int deb_cnt;
struct lbat_thd_t *deb_thd_ptr;
unsigned int hv_deb_prd;
unsigned int hv_deb_times;
unsigned int lv_deb_prd;
unsigned int lv_deb_times;
struct timer_list deb_timer;
struct work_struct deb_work;
struct list_head thd_list;
};
/* extern function */
extern int lbat_service_init(struct platform_device *pdev);
extern struct lbat_user *lbat_user_register_ext(const char *name,
unsigned int *thd_volt_arr, unsigned int thd_volt_size,
void (*callback)(unsigned int thd_volt));
extern struct lbat_user *lbat_user_register(const char *name, unsigned int hv_thd_volt,
unsigned int lv1_thd_volt,
unsigned int lv2_thd_volt,
void (*callback)(unsigned int thd_volt));
extern int lbat_user_set_debounce(struct lbat_user *user,
unsigned int hv_deb_prd, unsigned int hv_deb_cnt,
unsigned int lv_deb_prd, unsigned int lv_deb_cnt);
extern void lbat_suspend(void);
extern void lbat_resume(void);
extern unsigned int lbat_read_raw(void);
extern unsigned int lbat_read_volt(void);
extern void lbat_dump_reg(void);
extern int lbat_debug_init(struct dentry *debug_dir);
#endif /* __PMIC_LBAT_SERVICE_H__ */
@@ -0,0 +1,50 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_REGULATOR_H_
#define _PMIC_REGULATOR_H_
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/regulator/of_regulator.h>
#include <linux/of_device.h>
#include <linux/of_fdt.h>
#endif
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/consumer.h>
#include "include/pmic.h"
#define REGULATOR_READY
/*#define REGULATOR_TEST 0*/
extern struct mtk_regulator mtk_ldos[];
extern struct of_regulator_match pmic_regulator_matches[];
extern int mtk_ldos_size;
extern int pmic_regulator_matches_size;
#ifndef CONFIG_MTK_PMIC_CHIP_MT6353
#ifdef CONFIG_MTK_PMIC_CHIP_MT6335
/*---extern variable---*/
extern struct mtk_bucks_t mtk_bucks_class[];
/*---extern function---*/
extern int buck_is_enabled(enum BUCK_TYPE type);
extern int buck_enable(enum BUCK_TYPE type, unsigned char en);
extern int buck_set_mode(enum BUCK_TYPE type, unsigned char pmode);
extern int buck_set_voltage(enum BUCK_TYPE type, unsigned int voltage);
extern unsigned int buck_get_voltage(enum BUCK_TYPE type);
#endif /*--COMMON API after MT6335--*/
#endif /*--COMMON API after MT6353--*/
#ifdef REGULATOR_TEST
extern void pmic_regulator_en_test(void);
extern void pmic_regulator_vol_test(void);
#endif /*--REGULATOR_TEST--*/
#endif /* _PMIC_REGULATOR_H_ */
@@ -0,0 +1,39 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _PMIC_THROTTLING_DLPT_H_
#define _PMIC_THROTTLING_DLPT_H_
#include <linux/dcache.h>
#include <linux/platform_device.h>
/* just use in suspend flow for important log due to console suspend */
#ifdef CONFIG_MTK_AEE_FEATURE
#if defined PMIC_DEBUG_PR_DBG
#define pmic_spm_crit2(fmt, args...) pr_notice("[SPM-PMIC] " fmt, ##args)
#else
#define pmic_spm_crit2(fmt, args...) pr_info("[SPM-PMIC] " fmt, ##args)
#endif
#else
#define pmic_spm_crit2(fmt, args...)
#endif
extern int pmic_throttling_dlpt_init(struct platform_device *pdev);
extern void pmic_throttling_dlpt_suspend(void);
extern void pmic_throttling_dlpt_resume(void);
extern void pmic_throttling_dlpt_debug_init(
struct platform_device *dev, struct dentry *debug_dir);
extern int get_rac(void);
extern int get_imix(void);
extern int do_ptim_ex(bool isSuspend, unsigned int *bat, signed int *cur);
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
extern void mt6355_auxadc_dump_setting_regs(void);
extern void mt6355_auxadc_dump_clk_regs(void);
extern void mt6355_auxadc_dump_channel_regs(void);
#endif
#endif /* _PMIC_THROTTLING_DLPT_H_ */
@@ -0,0 +1,70 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef _REGULATOR_CODEGEN_H_
#define _REGULATOR_CODEGEN_H_
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/regulator/of_regulator.h>
#include <linux/of_device.h>
#include <linux/of_fdt.h>
#endif
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/consumer.h>
#include <mach/upmu_hw.h>
#include <mach/upmu_sw.h>
#ifdef CONFIG_MTK_PMIC_CHIP_MT6335
#include "mt6335/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6353
#include "mt6353/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6355
#include "mt6355/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6356
#include "mt6356/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6357
#include "mt6357/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6358
#include "mt6358/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359
#include "mt6359/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6359P
#include "mt6359p/mtk_regulator_codegen.h"
#endif
#ifdef CONFIG_MTK_PMIC_CHIP_MT6390
#include "mt6390/mtk_regulator_codegen.h"
#endif
/*****************************************************************************
* PMIC extern function
******************************************************************************/
extern int mtk_regulator_enable(struct regulator_dev *rdev);
extern int mtk_regulator_disable(struct regulator_dev *rdev);
extern int mtk_regulator_is_enabled(struct regulator_dev *rdev);
extern int mtk_regulator_set_voltage_sel(
struct regulator_dev *rdev, unsigned int selector);
extern int mtk_regulator_get_voltage_sel(struct regulator_dev *rdev);
extern int mtk_regulator_list_voltage(
struct regulator_dev *rdev, unsigned int selector);
#endif /* _REGULATOR_CODEGEN_H_ */
@@ -0,0 +1 @@
obj-y += v1/
@@ -0,0 +1,44 @@
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic_wrap/$(CONFIG_MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include
ccflags-y += -I$(srctree)/drivers/power/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/mediatek/charger
ccflags-y += -I$(srctree)/drivers/power/mediatek/misc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/usb_c/tcpc/inc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/typec/tcpc/inc
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/charger
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/charger
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/typec/tcpc/inc
subdir-ccflags-y += -Werror -I$(srctree)/drivers/misc/mediatek/pmic/include
ifeq ($(CONFIG_MTK_TINYSYS_SSPM_SUPPORT), y)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/$(MTK_PLATFORM)/
obj-y += pmic_ipi.o
endif
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
obj-y += mt6357_gauge.o
obj-y += mt6357_charger.o
endif
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += pmic.o pmic_common.o \
pmic_debugfs.o \
pmic_irq.o \
pmic_initial_setting.o \
pmic_api.o \
pmic_auxadc.o \
pmic_throttling_dlpt.o \
regulator_codegen.o \
pmic_lp_api.o \
pmic_efuse.o \
# Charger Type Detection
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += pmic_chr_type_det_v2.o
else
obj-$(CONFIG_MTK_PMIC_CHIP_MT6357) += pmic_chr_type_det.o
endif
@@ -0,0 +1,513 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/device.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/types.h>
#include <mt-plat/upmu_common.h>
#include "include/pmic.h"
#include "mtk_charger_intf.h"
struct mt6357_charger_desc {
u32 ichg; /* uA */
u32 cv; /* uV */
u32 vcdt_hv_thres; /* uV */
u32 vbat_ov_thres; /* uV */
};
static struct mt6357_charger_desc mt6357_chg_default_desc = {
.ichg = 500000,
.cv = 4350000,
.vcdt_hv_thres = 7000000,
.vbat_ov_thres = 4450000,
};
struct mt6357_charger {
const char *charger_dev_name;
struct charger_properties charger_prop;
struct charger_device *charger_dev;
struct mt6357_charger_desc *desc;
};
static const u32 CS_VTH[] = {
2000000, 1600000, 1500000, 1350000,
1200000, 1100000, 1000000, 900000,
800000, 700000, 650000, 550000,
450000, 300000, 200000, 70000,
};
static const u32 VBAT_CV_VTH[] = {
3900000, 4000000, 4050000, 4100000,
4150000, 4200000, 4212500, 4225000,
4237500, 4250000, 4262500, 4275000,
4287500, 4300000, 4312500, 4325000,
4337500, 4350000, 4362500, 4375000,
4387500, 4400000, 4412500, 4425000,
4437500, 4450000, 4462500, 4475000,
4487500, 4500000, 4600000,
};
static const u32 VCDT_HV_VTH[] = {
3000000, 3900000, 4000000, 4100000,
4150000, 4200000, 4250000, 4300000,
4350000, 4400000, 4450000, 6000000,
6500000, 7000000, 7500000, 8500000,
9500000, 10500000, 11500000, 12500000,
14000000,
};
static const u32 VBAT_OV_VTH[] = {
4200000, 4200000, 4300000, 4400000,
4450000, 4500000, 4600000, 4700000,
};
static u32 charging_value_to_parameter(const u32 *parameter,
const u32 array_size,
const u32 val)
{
if (val < array_size)
return parameter[val];
chr_debug("Can't find the parameter\n");
return parameter[0];
}
static u32 charging_parameter_to_value(const u32 *parameter,
const u32 array_size,
const u32 val)
{
u32 i;
for (i = 0; i < array_size; i++) {
if (val == *(parameter + i))
return i;
}
pr_info("no register value matched\n");
return 0;
}
static u32 bmt_find_closest_level(const u32 *pList, u32 number, u32 level)
{
int i;
u32 max_value_in_last_element;
if (pList[0] < pList[1])
max_value_in_last_element = true;
else
max_value_in_last_element = false;
if (max_value_in_last_element == true) {
/* max value in the last element */
for (i = (number - 1); i >= 0; i--) {
if (pList[i] <= level) {
/* pr_debug("zzf_%d<=%d i=%d\n", pList[i], level, i); */
return pList[i];
}
}
chr_debug("Can't find closest level\n");
return pList[0];
}
/* max value in the first element */
for (i = 0; i < number; i++) {
if (pList[i] <= level)
return pList[i];
}
chr_debug("Can't find closest level\n");
return pList[number - 1];
}
static int mt6357_charger_parse_dt(struct mt6357_charger *info,
struct device *dev)
{
struct device_node *np = dev->of_node;
struct mt6357_charger_desc *desc = NULL;
pr_info("%s: starts\n", __func__);
if (!np) {
chr_err("%s: no device node\n", __func__);
return -EINVAL;
}
info->desc = &mt6357_chg_default_desc;
desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);
if (!desc)
return -ENOMEM;
memcpy(desc, &mt6357_chg_default_desc,
sizeof(struct mt6357_charger_desc));
if (of_property_read_string(np, "charger_name",
&info->charger_dev_name) < 0) {
chr_err("%s: no charger name\n", __func__);
info->charger_dev_name = "primary_chg";
}
if (of_property_read_string(np, "alias_name",
&info->charger_prop.alias_name) < 0) {
chr_err("%s: no alias name\n", __func__);
info->charger_prop.alias_name = "mt6357";
}
if (of_property_read_u32(np, "ichg", &desc->ichg) < 0)
chr_err("%s: no ichg\n", __func__);
if (of_property_read_u32(np, "cv", &desc->cv) < 0)
chr_err("%s: no cv\n", __func__);
if (of_property_read_u32(np, "vcdt_hv_thres", &desc->vcdt_hv_thres) < 0)
chr_err("%s: no vcdt_hv_thres\n", __func__);
if (of_property_read_u32(np, "vbat_ov_thres", &desc->vbat_ov_thres) < 0)
chr_err("%s: no vbat_ov_thres\n", __func__);
info->desc = desc;
pr_info("chr name:%s alias:%s\n",
info->charger_dev_name, info->charger_prop.alias_name);
return 0;
}
static int mt6357_plug_in(struct charger_device *chg_dev)
{
int ret = 0;
pmic_set_register_value(PMIC_RG_ULC_DET_EN, 1);
return ret;
}
static int mt6357_enable_charging(struct charger_device *chg_dev, bool en)
{
int ret = 0;
/* struct mt6357_charger *info = dev_get_drvdata(&chg_dev->dev); */
chr_debug("[%s] en: %d\n", __func__, en);
if (en) {
#if 0
pmic_set_register_value(PMIC_RG_CSDAC_DLY, 4);
pmic_set_register_value(PMIC_RG_CSDAC_STP, 1);
pmic_set_register_value(PMIC_RG_CSDAC_STP_INC, 1);
pmic_set_register_value(PMIC_RG_CSDAC_STP_DEC, 2);
#endif
pmic_set_register_value(PMIC_RG_CSDAC_MODE, 1);
pmic_set_register_value(PMIC_RG_CS_EN, 1);
pmic_set_register_value(PMIC_RG_ULC_DET_EN, 1);
pmic_set_register_value(PMIC_RG_HWCV_EN, 1);
pmic_set_register_value(PMIC_RG_VBAT_CV_EN, 1);
/* enable debug flag output */
pmic_set_register_value(PMIC_RG_PCHR_FLAG_EN, 1);
pmic_set_register_value(PMIC_RG_CSDAC_EN, 1);
pmic_set_register_value(PMIC_RG_CHR_EN, 1);
/* pmic_enable_interrupt(INT_WATCHDOG, 1, "PMIC"); */
} else {
/* pmic_set_register_value(PMIC_RG_INT_EN_WATCHDOG, 0);
* TODO: remove it
*/
/* pmic_enable_interrupt(INT_WATCHDOG, 0, "PMIC"); */
pmic_set_register_value(PMIC_RG_CHRWDT_EN, 0);
#if 0
pmic_set_register_value(PMIC_RG_CHRWDT_WR, 0); /* TODO */
pmic_set_register_value(PMIC_RG_CSDAC_EN, 0);
pmic_set_register_value(PMIC_RG_HWCV_EN, 0);
#endif
pmic_set_register_value(PMIC_RG_CHR_EN, 0);
}
return ret;
}
static int mt6357_is_charging_enabled(struct charger_device *chg_dev, bool *en)
{
unsigned short val;
val = pmic_get_register_value(PMIC_RG_CHR_EN);
*en = (val == 1) ? true : false;
return 0;
}
static int mt6357_get_ichg(struct charger_device *chg_dev, u32 *ichg)
{
int ret = 0;
u32 array_size;
u32 val;
array_size = ARRAY_SIZE(CS_VTH);
val = pmic_get_register_value(PMIC_RG_CS_VTH);
*ichg = charging_value_to_parameter(CS_VTH, array_size, val);
return ret;
}
static int mt6357_set_ichg(struct charger_device *chg_dev, u32 ichg)
{
int ret = 0;
u32 array_size;
u32 set_ichg, register_value;
array_size = ARRAY_SIZE(CS_VTH);
set_ichg = bmt_find_closest_level(CS_VTH, array_size, ichg);
register_value = charging_parameter_to_value(CS_VTH,
array_size, set_ichg);
ret = pmic_set_register_value(PMIC_RG_CS_VTH, register_value);
chr_debug("%s: 0x%x %d %d\n", __func__, register_value, ichg, set_ichg);
return ret;
}
static int mt6357_get_min_ichg(struct charger_device *chg_dev, u32 *uA)
{
u32 array_size;
array_size = ARRAY_SIZE(CS_VTH);
*uA = charging_value_to_parameter(CS_VTH, array_size, array_size - 1);
return 0;
}
static int mt6357_get_cv(struct charger_device *chg_dev, u32 *cv)
{
int ret = 0;
u32 array_size;
u32 val;
array_size = ARRAY_SIZE(VBAT_CV_VTH);
val = pmic_get_register_value(PMIC_RG_VBAT_CV_VTH);
*cv = charging_value_to_parameter(VBAT_CV_VTH, array_size, val);
return ret;
}
static int mt6357_set_cv(struct charger_device *chg_dev, u32 cv)
{
int ret = 0;
u32 array_size;
u32 set_cv, register_value;
array_size = ARRAY_SIZE(VBAT_CV_VTH);
set_cv = bmt_find_closest_level(VBAT_CV_VTH, array_size, cv);
register_value = charging_parameter_to_value(VBAT_CV_VTH,
array_size, set_cv);
pmic_set_register_value(PMIC_RG_VBAT_CV_VTH, register_value);
chr_debug("%s: cv = %d mV (0x%x)\n", __func__, set_cv, register_value);
return ret;
}
static int mt6357_kick_wdt(struct charger_device *chg_dev)
{
int ret = 0;
chr_debug("%s\n", __func__);
#if 0
pmic_set_register_value(PMIC_RG_CHRWDT_TD, 3); /* 32s */
/* TODO: register interrupt callback!? */
pmic_set_register_value(PMIC_RG_INT_EN_WATCHDOG, 1);
pmic_set_register_value(PMIC_RG_CHRWDT_EN, 1);
#endif
pmic_set_register_value(PMIC_RG_CHRWDT_WR, 1);
return ret;
}
static int mt6357_dump_register(struct charger_device *chg_dev)
{
int ret = 0;
u32 i = 0;
u32 ichg = 0, cv = 0;
bool chg_en = false;
ret = mt6357_get_ichg(chg_dev, &ichg);
ret = mt6357_get_cv(chg_dev, &cv);
ret = mt6357_is_charging_enabled(chg_dev, &chg_en);
for (i = MT6357_CHR_TOP_CON0; i <= MT6357_PCHR_ELR1; i += 2)
chr_debug("[0x%x]=0x%x\t", i, upmu_get_reg_value(i));
chr_debug("\n");
for (i = MT6357_CHR_CON0; i <= MT6357_CHR_CON9; i += 2)
chr_debug("[0x%x]=0x%x\t", i, upmu_get_reg_value(i));
chr_debug("\n");
pr_info("ICHG = %dmA, CV = %dmV, CHG_EN = %d\n",
ichg / 1000, cv / 1000, chg_en);
return ret;
}
static int mt6357_do_event(struct charger_device *chg_dev, u32 event, u32 args)
{
switch (event) {
case EVENT_EOC:
charger_dev_notify(chg_dev, CHARGER_DEV_NOTIFY_EOC);
break;
case EVENT_RECHARGE:
charger_dev_notify(chg_dev, CHARGER_DEV_NOTIFY_RECHG);
break;
default:
break;
}
return 0;
}
static struct charger_ops mt6357_charger_ops = {
/* normal charging */
.plug_in = mt6357_plug_in,
/* .plug_out = mt6357_plug_out, */
.enable = mt6357_enable_charging,
.is_enabled = mt6357_is_charging_enabled,
.get_charging_current = mt6357_get_ichg,
.set_charging_current = mt6357_set_ichg,
.get_min_charging_current = mt6357_get_min_ichg,
.get_constant_voltage = mt6357_get_cv,
.set_constant_voltage = mt6357_set_cv,
.kick_wdt = mt6357_kick_wdt,
.dump_registers = mt6357_dump_register,
/* Event */
.event = mt6357_do_event,
};
static void watchdog_int_handler(void)
{
pr_notice("mt6357 CHRWDT IRQ\n");
}
static int mt6357_charger_init_setting(struct mt6357_charger *info)
{
int ret = 0;
unsigned short val;
val = pmic_get_register_value(PMIC_RG_VBAT_CV_VTH);
pr_info("[%s] VBAT_CV_VTH: 0x%x\n", __func__, val);
#if 0 /* TODO */
ret = mt6357_set_ichg(info);
#endif
pmic_set_register_value(PMIC_RG_CHRWDT_TD, 3); /* 32s */
pmic_set_register_value(PMIC_RG_CHRWDT_EN, 1);
pmic_set_register_value(PMIC_RG_CHRWDT_WR, 1);
#if 1 /* TODO: Default value */
pmic_set_register_value(PMIC_RG_VCDT_MODE, 0);
pmic_set_register_value(PMIC_RG_VCDT_HV_EN, 1);
/* force leave USBDL mode */
pmic_set_register_value(PMIC_RG_USBDL_SET, 0);
pmic_set_register_value(PMIC_RG_USBDL_RST, 1);
pmic_set_register_value(PMIC_RG_BC11_BB_CTRL, 1);
pmic_set_register_value(PMIC_RG_BC11_RST, 1);
pmic_set_register_value(PMIC_RG_VBAT_OV_EN, 1);
#endif
pmic_set_register_value(PMIC_RG_CSDAC_MODE, 1); /* CC mode */
/* TODO */
pmic_set_register_value(PMIC_RG_VBAT_OV_VTH, 4); /* 4450mV */
pmic_set_register_value(PMIC_RG_VCDT_HV_VTH, 0xd); /* 7000mV */
pmic_set_register_value(PMIC_RG_ULC_DET_EN, 1);
/* pmic_set_register_value(PMIC_RG_LOW_ICH_DB, 1); 16ms */
/* TODO */
pmic_register_interrupt_callback(INT_WATCHDOG, watchdog_int_handler);
pmic_enable_interrupt(INT_WATCHDOG, 1, "PMIC");
return ret;
}
static int mt6357_charger_probe(struct platform_device *pdev)
{
int ret = 0;
struct mt6357_charger *info = NULL;
pr_info("%s: starts\n", __func__);
info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
mt6357_charger_parse_dt(info, &pdev->dev);
platform_set_drvdata(pdev, info);
/* Register charger device */
info->charger_dev = charger_device_register(info->charger_dev_name,
&pdev->dev, info, &mt6357_charger_ops, &info->charger_prop);
if (IS_ERR_OR_NULL(info->charger_dev)) {
ret = PTR_ERR(info->charger_dev);
goto err_register_charger_dev;
}
info->charger_dev->is_polling_mode = true;
dev_set_drvdata(&info->charger_dev->dev, info);
mt6357_charger_init_setting(info);
err_register_charger_dev:
devm_kfree(&pdev->dev, info);
return ret;
}
static int mt6357_charger_remove(struct platform_device *pdev)
{
struct mt6357_charger *info = platform_get_drvdata(pdev);
if (info)
devm_kfree(&pdev->dev, info);
return 0;
}
static const struct of_device_id mt6357_charger_of_match[] = {
{.compatible = "mediatek,mt6357_charger",},
{},
};
MODULE_DEVICE_TABLE(of, mt6357_charger_of_match);
static struct platform_driver mt6357_charger_driver = {
.probe = mt6357_charger_probe,
.remove = mt6357_charger_remove,
.driver = {
.name = "mt6357_charger",
.of_match_table = mt6357_charger_of_match,
},
};
static int __init mt6357_charger_init(void)
{
return platform_driver_register(&mt6357_charger_driver);
}
module_init(mt6357_charger_init);
static void __exit mt6357_charger_exit(void)
{
platform_driver_unregister(&mt6357_charger_driver);
}
module_exit(mt6357_charger_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mediatek");
File diff suppressed because it is too large. Load diff
+235
View File
@@ -0,0 +1,235 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/debugfs.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/preempt.h>
#include <linux/uaccess.h>
#include "mtk_devinfo.h"
#include <mt-plat/upmu_common.h>
#include <mach/mtk_pmic.h>
#include "include/pmic.h"
#include "include/pmic_irq.h"
#include "include/pmic_throttling_dlpt.h"
#include "include/pmic_debugfs.h"
#ifdef CONFIG_MTK_AUXADC_INTF
#include <mt-plat/mtk_auxadc_intf.h>
#endif /* CONFIG_MTK_AUXADC_INTF */
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
#include "pwrap_hal.h"
#endif
#if defined(CONFIG_MACH_MT6739)
void vmd1_pmic_setting_on(void)
{
unsigned int vcore_vosel = 0;
unsigned int vmodem_vosel = 0;
unsigned int segment = get_devinfo_with_index(28);
unsigned char vcore_segment = (unsigned char)((segment & 0xC0000000) >> 30);
unsigned char vmodem_segment = (unsigned char)((segment & 0x08000000) >> 27);
if ((vcore_segment & 0x3) == 0x1 ||
(vcore_segment & 0x3) == 0x2) {
/* VCORE 1.15V: 0x65 */
vcore_vosel = 0x65;
} else {
/* VCORE 1.20V: 0x6D */
vcore_vosel = 0x6D;
}
#if defined(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES)
/* PMIC special flavor project */
if (strncmp(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES,
"mediatek/k39tv1_ctightening", 27) == 0) {
if ((vcore_segment & 0x3) == 0x1 ||
(vcore_segment & 0x3) == 0x2) {
/* VCORE 1.11250V: 0x5F */
vcore_vosel = 0x5F;
} else {
/* VCORE 1.15625V: 0x66 */
vcore_vosel = 0x66;
}
} else if (strncmp(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES,
"mediatek/k39v1_ctightening", 26) == 0) {
if ((vcore_segment & 0x3) == 0x1 ||
(vcore_segment & 0x3) == 0x2) {
/* VCORE 1.0875V: 0x5B */
vcore_vosel = 0x5B;
} else {
/* VCORE 1.13125V: 0x62 */
vcore_vosel = 0x62;
}
} else if (strncmp(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES,
"mediatek/k39v1_bsp_ctighten", 27) == 0) {
if ((vcore_segment & 0x3) == 0x1 ||
(vcore_segment & 0x3) == 0x2) {
/* VCORE 1.0875V: 0x5B */
vcore_vosel = 0x5B;
} else {
/* VCORE 1.13125V: 0x62 */
vcore_vosel = 0x62;
}
}
#endif
if (!vmodem_segment)
vmodem_vosel = 0x6F;/* VMODEM 1.19375V: 0x6F */
else
vmodem_vosel = 0x68;/* VMODEM 1.15V: 0x68 */
pr_notice("%s vcore vosel = 0x%x, da_vosel = 0x%x", __func__,
pmic_get_register_value(PMIC_RG_BUCK_VCORE_VOSEL),
pmic_get_register_value(PMIC_DA_VCORE_VOSEL));
/* 1.Call PMIC driver API configure VMODEM voltage */
pmic_set_register_value(PMIC_RG_BUCK_VMODEM_VOSEL, vmodem_vosel);
pr_notice("%s vmodem vosel = 0x%x, da_vosel = 0x%x", __func__,
pmic_get_register_value(PMIC_RG_BUCK_VMODEM_VOSEL),
pmic_get_register_value(PMIC_DA_VMODEM_VOSEL));
}
#else
void vmd1_pmic_setting_on(void)
{
/* Vcore: 0x2D, 0.8V */
/* Vmodem: 0x30, 0.8V */
unsigned int vcore_vosel = 0x2D, vmodem_vosel = 0x30;
if (pmic_get_register_value(PMIC_DA_VCORE_VOSEL) != vcore_vosel)
pr_notice("%s vcore vosel = 0x%x, da_vosel = 0x%x",
__func__, pmic_get_register_value(PMIC_RG_BUCK_VCORE_VOSEL),
pmic_get_register_value(PMIC_DA_VCORE_VOSEL));
/* 1.Call PMIC driver API configure VMODEM voltage */
pmic_set_register_value(PMIC_RG_BUCK_VMODEM_VOSEL, vmodem_vosel);
if (pmic_get_register_value(PMIC_DA_VMODEM_VOSEL) != vmodem_vosel)
pr_notice("%s vmodem vosel = 0x%x, da_vosel = 0x%x",
__func__, pmic_get_register_value(PMIC_RG_BUCK_VMODEM_VOSEL),
pmic_get_register_value(PMIC_DA_VMODEM_VOSEL));
}
#endif /* CONFIG_MACH_MT6739 */
void vmd1_pmic_setting_off(void)
{
PMICLOG("%s\n", __func__);
}
void wk_pmic_enable_sdn_delay(void)
{
pmic_set_register_value(PMIC_TMA_KEY, 0x9CA8);
pmic_set_register_value(PMIC_RG_SDN_DLY_ENB, 0);
pmic_set_register_value(PMIC_TMA_KEY, 0);
}
int vcore_pmic_set_mode(unsigned char mode)
{
unsigned char ret = 0;
pmic_set_register_value(PMIC_RG_VCORE_FPWM, mode);
ret = pmic_get_register_value(PMIC_RG_VCORE_FPWM);
return (ret == mode) ? (0) : (-1);
}
int vproc_pmic_set_mode(unsigned char mode)
{
unsigned char ret = 0;
pmic_set_register_value(PMIC_RG_VPROC_FPWM, mode);
ret = pmic_get_register_value(PMIC_RG_VPROC_FPWM);
return (ret == mode) ? (0) : (-1);
}
/* [Export API] */
/* Support for MT6357 CRV/MRV */
unsigned int is_pmic_mrv(void)
{
unsigned int g_is_mrv = 0;
pmic_read_interface(PMIC_RG_TOP2_RSV0_ADDR,
&g_is_mrv, 0x1, 15);
return g_is_mrv;
}
void pmic_enable_smart_reset(unsigned char smart_en, unsigned char smart_sdn_en)
{
pmic_set_register_value(PMIC_RG_SMART_RST_MODE, smart_en);
pmic_set_register_value(PMIC_RG_SMART_RST_SDN_EN, smart_sdn_en);
pr_info("[%s] smart_en:%d, smart_sdn_en:%d\n",
__func__, smart_en, smart_sdn_en);
}
int pmic_tracking_init(void)
{
int ret = 0;
#if 0
/* 0.1V */
pmic_set_register_value(PMIC_RG_VSRAM_VCORE_VOSEL_OFFSET, 0x10);
/* 0.025V */
pmic_set_register_value(PMIC_RG_VSRAM_VCORE_VOSEL_DELTA, 0x4);
/* 1.0V */
pmic_set_register_value(PMIC_RG_VSRAM_VCORE_VOSEL_ON_HB, 0x60);
/* 0.8V */
pmic_set_register_value(PMIC_RG_VSRAM_VCORE_VOSEL_ON_LB, 0x40);
/* 0.65V */
pmic_set_register_value(PMIC_RG_VSRAM_VCORE_VOSEL_SLEEP_LB, 0x28);
#endif
#if 0
ret = enable_vsram_vcore_hw_tracking(1);
PMICLOG("Enable VSRAM_VCORE hw tracking\n");
#else
PMICLOG("VSRAM_VCORE hw tracking not support in MT6357\n");
#endif
return ret;
}
/*****************************************************************************
* PMIC charger detection
******************************************************************************/
unsigned int upmu_get_rgs_chrdet(void)
{
unsigned int val = 0;
val = pmic_get_register_value(PMIC_RGS_CHRDET);
PMICLOG("[%s] CHRDET status = %d\n", __func__, val);
return val;
}
int is_ext_vbat_boost_exist(void)
{
return 0;
}
int is_ext_swchr_exist(void)
{
return 0;
}
/*****************************************************************************
* Enternal BUCK status
******************************************************************************/
int is_ext_buck_gpio_exist(void)
{
return pmic_get_register_value(PMIC_RG_STRUP_EXT_PMIC_EN);
}
MODULE_AUTHOR("Jeter Chen");
MODULE_DESCRIPTION("MT PMIC Device Driver");
MODULE_LICENSE("GPL");
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,634 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/pm_wakeup.h>
#include <linux/delay.h>
#include <linux/ratelimit.h>
#include <linux/timekeeping.h>
#include <linux/math64.h>
#include <linux/kthread.h>
#include <linux/iio/consumer.h>
#include <linux/iio/adc/mt635x-auxadc-internal.h>
#include "include/pmic.h"
#include "include/pmic_auxadc.h"
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#endif
#include <mt-plat/upmu_common.h>
#include <mt-plat/mtk_auxadc_intf.h>
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
#include <mach/mtk_pmic_wrap.h>
#endif
#if (CONFIG_MTK_GAUGE_VERSION == 30)
#include <mt-plat/v1/mtk_battery.h>
#include <mtk_battery_internal.h>
#endif
static struct device *pmic_auxadc_dev;
static int auxadc_bat_temp_cali(int bat_temp, int precision_factor);
/*********************************
* PMIC AUXADC Exported API
*********************************/
static DEFINE_MUTEX(auxadc_ch3_mutex);
static unsigned int g_pmic_pad_vbif28_vol;
unsigned int pmic_get_vbif28_volt(void)
{
return g_pmic_pad_vbif28_vol;
}
bool is_isense_supported(void)
{
/* PMIC MT6357 supports ISENSE */
return true;
}
/* BAT_TEMP background control */
void wk_auxadc_bgd_ctrl(unsigned char en)
{
/*--MT6357 not support Battmp BGD--*/
}
void pmic_auxadc_suspend(void)
{
#ifndef IPIMB
wk_auxadc_bgd_ctrl(0);
#endif
/* special call to restore bat_temp_prev when enter suspend */
auxadc_bat_temp_cali(-1, -1);
}
void pmic_auxadc_resume(void)
{
#ifndef IPIMB
wk_auxadc_bgd_ctrl(1);
#endif
}
void lockadcch3(void)
{
mutex_lock(&auxadc_ch3_mutex);
}
void unlockadcch3(void)
{
mutex_unlock(&auxadc_ch3_mutex);
}
void wk_auxadc_reset(void)
{
pmic_set_register_value(PMIC_RG_AUXADC_RST, 1);
pmic_set_register_value(PMIC_RG_AUXADC_RST, 0);
pmic_set_register_value(PMIC_BANK_AUXADC_SWRST, 1);
pmic_set_register_value(PMIC_BANK_AUXADC_SWRST, 0);
/* avoid GPS can't receive AUXADC ready after reset, request again */
pmic_set_register_value(PMIC_AUXADC_RQST_CH7, 1);
pmic_set_register_value(PMIC_AUXADC_RQST_DCXO_BY_GPS, 1);
pr_notice("reset AUXADC done\n");
}
/*********************************
* PMIC AUXADC debug register dump
*********************************/
#define DBG_REG_SIZE 384
#define BAT_TEMP_AEE_DBG 0
struct pmic_adc_dbg_st {
int ktime_sec;
unsigned short reg[DBG_REG_SIZE];
};
static unsigned int adc_dbg_addr[DBG_REG_SIZE];
static void wk_auxadc_dbg_dump(void)
{
unsigned char reg_log[861] = "", reg_str[21] = "";
unsigned short i, j;
static unsigned char dbg_stamp;
static struct pmic_adc_dbg_st pmic_adc_dbg[4];
for (i = 0; adc_dbg_addr[i] != 0; i++)
pmic_adc_dbg[dbg_stamp].reg[i] =
upmu_get_reg_value(adc_dbg_addr[i]);
pmic_adc_dbg[dbg_stamp].ktime_sec = (int)get_monotonic_coarse().tv_sec;
dbg_stamp++;
if (dbg_stamp >= 4)
dbg_stamp = 0;
for (i = 0; i < 4; i++) {
if (pmic_adc_dbg[dbg_stamp].ktime_sec == 0) {
dbg_stamp++;
if (dbg_stamp >= 4)
dbg_stamp = 0;
continue;
}
for (j = 0; adc_dbg_addr[j] != 0; j++) {
if (j != 0 && j % 43 == 0) {
pr_notice("%d %s\n",
pmic_adc_dbg[dbg_stamp].ktime_sec,
reg_log);
strncpy(reg_log, "", 860);
}
snprintf(reg_str, 20, "Reg[0x%x]=0x%x, ",
adc_dbg_addr[j],
pmic_adc_dbg[dbg_stamp].reg[j]);
strncat(reg_log, reg_str, 860);
}
pr_notice("%d %s\n",
pmic_adc_dbg[dbg_stamp].ktime_sec,
reg_log);
strncpy(reg_log, "", 860);
dbg_stamp++;
if (dbg_stamp >= 4)
dbg_stamp = 0;
}
}
/* BAT_TEMP filter Maxima and minima then average */
static int bat_temp_filter(int *arr, unsigned short size)
{
unsigned char i, i_max, i_min = 0;
int arr_max = 0, arr_min = arr[0];
int sum = 0;
for (i = 0; i < size; i++) {
sum += arr[i];
if (arr[i] > arr_max) {
arr_max = arr[i];
i_max = i;
} else if (arr[i] < arr_min) {
arr_min = arr[i];
i_min = i;
}
}
sum = sum - arr_max - arr_min;
return (sum/(size - 2));
}
static int wk_bat_temp_dbg(int bat_temp_prev, int bat_temp)
{
int vbif28, bat_temp_new = bat_temp;
int arr_bat_temp[5];
int bat = 0, bat_cur = 0;
unsigned short i;
#if (CONFIG_MTK_GAUGE_VERSION == 30)
int is_charging = 0;
#endif
vbif28 = auxadc_priv_read_channel(pmic_auxadc_dev, AUXADC_VBIF);
pr_notice("BAT_TEMP_PREV:%d,BAT_TEMP:%d,VBIF28:%d\n",
bat_temp_prev, bat_temp, vbif28);
if (bat_temp < 200 || abs(bat_temp_prev - bat_temp) > 100) {
wk_auxadc_dbg_dump();
for (i = 0; i < 5; i++) {
arr_bat_temp[i] =
auxadc_priv_read_channel(pmic_auxadc_dev,
AUXADC_BAT_TEMP);
}
bat_temp_new = bat_temp_filter(arr_bat_temp, 5);
pr_notice("%d,%d,%d,%d,%d, BAT_TEMP_NEW:%d\n",
arr_bat_temp[0], arr_bat_temp[1], arr_bat_temp[2],
arr_bat_temp[3], arr_bat_temp[4], bat_temp_new);
/* Reset AuxADC to observe VBAT/IBAT/BAT_TEMP */
wk_auxadc_reset();
for (i = 0; i < 5; i++) {
bat = auxadc_priv_read_channel(pmic_auxadc_dev,
AUXADC_BATADC);
#if (CONFIG_MTK_GAUGE_VERSION == 30)
is_charging = gauge_get_current(&bat_cur);
if (is_charging == 0)
bat_cur = 0 - bat_cur;
#endif
arr_bat_temp[i] =
auxadc_priv_read_channel(pmic_auxadc_dev,
AUXADC_BAT_TEMP);
pr_notice("[CH3_DBG] %d,%d,%d\n",
bat, bat_cur, arr_bat_temp[i]);
}
bat_temp_new = bat_temp_filter(arr_bat_temp, 5);
pr_notice("Final BAT_TEMP_NEW:%d\n", bat_temp_new);
}
return bat_temp_new;
}
static void wk_auxadc_dbg_init(void)
{
unsigned short i;
unsigned int addr = 0x1000;
/* All of AUXADC */
for (i = 0; addr <= 0x1236; i++) {
adc_dbg_addr[i] = addr;
addr += 0x2;
}
/* Clock related */
adc_dbg_addr[i++] = MT6357_HK_TOP_CLK_CON0;
adc_dbg_addr[i++] = MT6357_HK_TOP_CLK_CON1;
/* RST related */
adc_dbg_addr[i++] = MT6357_HK_TOP_RST_CON0;
/* Others */
adc_dbg_addr[i++] = MT6357_BATON_ANA_CON0;
}
/*********************************
* PMIC AUXADC MDRT debug(MTS=Modem Temp Share)
*********************************/
/* global variable */
static unsigned int mdrt_adc;
static struct wakeup_source *mdrt_wakelock;
static struct mutex mdrt_mutex;
static struct task_struct *mdrt_thread_handle;
/* wake up the thread to polling MDRT data in ms period */
void wake_up_mdrt_thread(void)
{
HKLOG("[%s]\n", __func__);
if (mdrt_thread_handle != NULL) {
__pm_stay_awake(mdrt_wakelock);
wake_up_process(mdrt_thread_handle);
} else
pr_notice(PMICTAG "[%s] mdrt_thread_handle not ready\n",
__func__);
}
/* dump MDRT related register */
static void mdrt_reg_dump(void)
{
#if defined(CONFIG_MTK_PMIC_WRAP_HAL) && !defined(CONFIG_FPGA_EARLY_PORTING)
pwrap_dump_all_register();
#endif
pr_notice("AUXADC_ADC16 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_ADC16));
pr_notice("AUXADC_ADC17 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_ADC17));
pr_notice("AUXADC_ADC18 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_ADC18));
pr_notice("AUXADC_ADC36 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_ADC36));
pr_notice("AUXADC_MDRT_0 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_MDRT_0));
pr_notice("AUXADC_MDRT_1 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_MDRT_1));
pr_notice("AUXADC_MDRT_2 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_MDRT_2));
pr_notice("AUXADC_MDRT_3 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_MDRT_3));
pr_notice("AUXADC_MDRT_4 = 0x%x\n"
, upmu_get_reg_value(MT6357_AUXADC_MDRT_4));
/*--AUXADC CLK--*/
pr_notice("RG_AUXADC_CK_PDN = 0x%x, RG_AUXADC_CK_PDN_HWEN = 0x%x\n",
pmic_get_register_value(PMIC_RG_AUXADC_CK_PDN),
pmic_get_register_value(PMIC_RG_AUXADC_CK_PDN_HWEN));
}
/* Check MDRT_ADC data has changed or not */
void mdrt_monitor(void)
{
static unsigned int mdrt_cnt;
static int mdrt_timestamp;
int mdrt_timestamp_cur = 0;
unsigned int temp_mdrt_adc = 0;
if (mdrt_adc == 0)
return;
mdrt_timestamp_cur = (int)get_monotonic_coarse().tv_sec;
if ((mdrt_timestamp_cur - mdrt_timestamp) < 5)
return;
mdrt_timestamp = mdrt_timestamp_cur;
temp_mdrt_adc = pmic_get_register_value(PMIC_AUXADC_ADC_OUT_MDRT);
pr_notice("[MDRT_ADC] OLD = 0x%x, NOW = 0x%x, CNT = %d\n",
mdrt_adc, temp_mdrt_adc, mdrt_cnt);
if (temp_mdrt_adc != mdrt_adc) {
mdrt_cnt = 0;
mdrt_adc = temp_mdrt_adc;
return;
}
mdrt_cnt++;
if (mdrt_cnt >= 7 && mdrt_cnt < 9) {
/* trigger CH7 in AP/MD/GPS and just delay 1ms to get data */
pmic_set_hk_reg_value(PMIC_AUXADC_RQST_CH7, 1);
pmic_set_hk_reg_value(PMIC_AUXADC_RQST_CH7_BY_MD, 1);
pmic_set_hk_reg_value(PMIC_AUXADC_RQST_CH7_BY_GPS, 1);
mdelay(1);
mdrt_reg_dump();
}
if (mdrt_cnt > 10) {
mdrt_reg_dump();
mdrt_cnt = 0;
wake_up_mdrt_thread();
}
mdrt_adc = temp_mdrt_adc;
}
static int mdrt_polling_rdy(unsigned int *trig_prd,
unsigned int *rdy_time, unsigned int *mdrt_adc)
{
while (pmic_get_register_value(PMIC_AUXADC_ADC_RDY_MDRT) == 1) {
if (*trig_prd > 100) {
pr_notice("[MDRT_ADC] no trigger\n");
return -1;
}
(*trig_prd)++;
mdelay(1);
}
while (pmic_get_register_value(PMIC_AUXADC_ADC_RDY_MDRT) == 0) {
if (*rdy_time > 100) {
pr_notice("[MDRT_ADC] no ready\n");
return -2;
}
(*rdy_time)++;
mdelay(1);
}
*mdrt_adc = pmic_get_register_value(PMIC_AUXADC_ADC_OUT_MDRT);
return 0;
}
static int mdrt_kthread(void *x)
{
unsigned int polling_cnt;
unsigned int trig_prd;
unsigned int rdy_time;
unsigned int temp_mdrt_adc;
/* Run on a process content */
while (1) {
mutex_lock(&mdrt_mutex);
polling_cnt = 0;
/* Adjust to average 8 sample numbers for ch7 */
pmic_set_register_value(PMIC_AUXADC_AVG_NUM_CH7, 0x2);
temp_mdrt_adc = pmic_get_register_value(
PMIC_AUXADC_ADC_OUT_MDRT);
while (mdrt_adc == temp_mdrt_adc) {
trig_prd = 0;
rdy_time = 0;
mdrt_polling_rdy(&trig_prd,
&rdy_time, &temp_mdrt_adc);
if (polling_cnt % 20 == 0) {
pr_notice("[MDRT_ADC] trig_prd=%d, rdy_time=%d, MDRT_OUT=%d\n"
, trig_prd, rdy_time,
temp_mdrt_adc);
}
if (polling_cnt == 156) { /* 156 * 32ms ~= 5s*/
pr_notice("[MDRT_ADC] (%d) reset AUXADC\n",
polling_cnt);
wk_auxadc_reset();
}
if (polling_cnt >= 312) { /* 312 * 32ms ~= 10s*/
mdrt_reg_dump();
#ifdef CONFIG_MTK_AEE_FEATURE
aee_kernel_warning("PMIC AUXADC:MDRT", "MDRT");
#endif
break;
}
polling_cnt++;
}
mutex_unlock(&mdrt_mutex);
__pm_relax(mdrt_wakelock);
set_current_state(TASK_INTERRUPTIBLE);
schedule();
/* Fix Cove.Scan, should not happened */
if (polling_cnt >= 0x1000)
break;
}
return 0;
}
static void mdrt_monitor_init(void)
{
// workaround for mt6739
//wakeup_source_init(&mdrt_wakelock, "MDRT Monitor wakelock");
mdrt_wakelock = wakeup_source_register(NULL, "MDRT Monitor wakelock");
mutex_init(&mdrt_mutex);
mdrt_adc = pmic_get_register_value(PMIC_AUXADC_ADC_OUT_MDRT);
mdrt_thread_handle = kthread_create(mdrt_kthread, NULL, "mdrt_thread");
if (IS_ERR(mdrt_thread_handle)) {
mdrt_thread_handle = NULL;
pr_notice(PMICTAG "[%s] creation fails\n", __func__);
} else
HKLOG("[%s] creation Done\n", __func__);
}
/*********************************
* Legacy API for getting PMIC AUXADC value
*********************************/
struct legacy_auxadc_t {
const char *channel_name;
struct iio_channel *chan;
};
#define LEGACY_AUXADC_GEN(_name) \
{ \
.channel_name = "AUXADC_"#_name,\
}
static struct legacy_auxadc_t legacy_auxadc[] = {
LEGACY_AUXADC_GEN(BATADC),
LEGACY_AUXADC_GEN(VCDT),
LEGACY_AUXADC_GEN(BAT_TEMP),
LEGACY_AUXADC_GEN(VBIF),
LEGACY_AUXADC_GEN(CHIP_TEMP),
LEGACY_AUXADC_GEN(DCXO_TEMP),
LEGACY_AUXADC_GEN(ACCDET),
LEGACY_AUXADC_GEN(TSX_TEMP),
LEGACY_AUXADC_GEN(HPOFS_CAL),
LEGACY_AUXADC_GEN(ISENSE),
LEGACY_AUXADC_GEN(VCORE_TEMP),
LEGACY_AUXADC_GEN(VPROC_TEMP),
};
static void legacy_auxadc_init(struct device *dev)
{
int i = 0;
for (i = AUXADC_LIST_START; i <= AUXADC_LIST_END; i++) {
legacy_auxadc[i].chan =
devm_iio_channel_get(dev,
legacy_auxadc[i].channel_name);
if (IS_ERR(legacy_auxadc[i].chan))
pr_notice("%s get fail with list %d\n",
legacy_auxadc[i].channel_name, i);
}
}
int pmic_get_auxadc_value(int list)
{
int value = 0, ret = 0;
#if (CONFIG_MTK_GAUGE_VERSION == 30)
int bat_cur = 0, is_charging = 0;
#endif
if (list < AUXADC_LIST_START || list > AUXADC_LIST_END) {
pr_notice("[%s] Invalid channel list(%d)\n", __func__, list);
return -EINVAL;
}
if (!(legacy_auxadc[list].chan) || IS_ERR(legacy_auxadc[list].chan)) {
pr_notice("[%s] iio channel consumer error(%s)\n",
__func__, legacy_auxadc[list].channel_name);
return PTR_ERR(legacy_auxadc[list].chan);
}
#if (CONFIG_MTK_GAUGE_VERSION == 30)
if (list == AUXADC_LIST_BATTEMP) {
is_charging = gauge_get_current(&bat_cur);
if (is_charging == 0)
bat_cur = 0 - bat_cur;
pr_notice("[CH3_DBG] bat_cur = %d\n", bat_cur);
}
#endif
if (list == AUXADC_LIST_HPOFS_CAL) {
ret = iio_read_channel_raw(
legacy_auxadc[list].chan, &value);
} else {
ret = iio_read_channel_processed(
legacy_auxadc[list].chan, &value);
}
if (ret < 0)
return ret;
return value;
}
/*********************************
* PMIC AUXADC chip setting for IIO ADC driver
*********************************/
static void auxadc_batadc_convert(unsigned char convert)
{
/* when user wants to get BATADC, starting monitor MDRT for debugging*/
if (convert == 0)
mdrt_monitor();
}
static void auxadc_bat_temp_convert(unsigned char convert)
{
if (convert == 1)
mutex_lock(&auxadc_ch3_mutex);
else if (convert == 0)
mutex_unlock(&auxadc_ch3_mutex);
}
static void auxadc_dcxo_temp_convert(unsigned char convert)
{
if (convert == 1)
pmic_set_hk_reg_value(PMIC_AUXADC_DCXO_CH4_MUX_AP_SEL, 1);
else if (convert == 0)
pmic_set_hk_reg_value(PMIC_AUXADC_DCXO_CH4_MUX_AP_SEL, 0);
}
static void auxadc_vbif_convert(unsigned char convert)
{
if (convert == 1)
pmic_set_hk_reg_value(PMIC_BATON_TDET_EN, 0);
else if (convert == 0)
pmic_set_hk_reg_value(PMIC_BATON_TDET_EN, 1);
}
static int auxadc_bat_temp_cali(int bat_temp, int precision_factor)
{
static int bat_temp_prev;
static unsigned int dbg_count;
static unsigned int aee_count;
if (bat_temp == -1 && precision_factor == -1) {
bat_temp_prev = 0;
return 0;
}
if (bat_temp_prev == 0)
goto out;
dbg_count++;
if (bat_temp < 200 || abs(bat_temp_prev - bat_temp) > 100) {
/* dump debug log when BAT_TEMP being abnormal */
bat_temp = wk_bat_temp_dbg(bat_temp_prev, bat_temp);
#if BAT_TEMP_AEE_DBG
#ifdef CONFIG_MTK_AEE_FEATURE
if (aee_count < 2)
aee_kernel_warning("PMIC AUXADC:BAT_TEMP", "BAT_TEMP");
#endif
pr_notice("PMIC AUXADC BAT_TEMP aee_count=%d\n", aee_count);
#endif
aee_count++;
} else if (dbg_count % 50 == 0) {
/* dump debug log in normal case */
wk_bat_temp_dbg(bat_temp_prev, bat_temp);
}
out:
bat_temp_prev = bat_temp;
return bat_temp;
}
void pmic_auxadc_chip_timeout_handler(
struct device *dev, bool is_timeout, unsigned char ch_num)
{
static unsigned short timeout_times;
if (is_timeout == false) {
timeout_times = 0;
return;
}
timeout_times++;
dev_notice(dev, "(%d)Time out!STA0=0x%x,STA1=0x%x,STA2=0x%x\n",
ch_num,
upmu_get_reg_value(MT6357_AUXADC_STA0),
upmu_get_reg_value(MT6357_AUXADC_STA1),
upmu_get_reg_value(MT6357_AUXADC_STA2));
dev_notice(dev, "RST: Reg[0x%x]=0x%x, Reg[0x%x]=0x%x\n",
MT6357_STRUP_CON6,
upmu_get_reg_value(MT6357_STRUP_CON6),
MT6357_HK_TOP_RST_CON0,
upmu_get_reg_value(MT6357_HK_TOP_RST_CON0));
dev_notice(dev, "CLK: Reg[0x%x]=0x%x, Reg[0x%x]=0x%x\n",
MT6357_HK_TOP_CLK_CON0,
upmu_get_reg_value(MT6357_HK_TOP_CLK_CON0),
MT6357_HK_TOP_CLK_CON1,
upmu_get_reg_value(MT6357_HK_TOP_CLK_CON1));
}
int pmic_auxadc_chip_init(struct device *dev)
{
int ret = 0;
struct iio_channel *chan_vbif;
HKLOG("%s\n", __func__);
pmic_auxadc_dev = dev;
auxadc_set_convert_fn(AUXADC_BATADC, auxadc_batadc_convert);
auxadc_set_convert_fn(AUXADC_BAT_TEMP, auxadc_bat_temp_convert);
auxadc_set_convert_fn(AUXADC_DCXO_TEMP, auxadc_dcxo_temp_convert);
auxadc_set_convert_fn(AUXADC_VBIF, auxadc_vbif_convert);
auxadc_set_cali_fn(AUXADC_BAT_TEMP, auxadc_bat_temp_cali);
#if 1 /*TBD*/
legacy_auxadc_init(dev);
#endif
wk_auxadc_dbg_init();
mdrt_monitor_init();
/* update VBIF28 by AUXADC */
chan_vbif = iio_channel_get(dev, "AUXADC_VBIF");
if (IS_ERR(chan_vbif)) {
pr_notice("[%s] iio channel consumer error(AUXADC_VBIF)\n",
__func__);
} else {
ret = iio_read_channel_processed(chan_vbif,
&g_pmic_pad_vbif28_vol);
iio_channel_release(chan_vbif);
}
pr_info("****[%s] VBIF28 = %d, MDRT_ADC = 0x%x\n",
__func__, pmic_get_vbif28_volt(), mdrt_adc);
return ret;
}
@@ -0,0 +1,439 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/power_supply.h>
#include <linux/reboot.h>
#include <linux/workqueue.h>
#include <mt-plat/v1/charger_type.h>
#include <mt-plat/mtk_boot.h>
#include <mt-plat/upmu_common.h>
#include <mach/upmu_sw.h>
#include <mach/upmu_hw.h>
#ifdef CONFIG_MTK_USB2JTAG_SUPPORT
#include <mt-plat/mtk_usb2jtag.h>
#endif
/* #define __FORCE_USB_TYPE__ */
#ifndef CONFIG_TCPC_CLASS
#define __SW_CHRDET_IN_PROBE_PHASE__
#endif
static enum charger_type g_chr_type;
#ifdef __SW_CHRDET_IN_PROBE_PHASE__
static struct work_struct chr_work;
#endif
static DEFINE_MUTEX(chrdet_lock);
static struct power_supply *chrdet_psy;
#if !defined(CONFIG_FPGA_EARLY_PORTING)
static bool first_connect = true;
#endif
static int chrdet_inform_psy_changed(enum charger_type chg_type,
bool chg_online)
{
int ret = 0;
union power_supply_propval propval;
pr_info("charger type: %s: online = %d, type = %d\n", __func__,
chg_online, chg_type);
/* Inform chg det power supply */
if (chg_online) {
propval.intval = chg_online;
ret = power_supply_set_property(chrdet_psy,
POWER_SUPPLY_PROP_ONLINE, &propval);
if (ret < 0)
pr_notice("%s: psy online failed, ret = %d\n",
__func__, ret);
propval.intval = chg_type;
ret = power_supply_set_property(chrdet_psy,
POWER_SUPPLY_PROP_CHARGE_TYPE, &propval);
if (ret < 0)
pr_notice("%s: psy type failed, ret = %d\n",
__func__, ret);
return ret;
}
propval.intval = chg_type;
ret = power_supply_set_property(chrdet_psy,
POWER_SUPPLY_PROP_CHARGE_TYPE, &propval);
if (ret < 0)
pr_notice("%s: psy type failed, ret(%d)\n", __func__, ret);
propval.intval = chg_online;
ret = power_supply_set_property(chrdet_psy, POWER_SUPPLY_PROP_ONLINE,
&propval);
if (ret < 0)
pr_notice("%s: psy online failed, ret(%d)\n", __func__, ret);
return ret;
}
#if defined(CONFIG_FPGA_EARLY_PORTING)
/* FPGA */
int hw_charging_get_charger_type(void)
{
/* Force Standard USB Host */
g_chr_type = STANDARD_HOST;
chrdet_inform_psy_changed(g_chr_type, 1);
return g_chr_type;
}
#else
/* EVB / Phone */
static void hw_bc11_init(void)
{
int timeout = 200;
msleep(200);
if (first_connect == true) {
/* add make sure USB Ready */
if (is_usb_rdy() == false) {
pr_info("CDP, block\n");
while (is_usb_rdy() == false && timeout > 0) {
msleep(100);
timeout--;
}
if (timeout == 0)
pr_info("CDP, timeout\n");
else
pr_info("CDP, free\n");
} else
pr_info("CDP, PASS\n");
first_connect = false;
}
/* RG_bc11_BIAS_EN=1 */
bc11_set_register_value(PMIC_RG_BC11_BIAS_EN, 1);
/* RG_bc11_VSRC_EN[1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0);
/* RG_bc11_VREF_VTH = [1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0);
/* RG_bc11_CMP_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0);
/* RG_bc11_IPU_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPU_EN, 0);
/* RG_bc11_IPD_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0);
/* bc11_RST=1 */
bc11_set_register_value(PMIC_RG_BC11_RST, 1);
/* bc11_BB_CTRL=1 */
bc11_set_register_value(PMIC_RG_BC11_BB_CTRL, 1);
/* add pull down to prevent PMIC leakage */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x1);
msleep(50);
Charger_Detect_Init();
}
static unsigned int hw_bc11_DCD(void)
{
unsigned int wChargerAvail = 0;
/* RG_bc11_IPU_EN[1.0] = 10 */
bc11_set_register_value(PMIC_RG_BC11_IPU_EN, 0x2);
/* RG_bc11_IPD_EN[1.0] = 01 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x1);
/* RG_bc11_VREF_VTH = [1:0]=01 */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0x1);
/* RG_bc11_CMP_EN[1.0] = 10 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x2);
msleep(80);
/* mdelay(80); */
wChargerAvail = bc11_get_register_value(PMIC_RGS_BC11_CMP_OUT);
/* RG_bc11_IPU_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPU_EN, 0x0);
/* RG_bc11_IPD_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x0);
/* RG_bc11_CMP_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x0);
/* RG_bc11_VREF_VTH = [1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0x0);
return wChargerAvail;
}
static unsigned int hw_bc11_stepA1(void)
{
unsigned int wChargerAvail = 0;
/* RG_bc11_IPD_EN[1.0] = 01 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x1);
/* RG_bc11_VREF_VTH = [1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0x0);
/* RG_bc11_CMP_EN[1.0] = 01 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x1);
msleep(80);
/* mdelay(80); */
wChargerAvail = bc11_get_register_value(PMIC_RGS_BC11_CMP_OUT);
/* RG_bc11_IPD_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x0);
/* RG_bc11_CMP_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x0);
return wChargerAvail;
}
static unsigned int hw_bc11_stepA2(void)
{
unsigned int wChargerAvail = 0;
/* RG_bc11_VSRC_EN[1.0] = 10 */
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0x2);
/* RG_bc11_IPD_EN[1:0] = 01 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x1);
/* RG_bc11_VREF_VTH = [1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0x0);
/* RG_bc11_CMP_EN[1.0] = 01 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x1);
msleep(80);
/* mdelay(80); */
wChargerAvail = bc11_get_register_value(PMIC_RGS_BC11_CMP_OUT);
/* RG_bc11_VSRC_EN[1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0x0);
/* RG_bc11_IPD_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x0);
/* RG_bc11_CMP_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x0);
return wChargerAvail;
}
static unsigned int hw_bc11_stepB2(void)
{
unsigned int wChargerAvail = 0;
/*enable the voltage source to DM*/
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0x1);
/* enable the pull-down current to DP */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x2);
/* VREF threshold voltage for comparator =0.325V */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0x0);
/* enable the comparator to DP */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x2);
msleep(80);
wChargerAvail = bc11_get_register_value(PMIC_RGS_BC11_CMP_OUT);
/*reset to default value*/
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0x0);
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x0);
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x0);
if (wChargerAvail == 1) {
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0x2);
pr_info("charger type: DCP, keep DM voltage source in stepB2\n");
}
return wChargerAvail;
}
static void hw_bc11_done(void)
{
/* RG_bc11_VSRC_EN[1:0]=00 */
bc11_set_register_value(PMIC_RG_BC11_VSRC_EN, 0x0);
/* RG_bc11_VREF_VTH = [1:0]=0 */
bc11_set_register_value(PMIC_RG_BC11_VREF_VTH, 0x0);
/* RG_bc11_CMP_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_CMP_EN, 0x0);
/* RG_bc11_IPU_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPU_EN, 0x0);
/* RG_bc11_IPD_EN[1.0] = 00 */
bc11_set_register_value(PMIC_RG_BC11_IPD_EN, 0x0);
/* RG_bc11_BIAS_EN=0 */
bc11_set_register_value(PMIC_RG_BC11_BIAS_EN, 0x0);
Charger_Detect_Release();
}
static void dump_charger_name(enum charger_type type)
{
switch (type) {
case CHARGER_UNKNOWN:
pr_info("charger type: %d, CHARGER_UNKNOWN\n", type);
break;
case STANDARD_HOST:
pr_info("charger type: %d, Standard USB Host\n", type);
break;
case CHARGING_HOST:
pr_info("charger type: %d, Charging USB Host\n", type);
break;
case NONSTANDARD_CHARGER:
pr_info("charger type: %d, Non-standard Charger\n", type);
break;
case STANDARD_CHARGER:
pr_info("charger type: %d, Standard Charger\n", type);
break;
case APPLE_2_1A_CHARGER:
pr_info("charger type: %d, APPLE_2_1A_CHARGER\n", type);
break;
case APPLE_1_0A_CHARGER:
pr_info("charger type: %d, APPLE_1_0A_CHARGER\n", type);
break;
case APPLE_0_5A_CHARGER:
pr_info("charger type: %d, APPLE_0_5A_CHARGER\n", type);
break;
default:
pr_info("charger type: %d, Not Defined!!!\n", type);
break;
}
}
int hw_charging_get_charger_type(void)
{
enum charger_type CHR_Type_num = CHARGER_UNKNOWN;
#ifdef CONFIG_MTK_USB2JTAG_SUPPORT
if (usb2jtag_mode()) {
pr_info("[USB2JTAG] in usb2jtag mode, skip charger detection\n");
return STANDARD_HOST;
}
#endif
hw_bc11_init();
if (hw_bc11_DCD()) {
if (hw_bc11_stepA1())
CHR_Type_num = APPLE_2_1A_CHARGER;
else
CHR_Type_num = NONSTANDARD_CHARGER;
} else {
if (hw_bc11_stepA2()) {
if (hw_bc11_stepB2())
CHR_Type_num = STANDARD_CHARGER;
else
CHR_Type_num = CHARGING_HOST;
} else
CHR_Type_num = STANDARD_HOST;
}
if (CHR_Type_num != STANDARD_CHARGER)
hw_bc11_done();
else
pr_info("charger type: skip bc11 release for BC12 DCP SPEC\n");
dump_charger_name(CHR_Type_num);
#ifdef __FORCE_USB_TYPE__
CHR_Type_num = STANDARD_HOST;
pr_info("charger type: Froce to STANDARD_HOST\n");
#endif
return CHR_Type_num;
}
void mtk_pmic_enable_chr_type_det(bool en)
{
#ifndef CONFIG_TCPC_CLASS
if (!mt_usb_is_device()) {
g_chr_type = CHARGER_UNKNOWN;
pr_info("charger type: UNKNOWN, Now is usb host mode. Skip detection\n");
return;
}
#endif
mutex_lock(&chrdet_lock);
if (en) {
// workaround for mt6739
// if (is_meta_mode()) {
if (0) {
/* Skip charger type detection to speed up meta boot */
pr_notice("charger type: force Standard USB Host in meta\n");
g_chr_type = STANDARD_HOST;
chrdet_inform_psy_changed(g_chr_type, 1);
} else {
pr_info("charger type: charger IN\n");
g_chr_type = hw_charging_get_charger_type();
chrdet_inform_psy_changed(g_chr_type, 1);
}
} else {
pr_info("charger type: charger OUT\n");
g_chr_type = CHARGER_UNKNOWN;
chrdet_inform_psy_changed(g_chr_type, 0);
}
mutex_unlock(&chrdet_lock);
}
/* Charger Detection */
void do_charger_detect(void)
{
if (pmic_get_register_value(PMIC_RGS_CHRDET))
mtk_pmic_enable_chr_type_det(true);
else
mtk_pmic_enable_chr_type_det(false);
}
/* PMIC Int Handler */
void chrdet_int_handler(void)
{
/*
* pr_notice("[chrdet_int_handler]CHRDET status = %d....\n",
* pmic_get_register_value(PMIC_RGS_CHRDET));
*/
if (!pmic_get_register_value(PMIC_RGS_CHRDET)) {
int boot_mode = 0;
hw_bc11_done();
// workaround for mt6739
boot_mode = 0;
//boot_mode = get_boot_mode();
if (boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT
|| boot_mode == LOW_POWER_OFF_CHARGING_BOOT) {
pr_info("[%s] Unplug Charger/USB\n", __func__);
#ifndef CONFIG_TCPC_CLASS
pr_info("%s: system_state=%d\n", __func__,
system_state);
if (system_state != SYSTEM_POWER_OFF)
kernel_power_off();
#else
return;
#endif
}
}
pmic_set_register_value(PMIC_RG_USBDL_RST, 1);
do_charger_detect();
}
/* Charger Probe Related */
#ifdef __SW_CHRDET_IN_PROBE_PHASE__
static void do_charger_detection_work(struct work_struct *data)
{
if (pmic_get_register_value(PMIC_RGS_CHRDET))
do_charger_detect();
}
#endif
static int __init pmic_chrdet_init(void)
{
mutex_init(&chrdet_lock);
chrdet_psy = power_supply_get_by_name("charger");
if (!chrdet_psy) {
pr_notice("%s: get power supply failed\n", __func__);
return -EINVAL;
}
#ifdef __SW_CHRDET_IN_PROBE_PHASE__
/* do charger detect here to prevent HW miss interrupt*/
INIT_WORK(&chr_work, do_charger_detection_work);
schedule_work(&chr_work);
#endif
#ifndef CONFIG_TCPC_CLASS
pmic_register_interrupt_callback(INT_CHRDET_EDGE, chrdet_int_handler);
pmic_enable_interrupt(INT_CHRDET_EDGE, 1, "PMIC");
#endif
return 0;
}
late_initcall(pmic_chrdet_init);
#endif /* CONFIG_FPGA_EARLY_PORTING */
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,167 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/seq_file.h>
#include <linux/uaccess.h>
#include <linux/debugfs.h>
#include <mt-plat/upmu_common.h>
#include "include/pmic.h"
#include "include/pmic_debugfs.h"
/*
* PMIC debug level
*/
unsigned int pmic_dbg_level_set(unsigned int level)
{
unsigned char Dlevel = (level & 0x7);
unsigned char HKlevel = (level & 0x38) >> 3;
unsigned char COMlevel = (level & 0x1C0) >> 6;
unsigned char IRQlevel = (level & 0xE00) >> 9;
unsigned char REGlevel = (level & 0x7000) >> 12;
gPMICDbgLvl = Dlevel > PMIC_LOG_DBG ? PMIC_LOG_DBG : Dlevel;
gPMICHKDbgLvl = HKlevel > PMIC_LOG_DBG ? PMIC_LOG_DBG : HKlevel;
gPMICCOMDbgLvl = COMlevel > PMIC_LOG_DBG ? PMIC_LOG_DBG : COMlevel;
gPMICIRQDbgLvl = IRQlevel > PMIC_LOG_DBG ? PMIC_LOG_DBG : IRQlevel;
gPMICREGDbgLvl = REGlevel > PMIC_LOG_DBG ? PMIC_LOG_DBG : REGlevel;
return 0;
}
/*
* PMIC reg dump log
*/
void pmic_dump_register(struct seq_file *m)
{
const PMU_FLAG_TABLE_ENTRY *pFlag =
&pmu_flags_table[PMU_COMMAND_MAX - 1];
unsigned int i = 0;
PMICLOG("dump PMIC register\n");
for (i = 0; i < (pFlag->offset - 10); i = i + 10) {
PMICLOG(
"[0x%x]=0x%x [0x%x]=0x%x [0x%x]=0x%x [0x%x]=0x%x [0x%x]=0x%x\n"
, i, upmu_get_reg_value(i)
, i + 2, upmu_get_reg_value(i + 2)
, i + 4, upmu_get_reg_value(i + 4)
, i + 6, upmu_get_reg_value(i + 6)
, i + 8, upmu_get_reg_value(i + 8));
if (m == NULL)
continue;
seq_printf(m,
"R[0x%x]=0x%x [0x%x]=0x%x [0x%x]=0x%x [0x%x]=0x%x [0x%x]=0x%x\n"
, i, upmu_get_reg_value(i)
, i + 2, upmu_get_reg_value(i + 2)
, i + 4, upmu_get_reg_value(i + 4)
, i + 6, upmu_get_reg_value(i + 6)
, i + 8, upmu_get_reg_value(i + 8));
}
}
/*
* PMIC dump exception status
*/
/* Kernel dump log */
void kernel_dump_exception_reg(void)
{
/* 1.UVLO off */
kernel_output_reg(MT6357_TOP_RST_STATUS);
kernel_output_reg(MT6357_PONSTS);
kernel_output_reg(MT6357_POFFSTS);
/* 2.thermal shutdown 150 */
kernel_output_reg(MT6357_THERMALSTATUS);
/* 3.power not good */
kernel_output_reg(MT6357_PG_SDN_STS0);
/* 4.BUCK OC status */
kernel_output_reg(MT6357_OC_SDN_STS0);
kernel_output_reg(MT6357_BUCK_TOP_OC_CON0);
/* 4.5 BUCK OC shutdown control */
kernel_output_reg(MT6357_BUCK_TOP_ELR0);
/* 5.long press shutdown */
kernel_output_reg(MT6357_STRUP_CON4);
/* 6.WDTRST */
kernel_output_reg(MT6357_TOP_RST_MISC);
/* 7.CLK TRIM */
kernel_output_reg(MT6357_TOP_CLK_TRIM);
}
/* Kernel & UART dump log */
void both_dump_exception_reg(struct seq_file *s)
{
/* 1.UVLO off */
both_output_reg(MT6357_TOP_RST_STATUS);
both_output_reg(MT6357_PONSTS);
both_output_reg(MT6357_POFFSTS);
/* 2.thermal shutdown 150 */
both_output_reg(MT6357_THERMALSTATUS);
/* 3.power not good */
both_output_reg(MT6357_PG_SDN_STS0);
/* 4.BUCK OC */
both_output_reg(MT6357_OC_SDN_STS0);
both_output_reg(MT6357_BUCK_TOP_OC_CON0);
/* 4.5 BUCK OC shutdown control */
both_output_reg(MT6357_BUCK_TOP_ELR0);
/* 5.long press shutdown */
both_output_reg(MT6357_STRUP_CON4);
/* 6.WDTRST */
both_output_reg(MT6357_TOP_RST_MISC);
/* 7.CLK TRIM */
both_output_reg(MT6357_TOP_CLK_TRIM);
}
/* dump exception reg in kernel and clean status */
int pmic_dump_exception_reg(void)
{
int ret_val = 0;
kernel_dump_exception_reg();
/* clear UVLO off */
ret_val = pmic_set_register_value(PMIC_TOP_RST_STATUS_CLR, 0xFFFF);
/* clear thermal shutdown 150 */
ret_val = pmic_set_register_value(PMIC_RG_STRUP_THR_CLR, 0x1);
udelay(200);
ret_val = pmic_set_register_value(PMIC_RG_STRUP_THR_CLR, 0x0);
/* clear power off status(POFFSTS) and PG status and BUCK OC status */
ret_val = pmic_set_register_value(PMIC_RG_POFFSTS_CLR, 0x1);
udelay(200);
ret_val = pmic_set_register_value(PMIC_RG_POFFSTS_CLR, 0x0);
/* clear Long press shutdown */
ret_val = pmic_set_register_value(PMIC_CLR_JUST_RST, 0x1);
udelay(200);
ret_val = pmic_set_register_value(PMIC_CLR_JUST_RST, 0x0);
udelay(200);
PMICLOG(PMICTAG "[pmic_boot_status] JUST_PWRKEY_RST=0x%x\n",
pmic_get_register_value(PMIC_JUST_PWRKEY_RST));
/* clear WDTRSTB_STATUS */
ret_val = pmic_set_register_value(PMIC_TOP_RST_MISC_SET, 0x8);
udelay(100);
ret_val = pmic_set_register_value(PMIC_TOP_RST_MISC_CLR, 0x8);
/* clear BUCK OC */
ret_val = pmic_config_interface(MT6357_BUCK_TOP_OC_CON0, 0xFF, 0xFF, 0);
udelay(200);
/* clear Additional(TBD) */
/* add mdelay for output the log in buffer */
mdelay(500);
return ret_val;
}
@@ -0,0 +1,54 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/delay.h>
#include <linux/mutex.h>
#include <mt-plat/upmu_common.h>
static DEFINE_MUTEX(pmic_efuse_lock_mutex);
unsigned int pmic_read_efuse_nolock(int i)
{
unsigned int efuse_data = 0;
/* 1. enable efuse ctrl engine clock */
pmic_set_register_value(PMIC_TOP_CKHWEN_CON0_CLR
, 1 << PMIC_RG_EFUSE_CK_PDN_HWEN_SHIFT);
pmic_set_register_value(PMIC_TOP_CKPDN_CON0_CLR
, 1 << PMIC_RG_EFUSE_CK_PDN_SHIFT);
/* 2. */
pmic_set_register_value(PMIC_RG_OTP_RD_SW, 1);
/* 3. Set row to read */
pmic_set_register_value(PMIC_RG_OTP_PA, i * 2);
/* 4. Toggle RG_OTP_RD_TRIG */
if (pmic_get_register_value(PMIC_RG_OTP_RD_TRIG) == 0)
pmic_set_register_value(PMIC_RG_OTP_RD_TRIG, 1);
else
pmic_set_register_value(PMIC_RG_OTP_RD_TRIG, 0);
/* 5. Polling RG_OTP_RD_BUSY = 0 */
udelay(300);
while (pmic_get_register_value(PMIC_RG_OTP_RD_BUSY) == 1)
;
/* 6. Read RG_OTP_DOUT_SW */
udelay(100);
efuse_data = pmic_get_register_value(PMIC_RG_OTP_DOUT_SW);
/* 7. disable efuse ctrl engine clock */
pmic_set_register_value(PMIC_TOP_CKHWEN_CON0_SET
, 1 << PMIC_RG_EFUSE_CK_PDN_HWEN_SHIFT);
pmic_set_register_value(PMIC_TOP_CKPDN_CON0_SET
, 1 << PMIC_RG_EFUSE_CK_PDN_SHIFT);
return efuse_data;
}
unsigned int pmic_Read_Efuse_HPOffset(int i)
{
unsigned int efuse_data = 0;
mutex_lock(&pmic_efuse_lock_mutex);
efuse_data = pmic_read_efuse_nolock(i);
mutex_unlock(&pmic_efuse_lock_mutex);
return efuse_data;
}
@@ -0,0 +1,440 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/delay.h>
#include <mt-plat/upmu_common.h>
#include <mt-plat/mtk_chip.h>
#include <mt-plat/mtk_rtc.h>
#include <linux/io.h>
#include <linux/io.h>
#include <linux/of_address.h>
#include "include/pmic.h"
#include "include/pmic_api.h"
#include "include/pmic_api_buck.h"
#include "include/regulator_codegen.h"
#define LP_INIT_SETTING_VERIFIED 1
unsigned int g_pmic_chip_version = 1;
int PMIC_MD_INIT_SETTING_V1(void)
{
/* No need for PMIC MT6357 */
return 0;
}
int PMIC_check_wdt_status(void)
{
unsigned int ret = 0;
is_wdt_reboot_pmic = pmic_get_register_value(PMIC_WDTRSTB_STATUS);
ret = pmic_set_register_value(PMIC_TOP_RST_MISC_SET, 0x8);
udelay(50);
is_wdt_reboot_pmic_chk = pmic_get_register_value(PMIC_WDTRSTB_STATUS);
ret = pmic_set_register_value(PMIC_TOP_RST_MISC_CLR, 0x8);
ret = pmic_set_register_value(PMIC_TOP_RST_MISC_SET, 0x1);
ret = pmic_get_register_value(PMIC_RG_WDTRSTB_EN);
return ret;
}
int PMIC_check_pwrhold_status(void)
{
unsigned int val = 0;
pmic_read_interface(PMIC_RG_PWRHOLD_ADDR, &val, PMIC_RG_PWRHOLD_MASK,
PMIC_RG_PWRHOLD_SHIFT);
return val;
}
int PMIC_check_battery(void)
{
unsigned int val = 0;
/* ask shin-shyu programming guide */
mt6357_upmu_set_rg_baton_en(1);
/*PMIC_upmu_set_baton_tdet_en(1);*/
val = mt6357_upmu_get_rgs_baton_undet();
if (val == 0) {
pr_debug("bat is exist.\n");
is_battery_remove = 0;
return 1;
}
pr_debug("bat NOT exist.\n");
is_battery_remove = 1;
return 0;
}
int PMIC_POWER_HOLD(unsigned int hold)
{
if (hold > 1) {
pr_notice("[PMIC_KERNEL] %s hold = %d only 0 or 1\n",
__func__, hold);
return -1;
}
if (hold)
PMICLOG("[PMIC_KERNEL] %s ON\n", __func__);
else
PMICLOG("[PMIC_KERNEL] %s OFF\n", __func__);
/* MT6357 must keep power hold */
pmic_config_interface_nolock(PMIC_RG_PWRHOLD_ADDR, hold
, PMIC_RG_PWRHOLD_MASK
, PMIC_RG_PWRHOLD_SHIFT);
PMICLOG("[PMIC_KERNEL] MT6357 PowerHold = 0x%x\n"
, upmu_get_reg_value(MT6357_PPCCTL0));
return 0;
}
unsigned int PMIC_LP_CHIP_VER(void)
{
unsigned int ret = 0;
unsigned short chip_ver = 0;
#if defined(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES)
/* PMIC special flavor project */
if (strncmp(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES,
"mediatek/evb6739_64_lp", 22) == 0 ||
strncmp(CONFIG_BUILD_ARM64_APPENDED_DTB_IMAGE_NAMES,
"mediatek/k39v1_64_lp", 20) == 0)
return 2;
#endif
#if defined(CONFIG_BUILD_ARM_APPENDED_DTB_IMAGE_NAMES)
/* PMIC special flavor project */
if (strncmp(CONFIG_BUILD_ARM_APPENDED_DTB_IMAGE_NAMES,
"evb6739_lp", 10) == 0 ||
strncmp(CONFIG_BUILD_ARM_APPENDED_DTB_IMAGE_NAMES,
"k39v1_lp", 8) == 0)
return 2;
#endif
chip_ver = pmic_get_register_value(PMIC_SWCID);
ret = ((chip_ver & 0x00F0) >> 4);
return ret;
}
unsigned int PMIC_CHIP_VER(void)
{
unsigned int ret = 0;
unsigned short chip_ver = 0;
chip_ver = pmic_get_register_value(PMIC_SWCID);
ret = ((chip_ver & 0x00F0) >> 4);
return ret;
}
#if defined(CONFIG_MACH_MT6739)
void PMIC_LP_INIT_SETTING(void)
{
g_pmic_chip_version = PMIC_CHIP_VER();
#if LP_INIT_SETTING_VERIFIED
/*Suspend*/
pmic_buck_vproc_lp(SW, 1, SW_OFF);
pmic_buck_vcore_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vmodem_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_others_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vaux18_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vaud28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vio28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_tref_lp(SW, 1, SW_OFF);
/*Deepidle*/
if (PMIC_CHIP_VER() == 1) {
pmic_buck_vproc_lp(SW, 1, SW_LP);
pmic_buck_vcore_lp(SW, 1, SW_ON);
pmic_buck_vmodem_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SW, 1, SW_LP);
pmic_ldo_vsram_others_lp(SW, 1, SW_ON);
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vaux18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vaud28_lp(SW, 1, SW_ON);
pmic_ldo_vio28_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_tref_lp(SW, 1, SW_OFF);
} else if (PMIC_CHIP_VER() >= 2) {
pmic_buck_vproc_lp(SW, 1, SW_LP);
pmic_buck_vcore_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vmodem_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SW, 1, SW_LP);
pmic_ldo_vsram_others_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vaux18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vaud28_lp(SW, 1, SW_ON);
pmic_ldo_vio28_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_tref_lp(SW, 1, SW_OFF);
} else
PMICLOG("[PMIC_LP_INIT_SETTING_v1_1705] Chip Ver = %d\n"
, PMIC_CHIP_VER());
#endif /*LP_INIT_SETTING_VERIFIED*/
}
#elif defined(CONFIG_MACH_MT6765)
void PMIC_LP_INIT_SETTING(void)
{
g_pmic_chip_version = PMIC_CHIP_VER();
PMICLOG("[PMIC_LP_INIT_SETTING_v1] Chip Ver = %d\n"
, g_pmic_chip_version);
#if LP_INIT_SETTING_VERIFIED
/*Suspend*/
pmic_buck_vproc_lp(SW, 1, SW_OFF);
/*pmic_buck_vcore_lp(SRCLKEN0, 1, HW_LP);*/
pmic_buck_vmodem_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_others_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SW, 1, SW_OFF);
pmic_ldo_vaux18_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vaud28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vio28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_tref_lp(SRCLKEN0, 1, HW_OFF);
/*Deepidle*/
pmic_buck_vproc_lp(SW, 1, SW_OFF);
/*pmic_buck_vcore_lp(SRCLKEN2, 1, HW_LP);*/
pmic_buck_vmodem_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_others_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SW, 1, SW_OFF);
pmic_ldo_vaux18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vaud28_lp(SW, 1, SW_ON);
pmic_ldo_vio28_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_tref_lp(SRCLKEN2, 1, HW_OFF);
#endif /*LP_INIT_SETTING_VERIFIED*/
}
#elif defined(CONFIG_MACH_MT6761)
void PMIC_LP_INIT_SETTING(void)
{
int i = 0;
g_pmic_chip_version = PMIC_CHIP_VER();
PMICLOG("[PMIC_LP_INIT_SETTING_v1] Chip Ver = %d mrv=%d\n"
, g_pmic_chip_version
, is_pmic_mrv());
#if LP_INIT_SETTING_VERIFIED
/* Suspend */
pmic_buck_vproc_lp(SW, 1, SW_OFF);
pmic_buck_vcore_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vmodem_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN0, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
/*pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);*/
/*pmic_ldo_vsram_others_lp(SRCLKEN0, 1, HW_LP);*/
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SW, 1, SW_OFF);
pmic_ldo_vaux18_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vaud28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vio28_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN0, 1, HW_LP);
pmic_ldo_tref_lp(SRCLKEN0, 1, HW_OFF);
/*Deepidle*/
pmic_buck_vproc_lp(SW, 1, SW_OFF);
pmic_buck_vcore_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vmodem_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vs1_lp(SRCLKEN2, 1, HW_LP);
pmic_buck_vpa_lp(SW, 1, SW_OFF);
/*pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);*/
/*pmic_ldo_vsram_others_lp(SRCLKEN2, 1, HW_LP);*/
pmic_ldo_vfe28_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vxo22_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vrf18_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vrf12_lp(SRCLKEN1, 1, HW_OFF);
pmic_ldo_vefuse_lp(SW, 1, SW_OFF);
pmic_ldo_vcn33_lp(SW, 1, SW_OFF);
pmic_ldo_vcn28_lp(SW, 1, SW_OFF);
pmic_ldo_vcn18_lp(SW, 1, SW_OFF);
pmic_ldo_vcama_lp(SW, 1, SW_OFF);
pmic_ldo_vcamd_lp(SW, 1, SW_OFF);
pmic_ldo_vcamio_lp(SW, 1, SW_OFF);
pmic_ldo_vldo28_lp(SW, 1, SW_OFF);
pmic_ldo_vaux18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vaud28_lp(SW, 1, SW_ON);
pmic_ldo_vio28_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vio18_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vdram_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_vmc_lp(SW, 1, SW_OFF);
pmic_ldo_vmch_lp(SW, 1, SW_OFF);
pmic_ldo_vemc_lp(SW, 1, SW_OFF);
pmic_ldo_vsim1_lp(SW, 1, SW_OFF);
pmic_ldo_vsim2_lp(SW, 1, SW_OFF);
pmic_ldo_vibr_lp(SW, 1, SW_OFF);
pmic_ldo_vusb33_lp(SRCLKEN2, 1, HW_LP);
pmic_ldo_tref_lp(SRCLKEN2, 1, HW_OFF);
/* Workaround setting for MT6357 MRV */
if (is_pmic_mrv()) {
/* Suspend */
pmic_ldo_vsram_others_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SRCLKEN0, 1, HW_LP);
/* Deepidle */
pmic_ldo_vsram_others_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_proc_lp(SRCLKEN2, 1, HW_LP);
/* Update regulator ops */
for (i = 0; i < pmic_regulator_ldo_matches_size; i++) {
if (strncmp(mt_ldos[i].desc.name,
"vsram_others", 12) == 0) {
mt_ldos[i].en_cb =
mt6357_upmu_set_rg_ldo_vsram_proc_en;
mt_ldos[i].vol_cb =
mt6357_upmu_set_rg_ldo_vsram_proc_vosel;
mt_ldos[i].da_en_cb =
mt6357_upmu_get_da_vsram_proc_en;
mt_ldos[i].da_vol_cb =
mt6357_upmu_get_da_vsram_proc_vosel;
} else if (strncmp(mt_ldos[i].desc.name,
"vsram_proc", 10) == 0) {
mt_ldos[i].en_cb =
mt6357_upmu_set_rg_ldo_vsram_others_en;
mt_ldos[i].vol_cb =
mt6357_upmu_set_rg_ldo_vsram_others_vosel;
mt_ldos[i].da_en_cb =
mt6357_upmu_get_da_vsram_others_en;
mt_ldos[i].da_vol_cb =
mt6357_upmu_get_da_vsram_others_vosel;
}
}
} else {
/* Suspend */
pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_others_lp(SRCLKEN0, 1, HW_LP);
/* Deepidle */
pmic_ldo_vsram_proc_lp(SW, 1, SW_OFF);
pmic_ldo_vsram_others_lp(SRCLKEN2, 1, HW_LP);
}
#endif /*LP_INIT_SETTING_VERIFIED*/
}
#endif
@@ -0,0 +1,238 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/ratelimit.h>
#include <mt-plat/upmu_common.h>
#include <sspm_ipi_pin.h>
#include <v1/sspm_ipi.h>
#include <include/pmic_ipi.h>
#include <include/pmic_ipi_service_id.h>
#ifdef SSPM_STF
#include <linux/init.h>
#include "sspm_stf.h"
#endif /*--SSPM_STF--*/
unsigned int pmic_ipi_to_sspm(void *buffer, void *retbuf, unsigned char lock)
{
int ret_val = 0;
int ipi_ret = 0;
unsigned int cmd = ((struct pmic_ipi_cmds *)buffer)->cmd[0];
#ifdef CONFIG_MTK_RAM_CONSOLE
unsigned int monitor_cmd = ((struct pmic_ipi_cmds *)buffer)->cmd[1];
unsigned int val = ((struct pmic_ipi_cmds *)buffer)->cmd[2];
#endif
/*unsigned long flags;*/
/*spin_lock_irqsave(&pmic_ipi_spinlock, flags);*/
#ifdef CONFIG_MTK_RAM_CONSOLE
if (monitor_cmd == 0x16B8) {
aee_rr_rec_set_bit_pmic_ext_buck(val, 4);
aee_rr_rec_set_bit_pmic_ext_buck(1, 5);
}
#endif
ret_val = sspm_ipi_send_sync(IPI_ID_PMIC, IPI_OPT_POLLING, buffer,
PMIC_IPI_SEND_SLOT_SIZE, retbuf,
PMIC_IPI_ACK_SLOT_SIZE);
#ifdef CONFIG_MTK_RAM_CONSOLE
if (monitor_cmd == 0x16B8)
aee_rr_rec_set_bit_pmic_ext_buck(0, 5);
#endif
/*spin_unlock_irqrestore(&pmic_ipi_spinlock, flags);*/
ipi_ret = ((struct pmic_ipi_ret_datas *)retbuf)->data[0];
switch (cmd) {
case MAIN_PMIC_WRITE_REGISTER:
if (ret_val) {
if (ret_val == IPI_BUSY || ret_val == IPI_TIMEOUT_ACK) {
if (ipi_ret != 0)
pr_notice_ratelimited("%s ap_ret_w = %d ipi_ret_w =%d\n"
, __func__
, ret_val, ipi_ret);
} else
/* Real PMIC service execution result
* ,by each PMIC service
*/
pr_notice_ratelimited("%s ap_ret_w = %d ipi_ret_w =%d\n"
, __func__
, ret_val
, ipi_ret);
} else {
if (ipi_ret != 0)
pr_notice_ratelimited("%s ap_ret_w = %d ipi_ret_w =%d\n"
, __func__
, ret_val, ipi_ret);
}
ret_val = ipi_ret;
break;
case MAIN_PMIC_READ_REGISTER:
if (ret_val) {
if (ret_val == IPI_BUSY || ret_val == IPI_TIMEOUT_ACK) {
if (ipi_ret != 0)
pr_notice_ratelimited("%s ap_ret_r = %d ipi_ret_r =%d\n"
, __func__
, ret_val, ipi_ret);
} else
/* Real PMIC service execution result
* ,by each PMIC service
*/
pr_notice_ratelimited("%s ap_ret_r = %d ipi_ret_r =%d\n"
, __func__
, ret_val, ipi_ret);
} else {
if (ipi_ret != 0)
pr_notice_ratelimited("%s ap_ret_r = %d ipi_ret_r =%d\n"
, __func__
, ret_val, ipi_ret);
}
ret_val = ipi_ret;
break;
case MAIN_PMIC_REGULATOR:
break;
case SUB_PMIC_CTRL:
break;
default:
pr_notice_ratelimited("%s(%d) cmd(%d) wrong!!!\n"
, __func__, __LINE__, cmd);
break;
}
return ret_val;
}
unsigned int pmic_ipi_read_interface(unsigned int RegNum,
unsigned int *val,
unsigned int MASK,
unsigned int SHIFT,
unsigned char lock)
{
struct pmic_ipi_cmds send = { {0} };
struct pmic_ipi_ret_datas recv = { {0} };
unsigned int ret = 0;
send.cmd[0] = MAIN_PMIC_READ_REGISTER;
send.cmd[1] = RegNum;
send.cmd[2] = MASK;
send.cmd[3] = SHIFT;
ret = pmic_ipi_to_sspm(&send, &recv, lock);
if (ret >= 0)
*val = recv.data[1];
return ret;
}
unsigned int pmic_ipi_config_interface(unsigned int RegNum,
unsigned int val,
unsigned int MASK,
unsigned int SHIFT,
unsigned char lock)
{
struct pmic_ipi_cmds send = { {0} };
struct pmic_ipi_ret_datas recv = { {0} };
unsigned int ret = 0;
send.cmd[0] = MAIN_PMIC_WRITE_REGISTER;
send.cmd[1] = RegNum;
send.cmd[2] = val;
send.cmd[3] = MASK;
send.cmd[4] = SHIFT;
ret = pmic_ipi_to_sspm(&send, &recv, lock);
return ret;
}
unsigned int mt6311_ipi_set_mode(unsigned char mode)
{
struct pmic_ipi_cmds send = { {0} };
struct pmic_ipi_ret_datas recv = { {0} };
unsigned int ret = 0;
send.cmd[0] = MT6311_FPWM;
send.cmd[1] = mode;
ret = pmic_ipi_to_sspm(&send, &recv, 1);
return ret;
}
#ifdef SSPM_STF
struct pmic_ipi_cmds stf_send = {
.cmd[0] = MAIN_PMIC_WRITE_REGISTER,
.cmd[1] = 0xC06,
.cmd[2] = 0x5AA5,
.cmd[3] = 0xFFFF,
.cmd[4] = 0,
};
struct pmic_ipi_ret_datas stf_recv = { {0} };
unsigned int stf_val;
/*
* 0: SSPM_STF_PASS
* 1: SSPM_STF_FAIL
*/
int stf_pmic_test(void *data)
{
pr_debug("%s\n", __func__);
stf_val = 0;
stf_val = sspm_ipi_send_sync_ex(IPI_ID_PMIC, IPI_OPT_DEFAUT, &stf_send,
PMIC_IPI_SEND_SLOT_SIZE, &stf_recv,
PMIC_IPI_ACK_SLOT_SIZE);
return stf_val;
}
int stf_pmic_chk(void *data)
{
unsigned int ret_val = 0;
/* Real PMIC service execution result, by each PMIC service */
if (stf_val) {
ret_val = ((struct pmic_ipi_ret_datas *)(&stf_recv))->data[0];
pr_debug("%s = %d\n", __func__, ret_val);
}
return ret_val;
}
struct chk_data stf_pmic_chk_data[] = {
{
.ack_data = 0,
.time_us = 100,
},
};
struct sspm_stf_device pmic = {
.name = "PMIC",
.ID = IPI_ID_PMIC,
.ipi_num = 1,
.ipi_chk_data = stf_pmic_chk_data,
.start_addr = NULL,
.len_byte = 0,
.bin_file = NULL,
.test_func = stf_pmic_test,
.chk_func = stf_pmic_chk,
};
static int __init sspm_stf_pmic_init(void)
{
sspm_stf_register(&pmic);
return 0;
}
late_initcall(sspm_stf_pmic_init);
#endif /*--SSPM_STF--*/
@@ -0,0 +1,308 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of_irq.h>
#if defined(CONFIG_MTK_AEE_FEATURE)
#include <mt-plat/aee.h>
#endif
#include <mt-plat/upmu_common.h>
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
#include <mach/mtk_pmic_wrap.h>
#endif
#include <mach/mtk_pmic.h>
#include "include/pmic.h"
#include "include/pmic_irq.h"
#include <mt-plat/mtk_ccci_common.h>
#include <linux/mfd/mt6358/core.h>
struct legacy_pmic_callback {
bool has_requested;
void (*callback)(void);
};
static struct device *pmic_dev;
static struct legacy_pmic_callback pmic_cbs[300];
/* KEY Int Handler */
irqreturn_t key_int_handler(int irq, void *data)
{
struct irq_desc *desc = irq_to_desc(irq);
unsigned int hwirq;
if (desc)
hwirq = irqd_to_hwirq(&desc->irq_data);
else
return IRQ_HANDLED;
#if !defined(CONFIG_FPGA_EARLY_PORTING) && defined(CONFIG_KPD_PWRKEY_USE_PMIC)
switch (hwirq) {
case INT_PWRKEY:
IRQLOG("Press pwrkey %d\n",
pmic_get_register_value(PMIC_PWRKEY_DEB));
kpd_pwrkey_pmic_handler(0x1);
break;
case INT_PWRKEY_R:
IRQLOG("Release pwrkey %d\n",
pmic_get_register_value(PMIC_PWRKEY_DEB));
kpd_pwrkey_pmic_handler(0x0);
break;
case INT_HOMEKEY:
IRQLOG("Press homekey %d\n",
pmic_get_register_value(PMIC_HOMEKEY_DEB));
kpd_pmic_rstkey_handler(0x1);
break;
case INT_HOMEKEY_R:
IRQLOG("Release homekey %d\n",
pmic_get_register_value(PMIC_HOMEKEY_DEB));
kpd_pmic_rstkey_handler(0x0);
break;
}
#endif
return IRQ_HANDLED;
}
irqreturn_t legacy_pmic_int_handler(int irq, void *data)
{
struct legacy_pmic_callback *pmic_cb = data;
pmic_cb->callback();
return IRQ_HANDLED;
}
/*
* PMIC Interrupt service
*/
void pmic_enable_interrupt(enum PMIC_IRQ_ENUM intNo, unsigned int en, char *str)
{
int ret;
unsigned int irq;
const char *name;
struct legacy_pmic_callback *pmic_cb = &pmic_cbs[intNo];
struct irq_desc *desc;
if (!pmic_dev) {
pr_notice("[%s] PMIC not ready\n", __func__);
return;
}
if (intNo == INT_ENUM_MAX) {
pr_notice(PMICTAG "[%s] disable intNo=%d\n", __func__, intNo);
return;
} else if (pmic_cb->callback == NULL) {
pr_notice(PMICTAG "[%s] No callback at intNo=%d\n",
__func__, intNo);
return;
}
irq = mt6358_irq_get_virq(pmic_dev->parent, intNo);
if (!irq) {
pr_notice(PMICTAG "[%s] fail intNo=%d\n", __func__, intNo);
return;
}
name = mt6358_irq_get_name(pmic_dev->parent, intNo);
if (name == NULL) {
pr_notice(PMICTAG "[%s] no irq name at intNo=%d\n",
__func__, intNo);
return;
}
if (en == 1) {
if (!(pmic_cb->has_requested)) {
ret = devm_request_threaded_irq(pmic_dev, irq, NULL,
legacy_pmic_int_handler, IRQF_TRIGGER_HIGH,
name, pmic_cb);
if (ret < 0)
pr_notice(PMICTAG "[%s] request %s irq fail\n",
__func__, name);
else
pmic_cb->has_requested = true;
} else
enable_irq(irq);
} else if (en == 0 && pmic_cb->has_requested)
disable_irq_nosync(irq);
desc = irq_to_desc(irq);
pr_info("[%s] intNo=%d, en=%d, depth=%d\n",
__func__, intNo, en, desc ? desc->depth : -1);
}
void pmic_register_interrupt_callback(enum PMIC_IRQ_ENUM intNo,
void (EINT_FUNC_PTR) (void))
{
struct legacy_pmic_callback *pmic_cb = &pmic_cbs[intNo];
if (intNo == INT_ENUM_MAX) {
pr_info(PMICTAG "[%s] disable intNo=%d\n", __func__, intNo);
return;
}
pr_info("[%s] intNo=%d, callback=%pf\n",
__func__, intNo, EINT_FUNC_PTR);
pmic_cb->callback = EINT_FUNC_PTR;
}
#if ENABLE_ALL_OC_IRQ
/* General OC Int Handler */
static void oc_int_handler(enum PMIC_IRQ_ENUM intNo, const char *int_name)
{
#if defined(CONFIG_MTK_AEE_FEATURE)
char oc_str[30] = "";
#endif
IRQLOG("[%s] int name=%s\n", __func__, int_name);
switch (intNo) {
case INT_VCN33_OC:
/* keep OC interrupt and keep tracking */
pr_notice(PMICTAG "[PMIC_INT] PMIC OC: %s\n", int_name);
break;
default:
/* issue AEE exception and disable OC interrupt */
kernel_dump_exception_reg();
#if defined(CONFIG_MTK_AEE_FEATURE)
snprintf(oc_str, 30, "PMIC OC:%s", int_name);
aee_kernel_warning(oc_str
, "\nCRDISPATCH_KEY:PMIC OC\nOC Interrupt: %s"
, int_name);
#endif
pmic_enable_interrupt(intNo, 0, "PMIC");
pr_notice(PMICTAG "[PMIC_INT] disable OC interrupt: %s\n"
, int_name);
break;
}
}
static void md_oc_int_handler(enum PMIC_IRQ_ENUM intNo, const char *int_name)
{
int ret = 0;
int data_int32 = 0;
#if defined(CONFIG_MTK_AEE_FEATURE)
char oc_str[30] = "";
#endif
switch (intNo) {
case INT_VPA_OC:
data_int32 = 1 << 0;
break;
case INT_VFE28_OC:
data_int32 = 1 << 1;
break;
case INT_VRF12_OC:
data_int32 = 1 << 2;
break;
case INT_VRF18_OC:
data_int32 = 1 << 3;
break;
default:
break;
}
#ifdef CONFIG_MTK_CCCI_DEVICES
#if defined(CONFIG_MTK_AEE_FEATURE)
snprintf(oc_str, 30, "PMIC OC:%s", int_name);
aee_kernel_warning(oc_str, "\nCRDISPATCH_KEY:MD OC\nOC Interrupt: %s"
, int_name);
#endif
ret = exec_ccci_kern_func_by_md_id(MD_SYS1, ID_PMIC_INTR
, (char *)&data_int32, 4);
#endif
if (ret)
pr_notice("[%s] - exec_ccci_kern_func_by_md_id - msg fail\n"
, __func__);
pmic_enable_interrupt(intNo, 0, "PMIC");
pr_notice(PMICTAG "[PMIC_INT] disable OC interrupt: %s\n"
, int_name);
pr_info("[%s]Send msg pass\n", __func__);
}
/* register general oc interrupt handler */
void pmic_register_oc_interrupt_callback(enum PMIC_IRQ_ENUM intNo)
{
unsigned int spNo, sp_conNo, sp_irqNo;
if (pmic_check_intNo(intNo, &spNo, &sp_conNo, &sp_irqNo)) {
pr_notice(PMICTAG "[%s] fail intNo=%d\n", __func__, intNo);
return;
}
IRQLOG("[%s] intNo=%d\n", __func__, intNo);
switch (intNo) {
case INT_VPA_OC:
case INT_VFE28_OC:
case INT_VRF12_OC:
case INT_VRF18_OC:
sp_interrupts[spNo].sp_irqs[sp_conNo][sp_irqNo].oc_callback =
md_oc_int_handler;
break;
default:
sp_interrupts[spNo].sp_irqs[sp_conNo][sp_irqNo].oc_callback =
oc_int_handler;
break;
}
}
/* register and enable all oc interrupt */
void register_all_oc_interrupts(void)
{
enum PMIC_IRQ_ENUM oc_int;
/* BUCK OC */
for (oc_int = INT_VPROC_OC; oc_int <= INT_VPA_OC; oc_int++) {
pmic_register_oc_interrupt_callback(oc_int);
pmic_enable_interrupt(oc_int, 1, "PMIC");
}
/* LDO OC */
for (oc_int = INT_VFE28_OC; oc_int <= INT_VSIM2_OC; oc_int++) {
switch (oc_int) {
case INT_VCN33_OC:
case INT_VSIM1_OC:
case INT_VSIM2_OC:
case INT_VMCH_OC:
case INT_VCAMA_OC:
case INT_VCAMD_OC:
case INT_VCAMIO_OC:
case INT_VLDO28_OC:
IRQLOG("[PMIC_INT] non-enabled OC: %d\n", oc_int);
break;
default:
pmic_register_oc_interrupt_callback(oc_int);
pmic_enable_interrupt(oc_int, 1, "PMIC");
break;
}
}
}
#endif
void PMIC_EINT_SETTING(struct platform_device *pdev)
{
int ret = 0;
pmic_dev = &pdev->dev;
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "pwrkey"),
NULL, key_int_handler, IRQF_TRIGGER_NONE,
"pwrkey", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request PWRKEY irq fail\n");
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "pwrkey_r"),
NULL, key_int_handler, IRQF_TRIGGER_NONE,
"pwrkey_r", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request PWRKEY_R irq fail\n");
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "homekey"),
NULL, key_int_handler, IRQF_TRIGGER_NONE,
"homekey", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request HOMEKEY irq fail\n");
ret = devm_request_threaded_irq(&pdev->dev,
platform_get_irq_byname(pdev, "homekey_r"),
NULL, key_int_handler, IRQF_TRIGGER_NONE,
"homekey_r", NULL);
if (ret < 0)
dev_notice(&pdev->dev, "request HOMEKEY_R irq fail\n");
}
MODULE_AUTHOR("Jeter Chen");
MODULE_DESCRIPTION("MT PMIC Interrupt Driver");
MODULE_LICENSE("GPL");
@@ -0,0 +1,436 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2021 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <mach/upmu_sw.h>
#include <mach/upmu_hw.h>
#include <mt-plat/upmu_common.h>
#include "include/pmic.h"
#include "include/pmic_api_buck.h"
/* --------------------------------------------------------------- */
/* pmic_<type>_<name>_lp (<user>, <op_en>, <op_cfg>) */
/* parameter */
/* <type> : BUCK / LDO */
/* <name> : BUCK name / LDO name */
/* <user> : SRCLKEN0 / SRCLKEN1 / SRCLKEN2 / SRCLKEN3 / SW / SPM */
/* <op_en> : user control enable */
/* <op_cfg> : */
/* HW mode : */
/* 0 : define as ON/OFF control */
/* 1 : define as LP/No LP control */
/* SW/SPM : */
/* 0 : OFF */
/* 1 : ON */
/* --------------------------------------------------------------- */
#define pmic_set_sw_en(addr, val) \
pmic_config_interface_nolock(addr, val, 1, 0)
#define pmic_set_sw_lp(addr, val) \
pmic_config_interface_nolock(addr, val, 1, 1)
#define pmic_set_op_en(user, addr, val) \
pmic_config_interface_nolock(addr, val, 1, user)
#define pmic_set_op_cfg(user, addr, val) \
pmic_config_interface_nolock(addr, val, 1, user)
#define pmic_get_op_en(user, addr, pval) \
pmic_read_interface_nolock(addr, pval, 1, user)
#define pmic_get_op_cfg(user, addr, pval) \
pmic_read_interface_nolock(addr, pval, 1, user)
#define en_cfg_shift 0x6
#if defined(LGS) || defined(LGSWS)
const struct PMU_LP_TABLE_ENTRY pmu_lp_table[] = {
PMIC_LP_BUCK_ENTRY(VPROC),
PMIC_LP_BUCK_ENTRY(VCORE),
PMIC_LP_BUCK_ENTRY(VMODEM),
PMIC_LP_BUCK_ENTRY(VS1),
PMIC_LP_BUCK_ENTRY(VPA),
PMIC_LP_LDO_ENTRY(VSRAM_PROC),
PMIC_LP_LDO_ENTRY(VSRAM_OTHERS),
PMIC_LP_LDO_ENTRY(VFE28),
PMIC_LP_LDO_ENTRY(VXO22),
PMIC_LP_LDO_ENTRY(VRF18),
PMIC_LP_LDO_ENTRY(VRF12),
PMIC_LP_LDO_ENTRY(VEFUSE),
PMIC_LP_LDO_VCN33_0_ENTRY(VCN33_0),
PMIC_LP_LDO_VCN33_1_ENTRY(VCN33_1),
PMIC_LP_LDO_ENTRY(VCN28),
PMIC_LP_LDO_ENTRY(VCN18),
PMIC_LP_LDO_ENTRY(VCAMA),
PMIC_LP_LDO_ENTRY(VCAMD),
PMIC_LP_LDO_ENTRY(VCAMIO),
PMIC_LP_LDO_VLDO28_0_ENTRY(VLDO28_0),
PMIC_LP_LDO_VLDO28_1_ENTRY(VLDO28_1),
PMIC_LP_LDO_ENTRY(VAUX18),
PMIC_LP_LDO_ENTRY(VAUD28),
PMIC_LP_LDO_ENTRY(VIO28),
PMIC_LP_LDO_ENTRY(VIO18),
PMIC_LP_LDO_ENTRY(VDRAM),
PMIC_LP_LDO_ENTRY(VMC),
PMIC_LP_LDO_ENTRY(VMCH),
PMIC_LP_LDO_ENTRY(VEMC),
PMIC_LP_LDO_ENTRY(VSIM1),
PMIC_LP_LDO_ENTRY(VSIM2),
PMIC_LP_LDO_ENTRY(VIBR),
PMIC_LP_LDO_VUSB33_0_ENTRY(VUSB33_0),
PMIC_LP_LDO_VUSB33_1_ENTRY(VUSB33_1),
PMIC_LP_LDO_ENTRY(TREF),
};
static int pmic_lp_golden_set(unsigned int en_adr,
unsigned char op_en, unsigned char op_cfg)
{
unsigned int en_cfg = 0, lp_cfg = 0;
/*--op_cfg 0:SW_OFF, 1:SW_EN, 3: SW_LP (SPM)--*/
if (op_en > 1 || op_cfg > 3) {
pr_notice("p\n");
return -1;
}
en_cfg = op_cfg & 0x1;
lp_cfg = (op_cfg >> 1) & 0x1;
pmic_set_sw_en(en_adr, en_cfg);
pmic_set_sw_lp(en_adr, lp_cfg);
}
#endif
static int pmic_lp_type_set(unsigned short en_cfg_adr,
enum PMU_LP_TABLE_ENUM name,
enum BUCK_LDO_EN_USER user,
unsigned char op_en,
unsigned char op_cfg)
{
unsigned int rb_en = 0, rb_cfg = 0, max_cfg = 1;
unsigned short op_en_adr = 0, op_cfg_adr = 0;
int ret = 0, ret_en = 0, ret_cfg = 0;
if (en_cfg_adr) {
op_en_adr = en_cfg_adr;
op_cfg_adr = (unsigned short)(en_cfg_adr + en_cfg_shift);
}
/*--else keep default adr = 0--*/
if (user == SW || user == SPM) {
max_cfg = 3;
rb_cfg = 0;
rb_en = 0;
}
if (op_en > 1 || op_cfg > max_cfg) {
pr_notice("p\n");
return -1;
}
PMICLOG("0x%x,type %d\n", en_cfg_adr, user);
#if defined(LGS) || defined(LGSWS)
const struct PMU_LP_TABLE_ENTRY *pFlag = &pmu_lp_table[name];
if (user == SW || user == SPM)
pmic_lp_golden_set((unsigned int)pFlag->en_adr, op_en, op_cfg);
#endif
if (op_cfg_adr && op_en_adr) {
pmic_set_op_en(user, op_en_adr, op_en);
pmic_get_op_en(user, op_en_adr, &rb_en);
PMICLOG("user = %d, op en = %d\n", user, rb_en);
(rb_en == op_en) ? (ret_en = 0) : (ret_en = -1);
if (user != SW && user != SPM) {
pmic_set_op_cfg(user, op_cfg_adr, op_cfg);
pmic_get_op_cfg(user, op_cfg_adr, &rb_cfg);
(rb_cfg == op_cfg) ? (ret_cfg = 0) : (ret_cfg - 1);
PMICLOG("user = %d, op cfg = %d\n", user, rb_cfg);
}
}
((!ret_en) && (!ret_cfg)) ? (ret = 0) : (ret = -1);
if (ret)
pr_notice("%d, %d, %d\n", user, ret_en, ret_cfg);
return ret;
}
int pmic_buck_vproc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_BUCK_VPROC_OP_EN,
VPROC, user, op_en, op_cfg);
}
int pmic_buck_vcore_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_BUCK_VCORE_OP_EN,
VCORE, user, op_en, op_cfg);
}
int pmic_buck_vmodem_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_BUCK_VMODEM_OP_EN,
VMODEM, user, op_en, op_cfg);
}
int pmic_buck_vs1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_BUCK_VS1_OP_EN,
VS1, user, op_en, op_cfg);
}
int pmic_buck_vpa_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(0, VPA, user, op_en, op_cfg);
}
int pmic_ldo_vsram_proc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VSRAM_PROC_OP_EN,
VSRAM_PROC, user, op_en, op_cfg);
}
int pmic_ldo_vsram_others_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VSRAM_OTHERS_OP_EN,
VSRAM_OTHERS, user, op_en, op_cfg);
}
int pmic_ldo_vfe28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VFE28_OP_EN,
VFE28, user, op_en, op_cfg);
}
int pmic_ldo_vxo22_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VXO22_OP_EN,
VXO22, user, op_en, op_cfg);
}
int pmic_ldo_vrf18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VRF18_OP_EN,
VRF18, user, op_en, op_cfg);
}
int pmic_ldo_vrf12_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VRF12_OP_EN,
VRF12, user, op_en, op_cfg);
}
int pmic_ldo_vefuse_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VEFUSE_OP_EN,
VEFUSE, user, op_en, op_cfg);
}
int pmic_ldo_vcn33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
int ret = 0;
PMICLOG("%s\n", __func__);
ret = pmic_lp_type_set(MT6357_LDO_VCN33_OP_EN,
VCN33_0, user, op_en, op_cfg);
if (ret)
return ret;
ret = pmic_lp_type_set(MT6357_LDO_VCN33_OP_EN,
VCN33_1, user, op_en, op_cfg);
return ret;
}
int pmic_ldo_vcn28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VCN28_OP_EN,
VCN28, user, op_en, op_cfg);
}
int pmic_ldo_vcn18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VCN18_OP_EN,
VCN18, user, op_en, op_cfg);
}
int pmic_ldo_vcama_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VCAMA_OP_EN,
VCAMA, user, op_en, op_cfg);
}
int pmic_ldo_vcamd_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VCAMD_OP_EN,
VCAMD, user, op_en, op_cfg);
}
int pmic_ldo_vcamio_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VCAMIO_OP_EN,
VCAMIO, user, op_en, op_cfg);
}
int pmic_ldo_vldo28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
int ret = 0;
PMICLOG("%s\n", __func__);
ret = pmic_lp_type_set(MT6357_LDO_VLDO28_OP_EN,
VLDO28_0, user, op_en, op_cfg);
if (ret)
return ret;
ret = pmic_lp_type_set(MT6357_LDO_VLDO28_OP_EN,
VLDO28_1, user, op_en, op_cfg);
return ret;
}
int pmic_ldo_vaux18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VAUX18_OP_EN,
VAUX18, user, op_en, op_cfg);
}
int pmic_ldo_vaud28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VAUD28_OP_EN,
VAUD28, user, op_en, op_cfg);
}
int pmic_ldo_vio28_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VIO28_OP_EN,
VIO28, user, op_en, op_cfg);
}
int pmic_ldo_vio18_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VIO18_OP_EN,
VIO18, user, op_en, op_cfg);
}
int pmic_ldo_vdram_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VDRAM_OP_EN,
VDRAM, user, op_en, op_cfg);
}
int pmic_ldo_vmc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VMC_OP_EN,
VMC, user, op_en, op_cfg);
}
int pmic_ldo_vmch_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VMCH_OP_EN,
VMCH, user, op_en, op_cfg);
}
int pmic_ldo_vemc_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VEMC_OP_EN,
VEMC, user, op_en, op_cfg);
}
int pmic_ldo_vsim1_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VSIM1_OP_EN,
VSIM1, user, op_en, op_cfg);
}
int pmic_ldo_vsim2_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VSIM2_OP_EN,
VSIM2, user, op_en, op_cfg);
}
int pmic_ldo_vibr_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_VIBR_OP_EN,
VIBR, user, op_en, op_cfg);
}
int pmic_ldo_vusb33_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
int ret = 0;
PMICLOG("%s\n", __func__);
ret = pmic_lp_type_set(MT6357_LDO_VUSB33_OP_EN,
VUSB33_0, user, op_en, op_cfg);
if (ret)
return ret;
ret = pmic_lp_type_set(MT6357_LDO_VUSB33_OP_EN,
VUSB33_1, user, op_en, op_cfg);
return ret;
}
int pmic_ldo_tref_lp(enum BUCK_LDO_EN_USER user,
unsigned char op_en, unsigned char op_cfg)
{
PMICLOG("%s\n", __func__);
return pmic_lp_type_set(MT6357_LDO_TREF_OP_EN,
TREF, user, op_en, op_cfg);
}
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -0,0 +1 @@
obj-y += v1/
@@ -0,0 +1,53 @@
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic
ccflags-y += -I$(srctree)/drivers/misc/mediatek/pmic_wrap/$(CONFIG_MTK_PLATFORM)
ccflags-y += -I$(srctree)/drivers/misc/mediatek/base/power/include
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/battery
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/charger
ccflags-y += -I$(srctree)/drivers/power/supply/mediatek/misc
ccflags-y += -I$(srctree)/drivers/misc/mediatek/usb_c/tcpc/inc
subdir-ccflags-y += -Werror -I$(srctree)/drivers/misc/mediatek/pmic/include
ifeq ($(CONFIG_MTK_TINYSYS_SSPM_SUPPORT), y)
ifeq ($(CONFIG_MACH_MT6781),y)
# SSPM V2
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/v2
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/mt6781/
obj-y += pmic_ipi_v2.o
else
#ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/
ifneq ($(CONFIG_MTK_TINYSYS_SSPM_VERSION),"")
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/$(CONFIG_MTK_TINYSYS_SSPM_VERSION)/
else
ccflags-y += -I$(srctree)/drivers/misc/mediatek/sspm/$(MTK_PLATFORM)/
endif
obj-y += pmic_ipi.o
endif
endif
ifeq ($(CONFIG_MTK_GAUGE_VERSION),30)
ifeq ($(CONFIG_MACH_MT6781),y)
obj-y += mt6366_gauge.o
else
obj-y += mt6358_gauge.o
endif
endif
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += pmic.o pmic_common.o \
pmic_debugfs.o \
pmic_irq.o \
pmic_initial_setting.o \
pmic_api.o \
pmic_auxadc.o \
regulator_codegen.o \
pmic_lp_api.o \
pmic_efuse.o \
pmic_throttling_dlpt.o \
#TODO
#pmic_bif.o \
ifndef CONFIG_MTK_EXTERNAL_CHARGER_TYPE_DETECT
obj-$(CONFIG_MTK_PMIC_CHIP_MT6358) += pmic_dummy_chr_type_det.o
endif
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+217
View File
@@ -0,0 +1,217 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include <generated/autoconf.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <mt-plat/mtk_devinfo.h>
#include <mt-plat/upmu_common.h>
#include "include/pmic.h"
#include "include/regulator_codegen.h"
#if defined(CONFIG_MACH_MT6781)
#include <linux/of_gpio.h>
static unsigned int g_is_new_power_grid;
unsigned int is_pmic_new_power_grid(void)
{
return g_is_new_power_grid;
}
void record_is_pmic_new_power_grid(struct platform_device *pdev)
{
unsigned int GPIO200_idx = 0;
GPIO200_idx = of_get_named_gpio(pdev->dev.of_node, "pmic,init_gpio", 0);
if (gpio_get_value(GPIO200_idx))
g_is_new_power_grid = 1;
pr_info("[PMIC] (GPIO200)(%d) = %d\n", GPIO200_idx, g_is_new_power_grid);
}
#endif
void record_md_vosel(void)
{
g_vmodem_vosel = pmic_get_register_value(PMIC_RG_BUCK_VMODEM_VOSEL);
pr_info("[%s] vmodem_vosel = 0x%x\n", __func__, g_vmodem_vosel);
}
/* [Export API] */
#if defined(CONFIG_MACH_MT6781)
void vmd1_pmic_setting_on(void)
{
unsigned int vsram_md_vosel = 0x4F; /*993750*/
/* 1.Call PMIC driver API configure VMODEM voltage */
if (g_vmodem_vosel != 0) {
if (is_pmic_new_power_grid())
pmic_config_interface(PMIC_RG_LDO_VSRAM_CORE_VOSEL_ADDR, vsram_md_vosel,
PMIC_RG_LDO_VSRAM_CORE_VOSEL_MASK,
PMIC_RG_LDO_VSRAM_CORE_VOSEL_SHIFT);
else
pmic_set_register_value(PMIC_RG_LDO_VSRAM_OTHERS_VOSEL, vsram_md_vosel);
pmic_set_register_value(PMIC_RG_BUCK_VMODEM_VOSEL, g_vmodem_vosel);
pr_info("[%s] set vmodem=0x%x vsram_md=0x%x\n"
, __func__, g_vmodem_vosel, vsram_md_vosel);
} else {
pr_notice("[%s] vmodem vosel has not recorded!\n", __func__);
record_md_vosel();
}
}
#else
void vmd1_pmic_setting_on(void)
{
/* 1.Call PMIC driver API configure VMODEM voltage */
if (g_vmodem_vosel != 0) {
pmic_set_register_value(PMIC_RG_BUCK_VMODEM_VOSEL,
g_vmodem_vosel);
} else {
pr_notice("[%s] vmodem vosel has not recorded!\n", __func__);
g_vmodem_vosel =
pmic_get_register_value(PMIC_RG_BUCK_VMODEM_VOSEL);
pr_info("[%s] vmodem_vosel = 0x%x\n",
__func__, g_vmodem_vosel);
}
if (pmic_get_register_value(PMIC_DA_VMODEM_VOSEL) != g_vmodem_vosel)
pr_notice("[%s] vmodem vosel = 0x%x, da_vosel = 0x%x",
__func__,
pmic_get_register_value(PMIC_RG_BUCK_VMODEM_VOSEL),
pmic_get_register_value(PMIC_DA_VMODEM_VOSEL));
}
#endif
void vmd1_pmic_setting_off(void)
{
PMICLOG("%s\n", __func__);
}
void pmic_enable_smart_reset(unsigned char smart_en,
unsigned char smart_sdn_en)
{
pr_notice("[%s] pwrkey %s, JUST_SMART_RST:%d\n", __func__,
pmic_get_register_value(PMIC_PWRKEY_DEB)?"released":"pressed",
pmic_get_register_value(PMIC_JUST_SMART_RST));
pmic_set_register_value(PMIC_RG_SMART_RST_MODE, smart_en);
pmic_set_register_value(PMIC_RG_SMART_RST_SDN_EN, smart_sdn_en);
pr_info("[%s] smart_en:%d, smart_sdn_en:%d\n",
__func__, smart_en, smart_sdn_en);
}
void wk_pmic_enable_sdn_delay(void)
{
pmic_set_register_value(PMIC_TMA_KEY, 0x9CA7);
pmic_set_register_value(PMIC_RG_SDN_DLY_ENB, 0);
pmic_set_register_value(PMIC_TMA_KEY, 0);
}
static unsigned int pmic_scp_set_regulator(struct mtk_regulator mt_reg,
enum PMU_FLAGS_LIST vosel_reg, unsigned int voltage, bool is_sleep_vol)
{
unsigned int min_uV = mt_reg.desc.min_uV;
unsigned int uV_step = mt_reg.desc.uV_step;
unsigned int n_voltages = mt_reg.desc.n_voltages;
unsigned short set_step = 0;
unsigned short get_step = 0;
set_step = (voltage - min_uV) / uV_step;
if (voltage < min_uV || set_step >= n_voltages) {
pr_notice("[%s] SSHUB_%s Set Wrong voltage=%duV is unsupportable range %d-%duV\n"
, __func__
, mt_reg.desc.name
, voltage
, min_uV
, (n_voltages * uV_step + min_uV));
return voltage;
}
pr_info("SSHUB_%s Expected %svolt step = %d\n",
mt_reg.desc.name, is_sleep_vol?"sleep ":"", set_step);
pmic_set_register_value(vosel_reg, set_step);
udelay(220);
get_step = pmic_get_register_value(vosel_reg);
if (get_step != set_step) {
pr_notice("[%s] Set SSHUB_%s Voltage fail with step = %d, read voltage = %duV\n"
, __func__, mt_reg.desc.name, set_step
, (get_step * uV_step + min_uV));
return voltage;
}
pr_info("Set SSHUB_%s %sVoltage to %duV pass\n",
mt_reg.desc.name, is_sleep_vol?"sleep ":"", voltage);
return 0;
}
/*
* SCP set VCORE voltage, return 0 if success,
* otherwise return set voltage(uV)
*/
unsigned int pmic_scp_set_vcore(unsigned int voltage)
{
return pmic_scp_set_regulator(
mt_bucks[MT6358_POWER_BUCK_VCORE],
PMIC_RG_BUCK_VCORE_SSHUB_VOSEL, voltage, false);
}
unsigned int pmic_scp_set_vcore_sleep(unsigned int voltage)
{
return pmic_scp_set_regulator(
mt_bucks[MT6358_POWER_BUCK_VCORE],
PMIC_RG_BUCK_VCORE_SSHUB_VOSEL_SLEEP, voltage, true);
}
/*
* SCP set VSRAM_CORE(VSRAM_OTHERS) voltage, return 0 if success,
* otherwise return set voltage(uV)
*/
unsigned int pmic_scp_set_vsram_vcore(unsigned int voltage)
{
return pmic_scp_set_regulator(
mt_ldos[MT6358_POWER_LDO_VSRAM_OTHERS],
PMIC_RG_LDO_VSRAM_OTHERS_SSHUB_VOSEL, voltage, false);
}
unsigned int pmic_scp_set_vsram_vcore_sleep(unsigned int voltage)
{
return pmic_scp_set_regulator(
mt_ldos[MT6358_POWER_LDO_VSRAM_OTHERS],
PMIC_RG_LDO_VSRAM_OTHERS_SSHUB_VOSEL_SLEEP, voltage, true);
}
/*****************************************************************************
* PMIC charger detection
******************************************************************************/
unsigned int upmu_get_rgs_chrdet(void)
{
unsigned int val = 0;
val = pmic_get_register_value(PMIC_RGS_CHRDET);
PMICLOG("[%s] CHRDET status = %d\n", __func__, val);
return val;
}
int is_ext_vbat_boost_exist(void)
{
return 0;
}
int is_ext_swchr_exist(void)
{
return 0;
}
/*****************************************************************************
* Enternal BUCK status
******************************************************************************/
int is_ext_buck_gpio_exist(void)
{
return pmic_get_register_value(PMIC_RG_STRUP_EXT_PMIC_EN);
}
MODULE_AUTHOR("Jeter Chen");
MODULE_DESCRIPTION("MT PMIC Device Driver");
MODULE_LICENSE("GPL");
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,784 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/mutex.h>
#include <linux/device.h>
#include <linux/pm_wakeup.h>
#include <linux/delay.h>
#include <linux/ratelimit.h>
#include <linux/timekeeping.h>
#include <linux/math64.h>
#include <linux/of_address.h>
#include <linux/iio/consumer.h>
#include <linux/iio/adc/mt635x-auxadc-internal.h>
#include "include/pmic.h"
#include "include/pmic_auxadc.h"
#ifdef CONFIG_MTK_AEE_FEATURE
#include <mt-plat/aee.h>
#endif
#include <mt-plat/upmu_common.h>
#include <mt-plat/mtk_auxadc_intf.h>
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
#include <mach/mtk_pmic_wrap.h>
#endif
#ifndef CONFIG_MTK_GAUGE_VERSION
#define CONFIG_MTK_GAUGE_VERSION 0
#endif
#if (CONFIG_MTK_GAUGE_VERSION == 30)
#include <mt-plat/v1/mtk_battery.h>
#include <mtk_battery_internal.h>
#endif
static struct device *pmic_auxadc_dev;
static int auxadc_bat_temp_cali(int bat_temp, int precision_factor);
static bool mts_enable = true;
/*********************************
* PMIC AUXADC Exported API
*********************************/
static DEFINE_MUTEX(auxadc_ch3_mutex);
static unsigned int g_pmic_pad_vbif28_vol;
unsigned int pmic_get_vbif28_volt(void)
{
return g_pmic_pad_vbif28_vol;
}
bool is_isense_supported(void)
{
/* PMIC MT6358 does not support ISENSE */
return false;
}
/* BAT_TEMP background control */
void wk_auxadc_bgd_ctrl(unsigned char en)
{
pmic_set_hk_reg_value(PMIC_AUXADC_BAT_TEMP_IRQ_EN_MAX, en);
pmic_set_hk_reg_value(PMIC_AUXADC_BAT_TEMP_EN_MAX, en);
pmic_set_hk_reg_value(PMIC_AUXADC_BAT_TEMP_IRQ_EN_MIN, en);
pmic_set_hk_reg_value(PMIC_AUXADC_BAT_TEMP_EN_MIN, en);
}
void pmic_auxadc_suspend(void)
{
#ifndef IPIMB
wk_auxadc_bgd_ctrl(0);
#endif
/* special call to restore bat_temp_prev when enter suspend */
auxadc_bat_temp_cali(-1, -1);
}
void pmic_auxadc_resume(void)
{
#ifndef IPIMB
wk_auxadc_bgd_ctrl(1);
#endif
}
void lockadcch3(void)
{
mutex_lock(&auxadc_ch3_mutex);
}
void unlockadcch3(void)
{
mutex_unlock(&auxadc_ch3_mutex);
}
void wk_auxadc_reset(void)
{
pmic_set_register_value(PMIC_RG_AUXADC_RST, 1);
pmic_set_register_value(PMIC_RG_AUXADC_RST, 0);
pmic_set_register_value(PMIC_BANK_AUXADC_SWRST, 1);
pmic_set_register_value(PMIC_BANK_AUXADC_SWRST, 0);
/* avoid GPS can't receive AUXADC ready after reset, request again */
pmic_set_register_value(PMIC_AUXADC_RQST_CH7, 1);
pmic_set_register_value(PMIC_AUXADC_RQST_DCXO_BY_GPS, 1);
pr_notice("reset AUXADC done\n");
}
/*********************************
* PMIC AUXADC Calibration
*********************************/
static unsigned int g_DEGC;
static unsigned int g_O_VTS;
static unsigned int g_O_SLOPE_SIGN;
static unsigned int g_O_SLOPE;
static unsigned int g_CALI_FROM_EFUSE_EN;
static unsigned int g_GAIN_AUX;
static unsigned int g_SIGN_AUX;
static unsigned int g_GAIN_BGRL;
static unsigned int g_SIGN_BGRL;
static unsigned int g_TEMP_L_CALI;
static unsigned int g_GAIN_BGRH;
static unsigned int g_SIGN_BGRH;
static unsigned int g_TEMP_H_CALI;
static unsigned int g_AUXCALI_EN;
static unsigned int g_BGRCALI_EN;
static int wk_aux_cali(int T_curr, int vbat_out)
{
signed long long coeff_gain_aux = 0;
signed long long vbat_cali = 0;
coeff_gain_aux = (317220 + 11960 * (signed long long)g_GAIN_AUX);
vbat_cali = div_s64((vbat_out * (T_curr - 250) * coeff_gain_aux), 255);
vbat_cali = div_s64(vbat_cali, 1000000000);
if (g_SIGN_AUX == 0)
vbat_out += vbat_cali;
else
vbat_out -= vbat_cali;
return vbat_out;
}
static int wk_bgr_cali(int T_curr, int vbat_out)
{
signed long long coeff_gain_bgr = 0;
signed int T_L = -100 + g_TEMP_L_CALI * 25;
signed int T_H = 600 + g_TEMP_H_CALI * 25;
if (T_curr < T_L) {
coeff_gain_bgr = (127 + 8 * (signed long long)g_GAIN_BGRL);
if (g_SIGN_BGRL == 0)
vbat_out += div_s64((vbat_out * (T_curr - T_L) *
coeff_gain_bgr), 127000000);
else
vbat_out -= div_s64((vbat_out * (T_curr - T_L) *
coeff_gain_bgr), 127000000);
} else if (T_curr > T_H) {
coeff_gain_bgr = (127 + 8 * (signed long long)g_GAIN_BGRH);
if (g_SIGN_BGRH == 0)
vbat_out -= div_s64((vbat_out * (T_curr - T_H) *
coeff_gain_bgr), 127000000);
else
vbat_out += div_s64((vbat_out * (T_curr - T_H) *
coeff_gain_bgr), 127000000);
}
return vbat_out;
}
/* vbat_out unit is 0.1mV, vthr unit is mV */
int wk_vbat_cali(int vbat_out, int precision_factor)
{
int mV_diff = 0;
int T_curr = 0; /* unit: 0.1 degrees C*/
int vbat_out_old;
int vthr;
vthr = auxadc_priv_read_channel(pmic_auxadc_dev, AUXADC_CHIP_TEMP);
mV_diff = vthr - g_O_VTS * 1800 / 4096;
if (g_O_SLOPE_SIGN == 0)
T_curr = mV_diff * 10000 / (signed int)(1681 + g_O_SLOPE * 10);
else
T_curr = mV_diff * 10000 / (signed int)(1681 - g_O_SLOPE * 10);
T_curr = (g_DEGC * 10 / 2) - T_curr;
/*pr_info("%d\n", T_curr);*/
if (precision_factor > 1)
vbat_out *= precision_factor;
vbat_out_old = vbat_out;
if (g_AUXCALI_EN == 1) {
vbat_out = wk_aux_cali(T_curr, vbat_out);
/*pr_info("vbat_out_auxcali = %d\n", vbat_out);*/
}
if (g_BGRCALI_EN == 1) {
vbat_out = wk_bgr_cali(T_curr, vbat_out);
/*pr_info("vbat_out_bgrcali = %d\n", vbat_out);*/
}
if (abs(vbat_out - vbat_out_old) > 1000) {
pr_notice("vbat_out_old=%d, vthr=%d, T_curr=%d, vbat_out=%d\n",
vbat_out_old, vthr, T_curr, vbat_out);
pr_notice("%d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
g_DEGC, g_O_VTS, g_O_SLOPE_SIGN, g_O_SLOPE,
g_SIGN_AUX, g_SIGN_BGRL, g_SIGN_BGRH,
g_AUXCALI_EN, g_BGRCALI_EN,
g_GAIN_AUX, g_GAIN_BGRL, g_GAIN_BGRH,
g_TEMP_L_CALI, g_TEMP_H_CALI);
#ifdef CONFIG_MTK_AEE_FEATURE
aee_kernel_warning("PMIC AUXADC CALI", "VBAT CALI");
#endif
} else
pr_info("vbat_out_old=%d, vthr=%d, T_curr=%d, vbat_out=%d\n",
vbat_out_old, vthr, T_curr, vbat_out);
if (precision_factor > 1)
vbat_out = DIV_ROUND_CLOSEST(vbat_out, precision_factor);
return vbat_out;
}
static void auxadc_cali_init(struct device_node *np)
{
unsigned int efuse = 0;
unsigned int efuse_offset;
if (of_property_read_u32(np, "cali-efuse-offset", &efuse_offset))
efuse_offset = 0;
if (pmic_get_register_value(PMIC_AUXADC_EFUSE_ADC_CALI_EN) == 1) {
g_DEGC = pmic_get_register_value(PMIC_AUXADC_EFUSE_DEGC_CALI);
if (g_DEGC < 38 || g_DEGC > 60)
g_DEGC = 53;
g_O_VTS = pmic_get_register_value(PMIC_AUXADC_EFUSE_O_VTS);
g_O_SLOPE_SIGN =
pmic_get_register_value(PMIC_AUXADC_EFUSE_O_SLOPE_SIGN);
g_O_SLOPE = pmic_get_register_value(PMIC_AUXADC_EFUSE_O_SLOPE);
} else {
g_DEGC = 50;
g_O_VTS = 1600;
}
efuse = pmic_Read_Efuse_HPOffset(39 + efuse_offset);
g_CALI_FROM_EFUSE_EN = (efuse >> 2) & 0x1;
if (g_CALI_FROM_EFUSE_EN == 1) {
g_SIGN_AUX = (efuse >> 3) & 0x1;
g_AUXCALI_EN = (efuse >> 6) & 0x1;
g_GAIN_AUX = (efuse >> 8) & 0xFF;
} else {
g_SIGN_AUX = 0;
g_AUXCALI_EN = 1;
g_GAIN_AUX = 106;
}
g_SIGN_BGRL = (efuse >> 4) & 0x1;
g_SIGN_BGRH = (efuse >> 5) & 0x1;
g_BGRCALI_EN = (efuse >> 7) & 0x1;
efuse = pmic_Read_Efuse_HPOffset(40 + efuse_offset);
g_GAIN_BGRL = (efuse >> 9) & 0x7F;
efuse = pmic_Read_Efuse_HPOffset(41 + efuse_offset);
g_GAIN_BGRH = (efuse >> 9) & 0x7F;
efuse = pmic_Read_Efuse_HPOffset(42 + efuse_offset);
g_TEMP_L_CALI = (efuse >> 10) & 0x7;
g_TEMP_H_CALI = (efuse >> 13) & 0x7;
pr_info("%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d\n",
g_DEGC, g_O_VTS, g_O_SLOPE_SIGN, g_O_SLOPE,
g_CALI_FROM_EFUSE_EN, g_SIGN_AUX, g_SIGN_BGRL, g_SIGN_BGRH,
g_AUXCALI_EN, g_BGRCALI_EN,
g_GAIN_AUX, g_GAIN_BGRL, g_GAIN_BGRH,
g_TEMP_L_CALI, g_TEMP_H_CALI);
}
/*********************************
* PMIC AUXADC debug register dump
*********************************/
#define DBG_REG_SIZE 384
#define BAT_TEMP_AEE_DBG 0
struct pmic_adc_dbg_st {
int ktime_sec;
unsigned short reg[DBG_REG_SIZE];
};
static unsigned int adc_dbg_addr[DBG_REG_SIZE];
static void wk_auxadc_dbg_dump(void)
{
unsigned char reg_log[861] = "", reg_str[21] = "";
unsigned short i, j;
static unsigned char dbg_stamp;
static struct pmic_adc_dbg_st pmic_adc_dbg[4];
for (i = 0; adc_dbg_addr[i] != 0; i++)
pmic_adc_dbg[dbg_stamp].reg[i] =
upmu_get_reg_value(adc_dbg_addr[i]);
pmic_adc_dbg[dbg_stamp].ktime_sec = (int)get_monotonic_coarse().tv_sec;
dbg_stamp++;
if (dbg_stamp >= 4)
dbg_stamp = 0;
for (i = 0; i < 4; i++) {
if (pmic_adc_dbg[dbg_stamp].ktime_sec == 0) {
dbg_stamp++;
if (dbg_stamp >= 4)
dbg_stamp = 0;
continue;
}
for (j = 0; adc_dbg_addr[j] != 0; j++) {
if (j != 0 && j % 43 == 0) {
pr_notice("%d %s\n",
pmic_adc_dbg[dbg_stamp].ktime_sec,
reg_log);
strncpy(reg_log, "", 860);
}
snprintf(reg_str, 20, "Reg[0x%x]=0x%x, ",
adc_dbg_addr[j],
pmic_adc_dbg[dbg_stamp].reg[j]);
strncat(reg_log, reg_str, 860);
}
pr_notice("%d %s\n",
pmic_adc_dbg[dbg_stamp].ktime_sec,
reg_log);
strncpy(reg_log, "", 860);
dbg_stamp++;
if (dbg_stamp >= 4)
dbg_stamp = 0;
}
}
/* BAT_TEMP filter Maxima and minima then average */
static int bat_temp_filter(int *arr, unsigned short size)
{
unsigned char i, i_max, i_min = 0;
int arr_max = 0, arr_min = arr[0];
int sum = 0;
for (i = 0; i < size; i++) {
sum += arr[i];
if (arr[i] > arr_max) {
arr_max = arr[i];
i_max = i;
} else if (arr[i] < arr_min) {
arr_min = arr[i];
i_min = i;
}
}
sum = sum - arr_max - arr_min;
return (sum/(size - 2));
}
static int wk_bat_temp_dbg(int bat_temp_prev, int bat_temp)
{
int vbif28, bat_temp_new = bat_temp;
int arr_bat_temp[5];
unsigned short i;
vbif28 = auxadc_priv_read_channel(pmic_auxadc_dev, AUXADC_VBIF);
pr_notice("BAT_TEMP_PREV:%d,BAT_TEMP:%d,VBIF28:%d\n",
bat_temp_prev, bat_temp, vbif28);
if (bat_temp < 200 || abs(bat_temp_prev - bat_temp) > 100) {
wk_auxadc_dbg_dump();
for (i = 0; i < 5; i++) {
arr_bat_temp[i] =
auxadc_priv_read_channel(pmic_auxadc_dev,
AUXADC_BAT_TEMP);
}
bat_temp_new = bat_temp_filter(arr_bat_temp, 5);
pr_notice("%d,%d,%d,%d,%d, BAT_TEMP_NEW:%d\n",
arr_bat_temp[0], arr_bat_temp[1], arr_bat_temp[2],
arr_bat_temp[3], arr_bat_temp[4], bat_temp_new);
}
return bat_temp_new;
}
static void wk_auxadc_dbg_init(void)
{
unsigned short i;
unsigned int addr = 0x1000;
/* All of AUXADC */
for (i = 0; addr <= 0x1266; i++) {
adc_dbg_addr[i] = addr;
addr += 0x2;
}
/* Clock related */
adc_dbg_addr[i++] = MT6358_HK_TOP_CLK_CON0;
adc_dbg_addr[i++] = MT6358_HK_TOP_CLK_CON1;
/* RST related */
adc_dbg_addr[i++] = MT6358_HK_TOP_RST_CON0;
/* Others */
adc_dbg_addr[i++] = MT6358_BATON_ANA_CON0;
adc_dbg_addr[i++] = MT6358_PCHR_VREF_ELR_0;
adc_dbg_addr[i++] = MT6358_PCHR_VREF_ELR_1;
}
/*********************************
* PMIC AUXADC MDRT debug(MTS=Modem Temp Share)
*********************************/
/* global variable */
static unsigned int mdrt_adc;
static struct wakeup_source* mdrt_wakelock;
static struct mutex mdrt_mutex;
static struct task_struct *mdrt_thread_handle;
/* wake up the thread to polling MDRT data in ms period */
void wake_up_mdrt_thread(void)
{
HKLOG("[%s]\n", __func__);
if (mdrt_thread_handle != NULL) {
__pm_stay_awake(mdrt_wakelock);
wake_up_process(mdrt_thread_handle);
} else
pr_notice(PMICTAG "[%s] mdrt_thread_handle not ready\n",
__func__);
}
/* dump MDRT related register */
static void mdrt_reg_dump(void)
{
#ifdef CONFIG_MTK_PMIC_WRAP_HAL
pwrap_dump_all_register();
#endif
pr_notice("AUXADC_ADC15 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_ADC15));
pr_notice("AUXADC_ADC16 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_ADC16));
pr_notice("AUXADC_ADC17 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_ADC17));
pr_notice("AUXADC_ADC31 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_ADC31));
pr_notice("AUXADC_MDRT_0 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_MDRT_0));
pr_notice("AUXADC_MDRT_1 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_MDRT_1));
pr_notice("AUXADC_MDRT_2 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_MDRT_2));
pr_notice("AUXADC_MDRT_3 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_MDRT_3));
pr_notice("AUXADC_MDRT_4 = 0x%x\n",
upmu_get_reg_value(MT6358_AUXADC_MDRT_4));
/*--AUXADC CLK--*/
pr_notice("RG_AUXADC_CK_PDN = 0x%x, RG_AUXADC_CK_PDN_HWEN = 0x%x\n",
pmic_get_register_value(PMIC_RG_AUXADC_CK_PDN),
pmic_get_register_value(PMIC_RG_AUXADC_CK_PDN_HWEN));
}
/* Check MDRT_ADC data has changed or not */
void mdrt_monitor(void)
{
static unsigned int mdrt_cnt;
static int mdrt_timestamp;
int mdrt_timestamp_cur = 0;
unsigned int temp_mdrt_adc = 0;
if (mdrt_adc == 0)
return;
mdrt_timestamp_cur = (int)get_monotonic_coarse().tv_sec;
if ((mdrt_timestamp_cur - mdrt_timestamp) < 5)
return;
mdrt_timestamp = mdrt_timestamp_cur;
temp_mdrt_adc = pmic_get_register_value(PMIC_AUXADC_ADC_OUT_MDRT);
pr_notice("[MDRT_ADC] OLD = 0x%x, NOW = 0x%x, CNT = %d\n",
mdrt_adc, temp_mdrt_adc, mdrt_cnt);
if (temp_mdrt_adc != mdrt_adc) {
mdrt_cnt = 0;
mdrt_adc = temp_mdrt_adc;
return;
}
mdrt_cnt++;
if (mdrt_cnt >= 7 && mdrt_cnt < 9) {
/* trigger CH7 in AP/MD/GPS and just delay 1ms to get data */
pmic_set_hk_reg_value(PMIC_AUXADC_RQST_CH7, 1);
pmic_set_hk_reg_value(PMIC_AUXADC_RQST_CH7_BY_MD, 1);
pmic_set_hk_reg_value(PMIC_AUXADC_RQST_CH7_BY_GPS, 1);
mdelay(1);
mdrt_reg_dump();
}
if (mdrt_cnt > 15) {
mdrt_reg_dump();
mdrt_cnt = 0;
wake_up_mdrt_thread();
}
mdrt_adc = temp_mdrt_adc;
}
static int mdrt_polling_rdy(unsigned int *trig_prd,
unsigned int *rdy_time, unsigned int *mdrt_adc)
{
while (pmic_get_register_value(PMIC_AUXADC_ADC_RDY_MDRT) == 1) {
if (*trig_prd > 100) {
pr_notice("[MDRT_ADC] no trigger\n");
return -1;
}
(*trig_prd)++;
mdelay(1);
}
while (pmic_get_register_value(PMIC_AUXADC_ADC_RDY_MDRT) == 0) {
if (*rdy_time > 100) {
pr_notice("[MDRT_ADC] no ready\n");
return -2;
}
(*rdy_time)++;
mdelay(1);
}
*mdrt_adc = pmic_get_register_value(PMIC_AUXADC_ADC_OUT_MDRT);
return 0;
}
static int mdrt_kthread(void *x)
{
unsigned int polling_cnt;
unsigned int trig_prd;
unsigned int rdy_time;
unsigned int temp_mdrt_adc;
/* Run on a process content */
while (1) {
mutex_lock(&mdrt_mutex);
polling_cnt = 0;
temp_mdrt_adc = pmic_get_register_value(
PMIC_AUXADC_ADC_OUT_MDRT);
while (mdrt_adc == temp_mdrt_adc) {
trig_prd = 0;
rdy_time = 0;
mdrt_polling_rdy(&trig_prd,
&rdy_time, &temp_mdrt_adc);
if (polling_cnt % 20 == 0) {
pr_notice("[MDRT_ADC] trig_prd=%d, rdy_time=%d, MDRT_OUT=%d\n"
, trig_prd, rdy_time,
temp_mdrt_adc);
}
if (polling_cnt == 156) { /* 156 * 32ms ~= 5s*/
pr_notice("[MDRT_ADC] (%d) reset AUXADC\n",
polling_cnt);
wk_auxadc_reset();
}
if (polling_cnt >= 312) { /* 312 * 32ms ~= 10s*/
mdrt_reg_dump();
#ifdef CONFIG_MTK_AEE_FEATURE
aee_kernel_warning("PMIC AUXADC:MDRT", "MDRT");
#endif
break;
}
polling_cnt++;
}
mutex_unlock(&mdrt_mutex);
__pm_relax(mdrt_wakelock);
set_current_state(TASK_INTERRUPTIBLE);
schedule();
/* Fix Cove.Scan, should not happened */
if (polling_cnt >= 0x1000)
break;
}
return 0;
}
static void mdrt_monitor_init(void)
{
//wakeup_source_init(&mdrt_wakelock, "MDRT Monitor wakelock");
mdrt_wakelock = wakeup_source_register(NULL, "MDRT Monitor wakelock");
mutex_init(&mdrt_mutex);
mdrt_adc = pmic_get_register_value(PMIC_AUXADC_ADC_OUT_MDRT);
mdrt_thread_handle = kthread_run(mdrt_kthread, NULL, "mdrt_thread");
if (IS_ERR(mdrt_thread_handle)) {
mdrt_thread_handle = NULL;
pr_notice(PMICTAG "[%s] creation fails\n", __func__);
} else
HKLOG("[%s] creation Done\n", __func__);
}
/*********************************
* Legacy API for getting PMIC AUXADC value
*********************************/
struct legacy_auxadc_t {
const char *channel_name;
struct iio_channel *chan;
};
#define LEGACY_AUXADC_GEN(_name) \
{ \
.channel_name = "AUXADC_"#_name,\
}
static struct legacy_auxadc_t legacy_auxadc[] = {
LEGACY_AUXADC_GEN(BATADC),
LEGACY_AUXADC_GEN(VCDT),
LEGACY_AUXADC_GEN(BAT_TEMP),
LEGACY_AUXADC_GEN(VBIF),
LEGACY_AUXADC_GEN(CHIP_TEMP),
LEGACY_AUXADC_GEN(DCXO_TEMP),
LEGACY_AUXADC_GEN(ACCDET),
LEGACY_AUXADC_GEN(TSX_TEMP),
LEGACY_AUXADC_GEN(HPOFS_CAL),
LEGACY_AUXADC_GEN(VCORE_TEMP),
LEGACY_AUXADC_GEN(VPROC_TEMP),
LEGACY_AUXADC_GEN(VGPU_TEMP),
LEGACY_AUXADC_GEN(VDCXO),
};
static void legacy_auxadc_init(struct device *dev)
{
int i = 0;
for (i = AUXADC_LIST_START; i <= AUXADC_LIST_END; i++) {
legacy_auxadc[i].chan =
devm_iio_channel_get(dev,
legacy_auxadc[i].channel_name);
if (IS_ERR(legacy_auxadc[i].chan))
pr_notice("%s get fail with list %d, dev_name:%s\n",
legacy_auxadc[i].channel_name, i,
dev_name(dev));
}
}
int pmic_get_auxadc_value(int list)
{
int bat_cur = 0, is_charging = 0;
int value = 0, ret = 0;
if (list < AUXADC_LIST_START || list > AUXADC_LIST_END) {
pr_notice("[%s] Invalid channel list(%d)\n", __func__, list);
return -EINVAL;
}
if (!(legacy_auxadc[list].chan) || IS_ERR(legacy_auxadc[list].chan)) {
pr_notice("[%s] iio channel consumer error(%s)\n",
__func__, legacy_auxadc[list].channel_name);
return PTR_ERR(legacy_auxadc[list].chan);
}
if (list == AUXADC_LIST_BATTEMP) {
#if (CONFIG_MTK_GAUGE_VERSION == 30)
is_charging = gauge_get_current(&bat_cur);
#endif
if (is_charging == 0)
bat_cur = 0 - bat_cur;
pr_notice("[CH3_DBG] bat_cur = %d\n", bat_cur);
}
if (list == AUXADC_LIST_HPOFS_CAL) {
ret = iio_read_channel_raw(
legacy_auxadc[list].chan, &value);
} else {
ret = iio_read_channel_processed(
legacy_auxadc[list].chan, &value);
}
if (ret < 0)
return ret;
return value;
}
/*********************************
* PMIC AUXADC chip setting for IIO ADC driver
*********************************/
static void auxadc_batadc_convert(unsigned char convert)
{
/* when user wants to get BATADC, starting monitor MDRT for debugging*/
if (convert == 0)
mdrt_monitor();
}
static void auxadc_bat_temp_convert(unsigned char convert)
{
if (convert == 1)
mutex_lock(&auxadc_ch3_mutex);
else if (convert == 0)
mutex_unlock(&auxadc_ch3_mutex);
}
static void auxadc_vdcxo_convert(unsigned char convert)
{
/* Turn on CH6 measured switch, set AUXADC_ANA_CON0[7] = 1’b1 */
if (convert == 1)
pmic_config_interface(MT6358_AUXADC_ANA_CON0, 0x1, 0x1, 7);
else if (convert == 0)
pmic_config_interface(MT6358_AUXADC_ANA_CON0, 0x0, 0x1, 7);
}
static void auxadc_vbif_convert(unsigned char convert)
{
if (convert == 1)
pmic_set_hk_reg_value(PMIC_RG_BATON_TDET_EN, 0);
else if (convert == 0)
pmic_set_hk_reg_value(PMIC_RG_BATON_TDET_EN, 1);
}
static int auxadc_bat_temp_cali(int bat_temp, int precision_factor)
{
static int bat_temp_prev;
static unsigned int dbg_count;
static unsigned int aee_count;
if (bat_temp == -1 && precision_factor == -1) {
bat_temp_prev = 0;
return 0;
}
if (bat_temp_prev == 0)
goto out;
dbg_count++;
if (bat_temp < 200 || abs(bat_temp_prev - bat_temp) > 100) {
/* dump debug log when BAT_TEMP being abnormal */
bat_temp = wk_bat_temp_dbg(bat_temp_prev, bat_temp);
#if BAT_TEMP_AEE_DBG
#ifdef CONFIG_MTK_AEE_FEATURE
if (aee_count < 2)
aee_kernel_warning("PMIC AUXADC:BAT_TEMP", "BAT_TEMP");
#endif
pr_notice("PMIC AUXADC BAT_TEMP aee_count=%d\n", aee_count);
#endif
aee_count++;
} else if (dbg_count % 50 == 0) {
/* dump debug log in normal case */
wk_bat_temp_dbg(bat_temp_prev, bat_temp);
}
out:
bat_temp_prev = bat_temp;
return bat_temp;
}
static void parsing_cust_setting(void)
{
struct device_node *np;
unsigned int disable_modem;
/* check customer setting */
np = of_find_compatible_node(NULL, NULL,
"mediatek,mt-pmic-custom-setting");
if (!np) {
HKLOG("[%s]Failed to find device-tree node\n", __func__);
return;
}
if (!of_property_read_u32(np, "disable-modem", &disable_modem)) {
if (disable_modem)
mts_enable = false;
}
of_node_put(np);
}
int pmic_auxadc_chip_init(struct device *dev)
{
int ret = 0;
struct iio_channel *chan_vbif;
HKLOG("%s\n", __func__);
pmic_auxadc_dev = dev;
auxadc_set_convert_fn(AUXADC_BATADC, auxadc_batadc_convert);
auxadc_set_convert_fn(AUXADC_BAT_TEMP, auxadc_bat_temp_convert);
auxadc_set_convert_fn(AUXADC_VDCXO, auxadc_vdcxo_convert);
auxadc_set_convert_fn(AUXADC_VBIF, auxadc_vbif_convert);
auxadc_set_cali_fn(AUXADC_BATADC, wk_vbat_cali);
auxadc_set_cali_fn(AUXADC_BAT_TEMP, auxadc_bat_temp_cali);
#if 1 /*TBD*/
legacy_auxadc_init(dev);
#endif
auxadc_cali_init(dev->of_node);
wk_auxadc_dbg_init();
parsing_cust_setting();
if (mts_enable)
mdrt_monitor_init();
/* update VBIF28 by AUXADC */
chan_vbif = iio_channel_get(dev, "AUXADC_VBIF");
if (IS_ERR(chan_vbif)) {
pr_notice("[%s] iio channel consumer error(AUXADC_VBIF)\n",
__func__);
} else {
ret = iio_read_channel_processed(chan_vbif,
&g_pmic_pad_vbif28_vol);
iio_channel_release(chan_vbif);
}
pr_info("****[%s] VBIF28 = %d, MDRT_ADC = 0x%x\n",
__func__, pmic_get_vbif28_volt(), mdrt_adc);
return ret;
}
Loaded 100 of 80519 files, more files were not shown because too many files have changed in this diff. Show more