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

@@ -0,0 +1,219 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: owen.chen <owen.chen@mediatek.com>
*/
/*
* @file mtk-clk-buf-ctl.c
* @brief Driver for clock buffer control
*
*/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <mtk-clkbuf-bridge.h>
#include <mtk_clkbuf_ctl.h>
#include <mtk_clkbuf_common.h>
DEFINE_MUTEX(clk_buf_ctrl_lock);
struct clk_buf {
const char *name;
const struct clk_buf_op *ops;
struct clk_hw *hw;
struct device *dev;
};
static struct clk_buf *clk_buf_core;
static bool _clk_buf_check(void)
{
if (!clk_buf_core || !clk_buf_core->ops) {
pr_err("Not register operand yet\n");
return false;
}
if (clk_buf_core->ops->get_bringup_sta())
return false;
return clk_buf_core->ops->get_clkbuf_init_sta();
}
int clk_buf_set_xo_ctrl(enum clk_buf_id id, bool onoff)
{
if (_clk_buf_check())
return clk_buf_core->ops->set_xo_sta(id, onoff);
return CLK_BUF_NOT_SUPPORT;
}
/* for spm driver use */
int is_clk_buf_under_flightmode(void)
{
if (_clk_buf_check())
return clk_buf_core->ops->get_flight_mode();
return CLK_BUF_NOT_SUPPORT;
}
/* for ccci driver to notify this */
int clk_buf_set_flight_mode(bool on)
{
if (_clk_buf_check()) {
clk_buf_core->ops->set_flight_mode(on);
return CLK_BUF_OK;
}
return CLK_BUF_NOT_SUPPORT;
}
int clk_buf_set_bblpm(bool on)
{
int ret = 0;
if (_clk_buf_check()) {
ret = clk_buf_core->ops->set_bblpm_sta(on);
return ret;
}
return CLK_BUF_NOT_SUPPORT;
}
void clk_buf_dump_log(void)
{
if (_clk_buf_check())
clk_buf_core->ops->get_main_log();
}
u8 clk_buf_get_xo_ctrl(enum xo_id id)
{
if (_clk_buf_check())
return clk_buf_core->ops->get_xo_sta(id);
return CLK_BUF_NOT_SUPPORT;
}
int clk_buf_get_bblpm_enter_cond(u32 *bblpm_cond)
{
if (_clk_buf_check()) {
clk_buf_core->ops->get_bblpm_enter_cond(bblpm_cond);
return CLK_BUF_OK;
}
return CLK_BUF_NOT_SUPPORT;
}
int mtk_register_clk_buf(struct device *dev, struct clk_buf_op *ops)
{
struct clk_buf_bridge pbridge;
int ret = 0;
clk_buf_core = kzalloc(sizeof(struct clk_buf), GFP_KERNEL);
if (!clk_buf_core) {
ret = -ENOMEM;
goto fail_out;
}
if (WARN_ON(!ops)) {
ret = -EINVAL;
goto fail_ops;
}
clk_buf_core->ops = ops;
clk_buf_core->dev = dev;
clk_buf_core->name = dev->driver->name;
pbridge.get_xo_ctrl_cb = clk_buf_get_xo_ctrl;
pbridge.get_bblpm_enter_cond_cb = clk_buf_get_bblpm_enter_cond;
pbridge.set_bblpm_cb = clk_buf_set_bblpm;
pbridge.set_flight_mode_cb = clk_buf_set_flight_mode;
pbridge.set_xo_ctrl_cb = clk_buf_set_xo_ctrl;
pbridge.dump_log_cb = clk_buf_dump_log;
clk_buf_export_platform_bridge_register(&pbridge);
return ret;
fail_ops:
kfree(clk_buf_core);
fail_out:
return ret;
}
static int mtk_clkbuf_probe(struct platform_device *pdev)
{
int (*clkbuf_probe)(struct platform_device *pdev);
int ret = 0;
clkbuf_probe = of_device_get_match_data(&pdev->dev);
if (!clkbuf_probe)
return -EINVAL;
ret = clkbuf_probe(pdev);
if (ret)
dev_err(&pdev->dev,
"could not register clock provider: %s: %d\n",
pdev->name, ret);
if (!clk_buf_core || !clk_buf_core->ops) {
pr_err("Not register operand yet\n");
return -ENODEV;
}
if (clk_buf_core->ops->get_bringup_sta())
return 0;
ret = clk_buf_core->ops->dts_init(pdev);
if (ret) {
pr_err("%s: failed due to chip DTS failed\n", __func__);
return ret;
}
ret = clk_buf_core->ops->fs_init();
if (ret) {
pr_err("%s: failed due to file operation failed\n", __func__);
return ret;
}
if (clk_buf_core->ops->get_clkbuf_init_sta())
return -EALREADY;
clk_buf_core->ops->xo_init();
clk_buf_core->ops->bblpm_init();
clk_buf_core->ops->set_clkbuf_init_sta(true);
return ret;
}
static const struct platform_device_id mtk_clkbuf_ids[] = {
{"mtk-clock-buffer", 0},
{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(platform, mtk_clkbuf_ids);
static const struct of_device_id mtk_clkbuf_of_match[] = {
{
.compatible = "mediatek,clock_buffer",
.data = clk_buf_hw_probe,
},
{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, mtk_clkbuf_of_match);
static struct platform_driver mtk_clkbuf_driver = {
.driver = {
.name = "mtk-clock-buffer",
.of_match_table = of_match_ptr(mtk_clkbuf_of_match),
},
.probe = mtk_clkbuf_probe,
.id_table = mtk_clkbuf_ids,
};
module_platform_driver(mtk_clkbuf_driver);
MODULE_AUTHOR("Owen Chen <owen.chen@mediatek.com>");
MODULE_DESCRIPTION("SOC Driver for MediaTek PMIC Clock Buffer");
MODULE_LICENSE("GPL v2");
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,726 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
* Author: owen.chen <owen.chen@mediatek.com>
*/
/*
* @file mtk-clk-buf-hw.c
* @brief Driver for clock buffer control of each platform
*
*/
#include <linux/kobject.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/regmap.h>
#include <linux/platform_device.h>
#include <linux/mfd/syscon.h>
#include <linux/mfd/mt6397/core.h>
#include <linux/list.h>
#include "mtk_clkbuf_pmic.h"
#include <mtk-clkbuf-bridge.h>
struct list_head dts_head;
static const char *PMIC_NAME[PMIC_NUM] = {
"mediatek,mt6357",
"mediatek,mt6359",
};
static const char *pmic_clkbuf_prop[PMIC_HW_DTS_NUM] = {
[PMIC_DRV_CURR] = "pmic-drvcurr",
[PMIC_HW_BBLPM] = "pmic-bblplm-hw",
[PMIC_HW_BBLPM_SEL] = "pmic-bblpm-sel",
[PMIC_LDO_VRFCK] = "pmic-ldo-vrfck",
[PMIC_LDO_VBBCK] = "pmic-ldo-vbbck",
[PMIC_AUXOUT_SEL] = "pmic-auxout-sel",
[PMIC_AUXOUT_XO] = "pmic-auxout-xo",
[PMIC_AUXOUT_DRV_CURR] = "pmic-auxout-drvcurr",
[PMIC_AUXOUT_BBLPM_EN] = "pmic-auxout-bblpm-en",
[PMIC_AUXOUT_BBLPM_O] = "pmic-auxout-bblpm-o",
[PMIC_COFST_FPM] = "pmic-cofst-fpm",
[PMIC_CDAC_FPM] = "pmic-cdac-fpm",
[PMIC_CORE_IDAC_FPM] = "pmic-core-idac-fpm",
[PMIC_AAC_FPM_SWEN] = "pmic-aac-fpm-swen",
[PMIC_HEATER_SEL] = "pmic-heater-sel",
};
static const u32 PMIC_CLKBUF_MASK[PMIC_HW_DTS_NUM] = {
[PMIC_DRV_CURR] = 0x3,
[PMIC_HW_BBLPM] = 0x1,
[PMIC_HW_BBLPM_SEL] = 0x1,
[PMIC_LDO_VRFCK] = 0x1,
[PMIC_LDO_VBBCK] = 0x1,
[PMIC_AUXOUT_SEL] = 0x2f,
[PMIC_AUXOUT_XO] = 0x1,
[PMIC_AUXOUT_DRV_CURR] = 0x3,
[PMIC_AUXOUT_BBLPM_EN] = 0x1,
[PMIC_AUXOUT_BBLPM_O] = 0x1,
[PMIC_COFST_FPM] = 0x3,
[PMIC_CDAC_FPM] = 0xff,
[PMIC_CORE_IDAC_FPM] = 0x3,
[PMIC_AAC_FPM_SWEN] = 0x1,
[PMIC_HEATER_SEL] = 0x3,
};
static inline bool _is_pmic_clk_buf_debug_enable(void)
{
#ifdef CLKBUF_DEBUG
return 1;
#else
return 0;
#endif
}
static inline struct pmic_clkbuf_dts *find_pmic_dts_node(u32 dts)
{
struct pmic_clkbuf_dts *node = NULL;
list_for_each_entry(node, &dts_head, dts_list) {
if (!strcmp(pmic_clkbuf_prop[dts], node->name))
return node;
}
pr_info("[%s]: no %s property, function not support or something wrong\n",
__func__, pmic_clkbuf_prop[dts]);
return NULL;
}
static inline void pmic_clkbuf_read(u32 dts, u32 id, u32 *val)
{
struct pmic_clkbuf_dts *node = NULL;
u32 regval = 0;
node = find_pmic_dts_node(dts);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
regmap_read(node->cfg.regmap, node->cfg.ofs[id], &regval);
*val = (regval >> node->cfg.bit[id] & node->mask);
}
static inline void pmic_clkbuf_write(u32 dts, u32 id, u32 val)
{
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(dts);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
val <<= node->cfg.bit[id];
pr_info("offset: 0x%x\n", node->cfg.ofs[id]);
regmap_write(node->cfg.regmap, node->cfg.ofs[id], val);
}
static inline void pmic_clkbuf_set(u32 dts, u32 id, u32 val)
{
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(dts);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
val <<= node->cfg.bit[id];
regmap_write(node->cfg.regmap, node->cfg.ofs[id] + 0x2, val);
}
static inline void pmic_clkbuf_clr(u32 dts, u32 id, u32 val)
{
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(dts);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
val <<= node->cfg.bit[id];
regmap_write(node->cfg.regmap, node->cfg.ofs[id] + 0x4, val);
}
static inline void pmic_clkbuf_update(u32 dts, u32 id, u32 val)
{
struct pmic_clkbuf_dts *node = NULL;
u32 mask = 0;
u32 out = 0;
node = find_pmic_dts_node(dts);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
val <<= node->cfg.bit[id];
mask = node->mask << node->cfg.bit[id];
regmap_update_bits(node->cfg.regmap,
node->cfg.ofs[id],
mask,
val);
regmap_read(node->cfg.regmap, node->cfg.ofs[id], &out);
if (_is_pmic_clk_buf_debug_enable()) {
pr_info("[%s]: val: 0x%x, shift val: 0x%x\n",
__func__, node->cfg.bit[id], val);
pr_info("[%s]: mask: 0x%x, shift mask: 0x%x\n",
__func__, node->mask, mask);
pr_info("%s: update value: 0x%x\n", __func__, out);
}
}
static void _dummy_clk_buf_set_bblpm_hw_msk(enum clk_buf_id id, bool onoff)
{
if (_is_pmic_clk_buf_debug_enable())
pr_info("%s: HW BBLPM not support\n", __func__);
}
static int _dummy_clk_buf_bblpm_hw_en(bool on)
{
if (_is_pmic_clk_buf_debug_enable())
pr_info("%s: HW BBLPM not support\n", __func__);
return 0;
}
static void _dummy_clk_buf_get_drv_curr(u32 *drvcurr)
{
if (_is_pmic_clk_buf_debug_enable())
pr_info("%s: Driving current not support\n", __func__);
}
static void _dummy_clk_buf_set_drv_curr(u32 *drvcurr)
{
if (_is_pmic_clk_buf_debug_enable())
pr_info("%s: Driving current not support\n", __func__);
}
static int _dummy_clk_buf_dump_misc_log(char *buf)
{
if (_is_pmic_clk_buf_debug_enable())
pr_info("%s: Dump misc log for clkbuf not support\n", __func__);
return 0;
}
static void _pmic_clk_buf_set_bblpm_hw_msk(enum clk_buf_id id, bool onoff)
{
pmic_clkbuf_update(PMIC_HW_BBLPM, id, onoff);
}
static int _pmic_clk_buf_bblpm_hw_en(bool on)
{
u32 val = 0;
pmic_clkbuf_update(PMIC_HW_BBLPM_SEL, 0, on);
pmic_clkbuf_read(PMIC_HW_BBLPM_SEL, 0, &val);
pr_debug("%s(%u): bblpm_hw=0x%x\n",
__func__, (on ? 1 : 0), val);
return 0;
}
static void _pmic_clk_buf_get_drv_curr(u32 *drvcurr)
{
int i = 0; /* to write different AUX function */
int j = 0; /* for reading different AUX value */
int offset = 0; /* for ignoring XO_BUF5 */
const u32 auxout_soc_wcn_curr = 0;
const u32 auxout_pd_ext_curr = 2;
int max = auxout_pd_ext_curr - auxout_soc_wcn_curr + 1;
struct pmic_clkbuf_dts *node = NULL;
struct pmic_clkbuf_dts *out_node = NULL;
node = find_pmic_dts_node(PMIC_AUXOUT_SEL);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
out_node = find_pmic_dts_node(PMIC_AUXOUT_DRV_CURR);
if (!out_node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
for (i = 0; i < max; i++) {
if (_is_pmic_clk_buf_debug_enable())
pr_info("%s: AUXOUT drv curr idx: %d, value: %d\n",
__func__,
i,
node->cfg.bit[i + 1]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0,
node->cfg.bit[i + 1]);
if (i == 2) {
offset = 1;
j++;
}
pmic_clkbuf_read(PMIC_AUXOUT_DRV_CURR,
j,
&(drvcurr[i * 2 + offset]));
j++;
pmic_clkbuf_read(PMIC_AUXOUT_DRV_CURR,
j,
&(drvcurr[i * 2 + 1 + offset]));
j++;
}
}
static void _pmic_clk_buf_set_drv_curr(u32 *drvcurr)
{
u32 i = 0;
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(PMIC_AUXOUT_DRV_CURR);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
for (i = 0; i < XO_NUMBER; i++)
if (node->cfg.ofs[i] != NOT_VALID)
pmic_clkbuf_update(PMIC_DRV_CURR, i, drvcurr[i] % 4);
}
static void mt6357_clk_buf_get_xo_en(u32 *stat)
{
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(PMIC_AUXOUT_SEL);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: idx: %d, AUXOUT write: %u\n",
__func__, 1, node->cfg.bit[1]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[1]);
pmic_clkbuf_read(PMIC_AUXOUT_XO, 0, &(stat[0]));
pmic_clkbuf_read(PMIC_AUXOUT_XO, 1, &(stat[1]));
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: idx: %d, AUXOUT write: %u\n",
__func__, 2, node->cfg.bit[2]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[2]);
pmic_clkbuf_read(PMIC_AUXOUT_XO, 2, &(stat[2]));
pmic_clkbuf_read(PMIC_AUXOUT_XO, 3, &(stat[3]));
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: idx: %d, AUXOUT write: %u\n",
__func__, 3, node->cfg.bit[3]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[3]);
pmic_clkbuf_read(PMIC_AUXOUT_XO, 5, &(stat[5]));
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: idx: %d, AUXOUT write: %u\n",
__func__, 4, node->cfg.bit[4]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[4]);
pmic_clkbuf_read(PMIC_AUXOUT_XO, 6, &(stat[6]));
}
static void mt6359_clk_buf_get_xo_en(u32 *stat)
{
u32 i = 0;
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(PMIC_AUXOUT_SEL);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[1]);
for (i = 0; i < XO_NUMBER; i++)
if (node->cfg.ofs[i] != NOT_VALID)
pmic_clkbuf_read(PMIC_AUXOUT_XO, i, &(stat[i]));
pr_info("[%s]: EN_STAT=%u %u %u %u %u %u\n",
__func__,
stat[XO_SOC],
stat[XO_WCN],
stat[XO_NFC],
stat[XO_CEL],
stat[XO_PD],
stat[XO_EXT]);
}
static void mt6357_clk_buf_get_bblpm_en(u32 *stat)
{
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(PMIC_AUXOUT_SEL);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: auxout bblpm idx: %u\n",
__func__, node->cfg.bit[5]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[5]);
pmic_clkbuf_read(PMIC_AUXOUT_BBLPM_EN, 0, &(stat[0]));
}
static void mt6357_clk_buf_set_cap_id(u32 capid)
{
pmic_clkbuf_update(PMIC_COFST_FPM, 0, 0);
pmic_clkbuf_update(PMIC_CDAC_FPM, 0, capid);
pmic_clkbuf_update(PMIC_CORE_IDAC_FPM, 0, 2);
pmic_clkbuf_update(PMIC_AAC_FPM_SWEN, 0, 0);
mdelay(1);
pmic_clkbuf_update(PMIC_AAC_FPM_SWEN, 0, 1);
mdelay(5);
}
static void mt6357_clk_buf_get_cap_id(u32 *capid)
{
pmic_clkbuf_read(PMIC_CDAC_FPM, 0, capid);
}
static void mt6357_clk_buf_set_heater(bool on)
{
if (on)
pmic_clkbuf_update(PMIC_HEATER_SEL, 0, 2);
else
pmic_clkbuf_update(PMIC_HEATER_SEL, 0, 0);
}
static void mt6357_clk_buf_get_heater(bool *on)
{
u32 val = 0;
pmic_clkbuf_read(PMIC_HEATER_SEL, 0, &val);
if (!val)
*on = false;
else
*on = true;
}
static void mt6357_clk_buf_set_cap_id_pre(void)
{
pmic_clkbuf_update(PMIC_COFST_FPM, 0, 0);
pmic_clkbuf_update(PMIC_CORE_IDAC_FPM, 0, 2);
pmic_clkbuf_update(PMIC_AAC_FPM_SWEN, 0, 0);
mdelay(1);
pmic_clkbuf_update(PMIC_AAC_FPM_SWEN, 0, 1);
mdelay(5);
}
static void mt6357_clk_buf_set_cap_id_new(u32 capid)
{
pmic_clkbuf_update(PMIC_CDAC_FPM, 0, capid);
}
static void mt6359_clk_buf_get_bblpm_en(u32 *stat)
{
struct pmic_clkbuf_dts *node = NULL;
node = find_pmic_dts_node(PMIC_AUXOUT_SEL);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return;
}
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: auxout bblpm idx: %u\n",
__func__, node->cfg.bit[2]);
pmic_clkbuf_write(PMIC_AUXOUT_SEL, 0, node->cfg.bit[2]);
pmic_clkbuf_read(PMIC_AUXOUT_BBLPM_EN, 0, &(stat[0]));
}
static int mt6359_clk_buf_dump_misc_log(char *buf)
{
u32 len = strlen(buf);
u32 val = 0;
u32 i = 0;
u32 node_idx[2] = {PMIC_LDO_VRFCK, PMIC_LDO_VBBCK};
struct pmic_clkbuf_dts *node = NULL;
for (i = 0; i < 2; i++) {
node = find_pmic_dts_node(node_idx[i]);
if (!node) {
pr_info("%s: pmic node property not stored, something wrong!\n",
__func__);
return 0;
}
pmic_clkbuf_read(PMIC_LDO_VRFCK, 0, &val);
len += snprintf(buf+len, PAGE_SIZE-len, "%s(%s)=0x%x\n",
node->name, "en", val);
pmic_clkbuf_read(PMIC_LDO_VRFCK, 1, &val);
len += snprintf(buf+len, PAGE_SIZE-len, "%s(%s)=0x%x\n",
node->name, "op_mode", val);
}
return len;
}
static inline int _pmic_clk_buf_find_mask(const char *pmic_prop,
struct pmic_clkbuf_dts *pmic_dts_node)
{
u32 idx = 0;
if (!pmic_dts_node) {
pr_info("[%s]: no pmic clkbuf dts node, find mask failed!\n",
__func__);
return -1;
}
for (idx = 0; idx < PMIC_HW_DTS_NUM; idx++) {
if (!strcmp(pmic_prop, pmic_clkbuf_prop[idx])) {
pmic_dts_node->mask = PMIC_CLKBUF_MASK[idx];
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: find %s mask: 0x%x\n",
__func__,
pmic_prop,
pmic_dts_node->mask);
return 0;
}
}
pr_info("[%s]: find %s mask failed\n", __func__, pmic_prop);
return -1;
}
static void _free_pmic_dts_list(void)
{
struct pmic_clkbuf_dts *node = NULL;
struct pmic_clkbuf_dts *next = NULL;
list_for_each_entry_safe(node, next, &dts_head, dts_list) {
list_del(&(node->dts_list));
kfree(node->cfg.ofs);
kfree(node->cfg.bit);
kfree(node);
}
}
static int _pmic_clk_buf_dts_get_property(struct device_node *node,
struct regmap *regmap,
const char *pmic_prop)
{
u32 n_prop = 0;
u32 idx = 0;
int ret = 0;
char n_pmic_prop[32] = "n-"; /* n-xxx property */
struct pmic_clkbuf_dts *pmic_dts_node = NULL;
strncat(n_pmic_prop, pmic_prop, sizeof(n_pmic_prop) - 1);
ret = of_property_read_u32(node, n_pmic_prop, &n_prop);
if (ret) {
pr_info("[%s]: find %s failed\n", __func__, n_pmic_prop);
goto no_property;
}
pmic_dts_node = kzalloc(sizeof(struct pmic_clkbuf_dts), GFP_KERNEL);
if (!pmic_dts_node)
goto no_mem;
pmic_dts_node->cfg.ofs = kcalloc(n_prop, sizeof(u32), GFP_KERNEL);
if (!(pmic_dts_node->cfg.ofs)) {
pr_info("[%s]: allocate cfg offset memory failed\n",
__func__);
goto no_cfg_offset_mem;
}
pmic_dts_node->cfg.bit = kcalloc(n_prop, sizeof(u32), GFP_KERNEL);
if (!(pmic_dts_node->cfg.bit)) {
pr_info("[%s]: allocate cfg offset memory failed\n",
__func__);
goto no_cfg_bit_mem;
}
strncpy(pmic_dts_node->name, pmic_prop,
sizeof(pmic_dts_node->name) - 1);
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: node name: %s\n",
__func__, pmic_dts_node->name);
pmic_dts_node->cfg.regmap = regmap;
ret = _pmic_clk_buf_find_mask(pmic_prop, pmic_dts_node);
if (ret)
goto mask_not_found;
for (idx = 0; idx < n_prop; idx++) {
ret = of_property_read_u32_index(node,
pmic_prop,
(idx * 2),
&(pmic_dts_node->cfg.ofs[idx]));
if (ret) {
pr_info("[%s]: find %s cfg offset index %u failed\n",
__func__, pmic_prop, idx);
goto offset_not_found;
}
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: find %s cfg offset index %u: %u\n",
__func__,
pmic_prop,
idx,
pmic_dts_node->cfg.ofs[idx]);
ret = of_property_read_u32_index(node,
pmic_prop,
(idx * 2 + 1),
&(pmic_dts_node->cfg.bit[idx]));
if (ret) {
pr_info("[%s]: find %s cfg bit index %u failed\n",
__func__, pmic_prop, idx);
goto bit_not_found;
}
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: find %s cfg bit index %u: %u\n",
__func__,
pmic_prop,
idx,
pmic_dts_node->cfg.bit[idx]);
}
INIT_LIST_HEAD(&(pmic_dts_node->dts_list));
list_add_tail(&(pmic_dts_node->dts_list), &dts_head);
return 0;
bit_not_found:
offset_not_found:
mask_not_found:
kfree(pmic_dts_node->cfg.bit);
no_cfg_bit_mem:
kfree(pmic_dts_node->cfg.ofs);
no_cfg_offset_mem:
kfree(pmic_dts_node);
no_property:
no_mem:
return -1;
}
static int _pmic_clk_buf_dts_init(struct device_node *node,
struct regmap *regmap)
{
u32 n_prop = 0;
u32 idx = 0;
const char *prop;
int ret = 0;
INIT_LIST_HEAD(&dts_head);
ret = of_property_read_u32(node,
"n-clkbuf-pmic-dependent",
&n_prop);
if (ret) {
pr_info("[%s]: read number of pmic clkbuf dependent failed\n",
__func__);
goto no_property;
}
for (idx = 0; idx < n_prop; idx++) {
ret = of_property_read_string_index(node,
"clkbuf-pmic-dependent",
idx,
&prop);
if (_is_pmic_clk_buf_debug_enable())
pr_info("[%s]: find property %s\n", __func__, prop);
if (ret) {
pr_info("[%s]: read pmic clkbuf dependent failed\n",
__func__);
goto dependent_property_failed;
}
ret = _pmic_clk_buf_dts_get_property(node, regmap, prop);
if (ret) {
pr_info("[%s]: find property %s failed\n",
__func__,
prop);
goto find_property_internal_failed;
}
}
pr_info("[%s]: pmic dts init done\n", __func__);
return 0;
find_property_internal_failed:
dependent_property_failed:
_free_pmic_dts_list();
no_property:
return -1;
}
static struct pmic_clkbuf_op pmic_clkbuf[PMIC_NUM] = {
[PMIC_6357] = {
.pmic_name = "mt6357",
.pmic_clk_buf_set_bblpm_hw_msk =
_dummy_clk_buf_set_bblpm_hw_msk,
.pmic_clk_buf_bblpm_hw_en = _dummy_clk_buf_bblpm_hw_en,
.pmic_clk_buf_get_drv_curr = _pmic_clk_buf_get_drv_curr,
.pmic_clk_buf_set_drv_curr = _pmic_clk_buf_set_drv_curr,
.pmic_clk_buf_dts_init = _pmic_clk_buf_dts_init,
.pmic_clk_buf_get_xo_en = mt6357_clk_buf_get_xo_en,
.pmic_clk_buf_get_bblpm_en = mt6357_clk_buf_get_bblpm_en,
.pmic_clk_buf_dump_misc_log = _dummy_clk_buf_dump_misc_log,
.pmic_clk_buf_set_cap_id = mt6357_clk_buf_set_cap_id,
.pmic_clk_buf_get_cap_id = mt6357_clk_buf_get_cap_id,
.pmic_clk_buf_set_heater = mt6357_clk_buf_set_heater,
.pmic_clk_buf_get_heater = mt6357_clk_buf_get_heater,
.pmic_clk_buf_set_cap_id_pre = mt6357_clk_buf_set_cap_id_pre,
.pmic_clk_buf_set_cap_id_new = mt6357_clk_buf_set_cap_id_new,
},
[PMIC_6359] = {
.pmic_name = "mt6359",
.pmic_clk_buf_set_bblpm_hw_msk =
_pmic_clk_buf_set_bblpm_hw_msk,
.pmic_clk_buf_bblpm_hw_en = _pmic_clk_buf_bblpm_hw_en,
.pmic_clk_buf_get_drv_curr = _dummy_clk_buf_get_drv_curr,
.pmic_clk_buf_set_drv_curr = _dummy_clk_buf_set_drv_curr,
.pmic_clk_buf_dts_init = _pmic_clk_buf_dts_init,
.pmic_clk_buf_get_xo_en = mt6359_clk_buf_get_xo_en,
.pmic_clk_buf_get_bblpm_en = mt6359_clk_buf_get_bblpm_en,
.pmic_clk_buf_dump_misc_log = mt6359_clk_buf_dump_misc_log,
},
};
int get_pmic_clkbuf(struct device_node *node,
struct pmic_clkbuf_op **pmic_op)
{
u32 idx = 0;
struct device_node *parent_node = node->parent;
for (idx = 0; idx < PMIC_NUM; idx++) {
if (of_device_is_compatible(parent_node, PMIC_NAME[idx])) {
*pmic_op = &pmic_clkbuf[idx];
return 0;
}
}
return -1;
}
@@ -0,0 +1,66 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/**
* @file mtk_clk_buf_common.h
* @brief Driver for clock buffer control
*
*/
#ifndef __MTK_CLK_BUF_COMMON_H__
#define __MTK_CLK_BUF_COMMON_H__
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/sysfs.h>
#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/ratelimit.h>
#include <linux/workqueue.h>
#include <linux/io.h>
//#include <mt-plat/sync_write.h>
//#include <mt-plat/upmu_common.h>
#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) "[Power/clkbuf] " fmt
#ifdef CONFIG_PM
#define DEFINE_ATTR_RO(_name) \
static struct kobj_attribute _name##_attr = { \
.attr = { \
.name = #_name, \
.mode = 0444, \
}, \
.show = _name##_show, \
}
#define DEFINE_ATTR_RW(_name) \
static struct kobj_attribute _name##_attr = { \
.attr = { \
.name = #_name, \
.mode = 0644, \
}, \
.show = _name##_show, \
.store = _name##_store, \
}
#define __ATTR_OF(_name) (&_name##_attr.attr)
#endif /* CONFIG_PM */
#define NOT_VALID 0xffff
/* #define CLKBUF_DEBUG */
extern struct mutex clk_buf_ctrl_lock;
#endif
@@ -0,0 +1,27 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/**
* @file mtk_clk_buf_ctl.h
* @brief Driver for clock buffer control
*
*/
#ifndef __MTK_CLK_BUF_CTL_H__
#define __MTK_CLK_BUF_CTL_H__
#include <linux/kernel.h>
#include <linux/mutex.h>
#include "mtk_clkbuf_hw.h"
enum CLK_BUF_TYPE {
CLK_BUF_SW_DISABLE = 0,
CLK_BUF_SW_ENABLE = 1,
};
int mtk_register_clk_buf(struct device *dev, struct clk_buf_op *ops);
#endif
@@ -0,0 +1,164 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/**
* @file mtk_clk_buf_hw.h
* @brief Driver for clock buffer control
*
*/
#ifndef __MTK_CLK_BUF_HW_H__
#define __MTK_CLK_BUF_HW_H__
enum MTK_CLK_BUF_STATUS {
CLOCK_BUFFER_DISABLE,
CLOCK_BUFFER_SW_CONTROL,
CLOCK_BUFFER_HW_CONTROL,
};
enum MTK_CLK_BUF_OUTPUT_IMPEDANCE {
CLK_BUF_OUTPUT_IMPEDANCE_0,
CLK_BUF_OUTPUT_IMPEDANCE_1,
CLK_BUF_OUTPUT_IMPEDANCE_2,
CLK_BUF_OUTPUT_IMPEDANCE_3,
CLK_BUF_OUTPUT_IMPEDANCE_4,
CLK_BUF_OUTPUT_IMPEDANCE_5,
CLK_BUF_OUTPUT_IMPEDANCE_6,
CLK_BUF_OUTPUT_IMPEDANCE_7,
};
enum MTK_CLK_BUF_CONTROLS_FOR_DESENSE {
CLK_BUF_CONTROLS_FOR_DESENSE_0,
CLK_BUF_CONTROLS_FOR_DESENSE_1,
CLK_BUF_CONTROLS_FOR_DESENSE_2,
CLK_BUF_CONTROLS_FOR_DESENSE_3,
CLK_BUF_CONTROLS_FOR_DESENSE_4,
CLK_BUF_CONTROLS_FOR_DESENSE_5,
CLK_BUF_CONTROLS_FOR_DESENSE_6,
CLK_BUF_CONTROLS_FOR_DESENSE_7,
};
enum MTK_CLK_BUF_DRIVING_CURR {
CLK_BUF_DRIVING_CURR_AUTO_K = -1,
CLK_BUF_DRIVING_CURR_0,
CLK_BUF_DRIVING_CURR_1,
CLK_BUF_DRIVING_CURR_2,
CLK_BUF_DRIVING_CURR_3
};
enum cmd_type {
CLK_BUF_OFF,
CLK_BUF_ON,
CLK_BUF_ENBB,
CLK_BUF_SIG,
CLK_BUF_COBUF,
CLK_BUF_INIT_SETTING
};
enum {
PWR_STATUS_MD = (1 << 0),
PWR_STATUS_CONN = (1 << 1),
};
enum {
BUF_MAN_M = 0,
EN_BB_M,
SIG_CTRL_M,
CO_BUF_M,
MODE_M_NUM,
};
enum reg_type {
PMIC_R = 0,
PWRAP_R,
SPM,
REGMAP_NUM,
};
enum dev_sta {
DEV_NOT_SUPPORT = 0,
DEV_ON,
DEV_OFF,
};
enum dts_arg {
DCXO_START = 0,
XO_START = DCXO_START,
XO_SW_EN = XO_START,
DCXO_CW,
XO_HW_SEL,
XO_END,
BBLPM_START = XO_END,
BBL_SW_EN = BBLPM_START,
BBLPM_END,
MISC_START = BBLPM_END,
MISC_SRCLKENI_EN = MISC_START,
MISC_END,
DCXO_END = MISC_END,
PWRAP_START = DCXO_END,
PWRAP_DCXO_EN = PWRAP_START,
PWRAP_CONN_EN,
PWRAP_NFC_EN,
PWRAP_CONN_CFG,
PWRAP_NFC_CFG,
PWRAP_END,
GPIO_START = PWRAP_END,
GPIO_END = GPIO_START,
SPM_START = GPIO_END,
SPM_MD_PWR_STA = SPM_START,
SPM_CONN_PWR_STA,
SPM_END,
DTS_NUM = SPM_END,
};
struct dts_predef {
const char prop[20];
u32 len;
u32 idx;
u32 mask;
u32 interval;
};
struct reg_info {
struct regmap *regmap;
u32 *ofs;
u32 *bit;
};
struct clk_buf_op {
/* initial flow */
void (*xo_init)(void);
int (*bblpm_init)(void);
int (*dts_init)(struct platform_device *dev);
int (*fs_init)(void);
/* cat state */
bool (*get_bringup_sta)(void);
bool (*get_clkbuf_init_sta)(void);
bool (*get_flight_mode)(void);
int (*get_xo_sta)(enum xo_id id);
void (*get_bblpm_enter_cond)(u32 *bblpm_cond);
int (*get_bblpm_sta)(void);
/* dump log */
void (*get_main_log)(void);
int (*get_dws_log)(char *buf);
int (*get_misc_log)(char *buf);
/* set state */
void (*set_bringup_sta)(bool on);
void (*set_clkbuf_init_sta)(bool on);
void (*set_flight_mode)(bool on);
bool (*set_xo_sta)(enum clk_buf_id id, bool on);
int (*set_xo_cmd)(enum clk_buf_id id, enum cmd_type type);
int (*set_bblpm_sta)(bool on);
int (*set_bblpm_hw_mode)(bool on);
};
int clk_buf_hw_probe(struct platform_device *pdev);
#endif
@@ -0,0 +1,78 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
/**
* @file mtk_clk_buf_hw.h
* @brief Driver for clock buffer control
*
*/
#ifndef __MTK_CLK_BUF_PMIC_H__
#define __MTK_CLK_BUF_PMIC_H__
#include <linux/list.h>
#include <mtk_clkbuf_common.h>
#include <mtk-clkbuf-bridge.h>
enum {
PMIC_6357 = 0,
PMIC_6359,
PMIC_NUM,
};
enum {
PMIC_DRV_CURR = 0,
PMIC_HW_BBLPM,
PMIC_HW_BBLPM_SEL,
PMIC_LDO_VRFCK,
PMIC_LDO_VBBCK,
PMIC_AUXOUT_SEL,
PMIC_AUXOUT_XO,
PMIC_AUXOUT_DRV_CURR,
PMIC_AUXOUT_BBLPM_EN,
PMIC_AUXOUT_BBLPM_O,
PMIC_COFST_FPM,
PMIC_CDAC_FPM,
PMIC_CORE_IDAC_FPM,
PMIC_AAC_FPM_SWEN,
PMIC_HEATER_SEL,
PMIC_HW_DTS_NUM, /* Number of HW dependent PMIC properties */
};
struct pmic_clkbuf_reg {
struct regmap *regmap;
u32 *ofs;
u32 *bit;
};
struct pmic_clkbuf_dts {
char name[32];
struct pmic_clkbuf_reg cfg;
u32 mask;
struct list_head dts_list;
};
struct pmic_clkbuf_op {
char pmic_name[20];
void (*pmic_clk_buf_set_bblpm_hw_msk)(enum clk_buf_id id, bool onoff);
int (*pmic_clk_buf_bblpm_hw_en)(bool on);
void (*pmic_clk_buf_get_drv_curr)(u32 *drvcurr);
void (*pmic_clk_buf_set_drv_curr)(u32 *drvcurr);
int (*pmic_clk_buf_dts_init)(struct device_node *pmic_node,
struct regmap *regmap);
void (*pmic_clk_buf_get_xo_en)(u32 *stat);
void (*pmic_clk_buf_get_bblpm_en)(u32 *stat);
int (*pmic_clk_buf_dump_misc_log)(char *buf);
void (*pmic_clk_buf_set_cap_id)(u32 capid);
void (*pmic_clk_buf_get_cap_id)(u32 *capid);
void (*pmic_clk_buf_set_heater)(bool on);
void (*pmic_clk_buf_get_heater)(bool *on);
void (*pmic_clk_buf_set_cap_id_pre)(void);
void (*pmic_clk_buf_set_cap_id_new)(u32 capid);
};
int get_pmic_clkbuf(struct device_node *node, struct pmic_clkbuf_op **pmic_op);
#endif