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,399 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifdef DFT_TAG
#undef DFT_TAG
#endif
#define DFT_TAG "[CONNADP]"
#include "connectivity_build_in_adapter.h"
#include <kernel/sched/sched.h>
/*device tree mode*/
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/irqreturn.h>
#include <linux/of_address.h>
#endif
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/of_reserved_mem.h>
#include <linux/trace_events.h>
#include <linux/interrupt.h>
#ifdef CONFIG_MTK_MT6306_GPIO_SUPPORT
#include <mtk_6306_gpio.h>
#endif
#ifdef CONNADP_HAS_CLOCK_BUF_CTRL
#include <mtk_clkbuf_ctl.h>
#endif
/* PMIC */
#if defined(CONFIG_MTK_PMIC_CHIP_MT6359)
#include <mtk_pmic_api_buck.h>
#endif
#if defined(CONFIG_MTK_PMIC_CHIP_MT6359P)
#include <pmic_api_buck.h>
#endif
#include <upmu_common.h>
/* MMC */
#include <linux/mmc/card.h>
#include <linux/mmc/host.h>
#include <sdio_ops.h>
#ifdef CONFIG_ARCH_MT6570
#define CPU_BOOST y
#endif
#ifdef CONFIG_ARCH_MT6755
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6757
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6763
#define CPU_BOOST y
#endif
#ifdef CPU_BOOST
#include "mtk_ppm_api.h"
#endif
#ifndef TASK_STATE_TO_CHAR_STR
#define TASK_STATE_TO_CHAR_STR "RSDTtXZxKWPNn"
#endif
void connectivity_export_show_stack(struct task_struct *tsk, unsigned long *sp)
{
#ifdef CFG_CONNADP_BUILD_IN
show_stack(tsk, sp);
#else
pr_info("%s not support in connadp.ko\n", __func__);
#endif
}
EXPORT_SYMBOL(connectivity_export_show_stack);
void connectivity_export_tracing_record_cmdline(struct task_struct *tsk)
{
#ifdef CONFIG_TRACING
#ifdef CFG_CONNADP_BUILD_IN
tracing_record_cmdline(tsk);
#else
pr_info("%s not support in connadp.ko\n", __func__);
#endif
#endif
}
EXPORT_SYMBOL(connectivity_export_tracing_record_cmdline);
void connectivity_export_conap_scp_init(unsigned int chip_info, phys_addr_t emi_phy_addr)
{
}
EXPORT_SYMBOL(connectivity_export_conap_scp_init);
void connectivity_export_conap_scp_deinit(void)
{
}
EXPORT_SYMBOL(connectivity_export_conap_scp_deinit);
#ifdef CPU_BOOST
bool connectivity_export_spm_resource_req(unsigned int user,
unsigned int req_mask)
{
return spm_resource_req(user, req_mask);
}
EXPORT_SYMBOL(connectivity_export_spm_resource_req);
void connectivity_export_mt_ppm_sysboost_freq(enum ppm_sysboost_user user,
unsigned int freq)
{
mt_ppm_sysboost_freq(user, freq);
}
EXPORT_SYMBOL(connectivity_export_mt_ppm_sysboost_freq);
void connectivity_export_mt_ppm_sysboost_core(enum ppm_sysboost_user user,
unsigned int core_num)
{
mt_ppm_sysboost_core(user, core_num);
}
EXPORT_SYMBOL(connectivity_export_mt_ppm_sysboost_core);
void connectivity_export_mt_ppm_sysboost_set_core_limit(
enum ppm_sysboost_user user,
unsigned int cluster,
int min_core, int max_core)
{
mt_ppm_sysboost_set_core_limit(user, cluster, min_core, max_core);
}
EXPORT_SYMBOL(connectivity_export_mt_ppm_sysboost_set_core_limit);
void connectivity_export_mt_ppm_sysboost_set_freq_limit(
enum ppm_sysboost_user user,
unsigned int cluster,
int min_freq, int max_freq)
{
mt_ppm_sysboost_set_freq_limit(user, cluster, min_freq, max_freq);
}
EXPORT_SYMBOL(connectivity_export_mt_ppm_sysboost_set_freq_limit);
#endif
/*******************************************************************************
* Clock Buffer Control
******************************************************************************/
#ifdef CONNADP_HAS_CLOCK_BUF_CTRL
void connectivity_export_clk_buf_ctrl(enum clk_buf_id id, bool onoff)
{
clk_buf_ctrl(id, onoff);
}
EXPORT_SYMBOL(connectivity_export_clk_buf_ctrl);
void connectivity_export_clk_buf_show_status_info(void)
{
#if defined(CONFIG_MACH_MT6768) || \
defined(CONFIG_MACH_MT6771) || \
defined(CONFIG_MACH_MT6739) || \
defined(CONFIG_MACH_MT6781) || \
defined(CONFIG_MACH_MT6785) || \
defined(CONFIG_MACH_MT6873) || \
defined(CONFIG_MACH_MT6885) || \
defined(CONFIG_MACH_MT6893) || \
defined(CONFIG_MACH_MT6877)
#if defined(CONFIG_MTK_BASE_POWER)
clk_buf_show_status_info();
#else
pr_info("[%s] not support now", __func__);
#endif
#endif
}
EXPORT_SYMBOL(connectivity_export_clk_buf_show_status_info);
int connectivity_export_clk_buf_get_xo_en_sta(/*enum xo_id id*/ int id)
{
#if defined(CONFIG_MACH_MT6768) || \
defined(CONFIG_MACH_MT6781) || \
defined(CONFIG_MACH_MT6785) || \
defined(CONFIG_MACH_MT6771) || \
defined(CONFIG_MACH_MT6739)
return clk_buf_get_xo_en_sta(id);
#else
return KERNEL_CLK_BUF_CHIP_NOT_SUPPORT;
#endif
}
EXPORT_SYMBOL(connectivity_export_clk_buf_get_xo_en_sta);
#endif
/*******************************************************************************
* MT6306 I2C-based GPIO Expander
******************************************************************************/
#ifdef CONFIG_MTK_MT6306_GPIO_SUPPORT
void connectivity_export_mt6306_set_gpio_out(unsigned long pin,
unsigned long output)
{
mt6306_set_gpio_out(MT6306_GPIO_01, MT6306_GPIO_OUT_LOW);
}
EXPORT_SYMBOL(connectivity_export_mt6306_set_gpio_out);
void connectivity_export_mt6306_set_gpio_dir(unsigned long pin,
unsigned long dir)
{
mt6306_set_gpio_dir(MT6306_GPIO_01, MT6306_GPIO_DIR_OUT);
}
EXPORT_SYMBOL(connectivity_export_mt6306_set_gpio_dir);
#endif
/*******************************************************************************
* PMIC
******************************************************************************/
void connectivity_export_pmic_config_interface(unsigned int RegNum,
unsigned int val, unsigned int MASK, unsigned int SHIFT)
{
#if !defined(CONFIG_MACH_MT6761) && !defined(CONFIG_MACH_MT6765) && !defined(CONFIG_MACH_MT6779)
pmic_config_interface(RegNum, val, MASK, SHIFT);
#else
return;
#endif
}
EXPORT_SYMBOL(connectivity_export_pmic_config_interface);
void connectivity_export_pmic_read_interface(unsigned int RegNum,
unsigned int *val, unsigned int MASK, unsigned int SHIFT)
{
#if !defined(CONFIG_MACH_MT6761) && !defined(CONFIG_MACH_MT6765) && !defined(CONFIG_MACH_MT6779)
pmic_read_interface(RegNum, val, MASK, SHIFT);
#else
return;
#endif
}
EXPORT_SYMBOL(connectivity_export_pmic_read_interface);
void connectivity_export_pmic_set_register_value(int flagname, unsigned int val)
{
#ifdef CONNADP_HAS_UPMU_VCN_CTRL
upmu_set_reg_value(flagname, val);
#else
#if !defined(CONFIG_MACH_MT6761) && !defined(CONFIG_MACH_MT6765) && !defined(CONFIG_MACH_MT6779)
pmic_set_register_value(flagname, val);
#else
return;
#endif
#endif
}
EXPORT_SYMBOL(connectivity_export_pmic_set_register_value);
unsigned short connectivity_export_pmic_get_register_value(int flagname)
{
#ifdef CONNADP_HAS_UPMU_VCN_CTRL
return upmu_get_reg_value(flagname);
#else
#if !defined(CONFIG_MACH_MT6761) && !defined(CONFIG_MACH_MT6765) && !defined(CONFIG_MACH_MT6779)
return pmic_get_register_value(flagname);
#else
return 0;
#endif
#endif
}
EXPORT_SYMBOL(connectivity_export_pmic_get_register_value);
void connectivity_export_upmu_set_reg_value(unsigned int reg,
unsigned int reg_val)
{
#if !defined(CONFIG_MACH_MT6761) && !defined(CONFIG_MACH_MT6765) && !defined(CONFIG_MACH_MT6779)
upmu_set_reg_value(reg, reg_val);
#else
return;
#endif
}
EXPORT_SYMBOL(connectivity_export_upmu_set_reg_value);
#if defined(CONFIG_MTK_PMIC_CHIP_MT6359) || \
defined(CONFIG_MTK_PMIC_CHIP_MT6359P)
int connectivity_export_pmic_ldo_vcn13_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg)
{
return pmic_ldo_vcn13_lp(user, op_mode, op_en, op_cfg);
}
EXPORT_SYMBOL(connectivity_export_pmic_ldo_vcn13_lp);
int connectivity_export_pmic_ldo_vcn18_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg)
{
return pmic_ldo_vcn18_lp(user, op_mode, op_en, op_cfg);
}
EXPORT_SYMBOL(connectivity_export_pmic_ldo_vcn18_lp);
void connectivity_export_pmic_ldo_vfe28_lp(unsigned int user,
int op_mode, unsigned char op_en, unsigned char op_cfg)
{
pmic_ldo_vfe28_lp(user, op_mode, op_en, op_cfg);
}
EXPORT_SYMBOL(connectivity_export_pmic_ldo_vfe28_lp);
int connectivity_export_pmic_ldo_vcn33_1_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg)
{
return pmic_ldo_vcn33_1_lp(user, op_mode, op_en, op_cfg);
}
EXPORT_SYMBOL(connectivity_export_pmic_ldo_vcn33_1_lp);
int connectivity_export_pmic_ldo_vcn33_2_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg)
{
return pmic_ldo_vcn33_2_lp(user, op_mode, op_en, op_cfg);
}
EXPORT_SYMBOL(connectivity_export_pmic_ldo_vcn33_2_lp);
#endif
/*******************************************************************************
* MMC
******************************************************************************/
int connectivity_export_mmc_io_rw_direct(struct mmc_card *card,
int write, unsigned int fn,
unsigned int addr, u8 in, u8 *out)
{
/* TODO: porting this function if sdio is used */
/* return mmc_io_rw_direct(card, write, fn, addr, in, out); */
return 0;
}
EXPORT_SYMBOL(connectivity_export_mmc_io_rw_direct);
/******************************************************************************
* GPIO dump information
******************************************************************************/
#ifndef CONFIG_MTK_GPIO
void __weak gpio_dump_regs_range(int start, int end)
{
pr_info(DFT_TAG "[W]%s: is not define!\n", __func__);
}
#endif
#ifndef CONFIG_MTK_GPIO
void connectivity_export_dump_gpio_info(int start, int end)
{
gpio_dump_regs_range(start, end);
}
EXPORT_SYMBOL(connectivity_export_dump_gpio_info);
#endif
void connectivity_export_dump_thread_state(const char *name)
{
#ifdef CFG_CONNADP_BUILD_IN
static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;
struct task_struct *p;
int cpu;
struct rq *rq;
struct task_struct *curr;
struct thread_info *ti;
if (name == NULL || strlen(name) > 255) {
pr_info("invalid name:%p or thread name too long\n", name);
return;
}
pr_info("start to show debug info of %s\n", name);
rcu_read_lock();
for_each_process(p) {
unsigned long state;
if (strncmp(p->comm, name, strlen(name)) != 0)
continue;
state = p->state;
cpu = task_cpu(p);
rq = cpu_rq(cpu);
curr = rq->curr;
ti = task_thread_info(curr);
if (state)
state = __ffs(state) + 1;
pr_info("%d:%-15.15s %c", p->pid, p->comm,
state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
pr_info("cpu=%d on_cpu=%d ", cpu, p->on_cpu);
show_stack(p, NULL);
pr_info("CPU%d curr=%d:%-15.15s preempt_count=0x%x", cpu,
curr->pid, curr->comm, ti->preempt_count);
if (state == TASK_RUNNING && curr != p)
show_stack(curr, NULL);
break;
}
rcu_read_unlock();
#else
pr_info("%s not support in connadp.ko\n", __func__);
#endif
}
EXPORT_SYMBOL(connectivity_export_dump_thread_state);
int connectivity_export_gpio_get_tristate_input(unsigned int pin)
{
return 0;
}
EXPORT_SYMBOL(connectivity_export_gpio_get_tristate_input);
MODULE_LICENSE("GPL");
@@ -0,0 +1,290 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef CONNECTIVITY_BUILD_IN_ADAPTER_H
#define CONNECTIVITY_BUILD_IN_ADAPTER_H
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/dma-mapping.h>
#include <linux/sched/clock.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>
#include <mtk-clkbuf-bridge.h>
/*******************************************************************************
* Clock Buffer Control
*
* The Connsys adaptation layer must provide Clock Buffer Control support
* should it be available from the platform.
* Therefore CONNADP_HAS_CLOCK_BUF_CTRL is defined based on platform chip, and
* is used to decide if adaptation has support on Clock Buffer Control.
*
* Each WMT platform file must still define its own CONSYS_CLOCK_BUF_CTRL to
* decide if it is a co-clock'd platform.
* It is possible that the Clock Buffer Control is available on the platform,
* but is not used by Connsys.
*
* For Kernel-4,4, definition of CONNADP_HAS_CLOCK_BUF_CTRL must align with:
* drivers/misc/mediatek/base/power/include/mtk_clkbuf_ctl.h
*
* Platform that wishes to use Clock Buffer Control, please be sure to #include
* the header file above.
******************************************************************************/
#if defined(CONFIG_MACH_MT6735) || \
defined(CONFIG_MACH_MT6735M) || \
defined(CONFIG_MACH_MT6753) || \
defined(CONFIG_MACH_MT6739) || \
defined(CONFIG_MACH_MT6755) || \
defined(CONFIG_MACH_MT6757) || \
defined(CONFIG_MACH_MT6758) || \
defined(CONFIG_MACH_MT6759) || \
defined(CONFIG_MACH_MT6763) || \
defined(CONFIG_MACH_MT6775) || \
defined(CONFIG_MACH_MT6797) || \
defined(CONFIG_MACH_MT6799) || \
defined(CONFIG_MACH_MT6580) || \
defined(CONFIG_MACH_MT6761) || \
defined(CONFIG_MACH_MT6765) || \
defined(CONFIG_MACH_MT6781) || \
defined(CONFIG_MACH_MT3967) || \
defined(CONFIG_MACH_MT6771) || \
defined(CONFIG_MACH_MT6768) || \
defined(CONFIG_MACH_MT6785) || \
defined(CONFIG_MACH_KIBOPLUS) || \
defined(CONFIG_MACH_MT6885) || \
defined(CONFIG_MACH_MT6853) || \
defined(CONFIG_MACH_MT6873) || \
defined(CONFIG_MACH_ELBRUS) || \
defined(CONFIG_MACH_MT6893) || \
defined(CONFIG_MACH_MT6877)
#define CONNADP_HAS_CLOCK_BUF_CTRL
#define KERNEL_CLK_BUF_CHIP_NOT_SUPPORT -7788
#define KERNEL_clk_buf_ctrl connectivity_export_clk_buf_ctrl
#define KERNEL_clk_buf_show_status_info \
connectivity_export_clk_buf_show_status_info
#define KERNEL_clk_buf_get_xo_en_sta \
connectivity_export_clk_buf_get_xo_en_sta
enum clk_buf_id;
void connectivity_export_clk_buf_ctrl(enum clk_buf_id id, bool onoff);
void connectivity_export_clk_buf_show_status_info(void);
int connectivity_export_clk_buf_get_xo_en_sta(/*enum xo_id id*/ int id);
#endif
/*******************************************************************************
* PMIC
* Caller please be sure to #include:
* drivers/misc/mediatek/pmic/include/mt6359/mtk_pmic_api_buck.h
* drivers/misc/mediatek/include/mt-plat/upmu_common.h
******************************************************************************/
#define KERNEL_pmic_config_interface \
connectivity_export_pmic_config_interface
#define KERNEL_pmic_read_interface \
connectivity_export_pmic_read_interface
#define KERNEL_pmic_set_register_value \
connectivity_export_pmic_set_register_value
#define KERNEL_pmic_get_register_value \
connectivity_export_pmic_get_register_value
#define KERNEL_upmu_set_reg_value \
connectivity_export_upmu_set_reg_value
#if defined(CONFIG_MTK_PMIC_CHIP_MT6359) || \
defined(CONFIG_MTK_PMIC_CHIP_MT6359P)
#define KERNEL_pmic_ldo_vcn13_lp \
connectivity_export_pmic_ldo_vcn13_lp
#define KERNEL_pmic_ldo_vcn18_lp \
connectivity_export_pmic_ldo_vcn18_lp
#define KERNEL_pmic_ldo_vfe28_lp \
connectivity_export_pmic_ldo_vfe28_lp
#define KERNEL_pmic_ldo_vcn33_1_lp \
connectivity_export_pmic_ldo_vcn33_1_lp
#define KERNEL_pmic_ldo_vcn33_2_lp \
connectivity_export_pmic_ldo_vcn33_2_lp
#endif
void connectivity_export_pmic_config_interface(unsigned int RegNum,
unsigned int val,
unsigned int MASK,
unsigned int SHIFT);
void connectivity_export_pmic_read_interface(unsigned int RegNum,
unsigned int *val,
unsigned int MASK,
unsigned int SHIFT);
void connectivity_export_pmic_set_register_value(int flagname,
unsigned int val);
unsigned short connectivity_export_pmic_get_register_value(int flagname);
void connectivity_export_upmu_set_reg_value(unsigned int reg,
unsigned int reg_val);
#if defined(CONFIG_MTK_PMIC_CHIP_MT6359) || \
defined(CONFIG_MTK_PMIC_CHIP_MT6359P)
int connectivity_export_pmic_ldo_vcn13_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg);
int connectivity_export_pmic_ldo_vcn18_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg);
void connectivity_export_pmic_ldo_vfe28_lp(unsigned int user,
int op_mode, unsigned char op_en, unsigned char op_cfg);
int connectivity_export_pmic_ldo_vcn33_1_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg);
int connectivity_export_pmic_ldo_vcn33_2_lp(int user,
int op_mode, unsigned char op_en, unsigned char op_cfg);
#endif
/*******************************************************************************
* MMC
* Caller please be sure to #include:
* <linux/mmc/host.h>
* <linux/mmc/card.h>
* drivers/mmc/core/sdio_ops.h
******************************************************************************/
#define KERNEL_mmc_io_rw_direct connectivity_export_mmc_io_rw_direct
struct mmc_card;
int connectivity_export_mmc_io_rw_direct(struct mmc_card *card, int write,
unsigned int fn,
unsigned int addr,
u8 in, u8 *out);
/*******************************************************************************
* MT6306 I2C-based GPIO Expander
******************************************************************************/
#ifdef CONFIG_MTK_MT6306_GPIO_SUPPORT
#define KERNEL_mt6306_set_gpio_out connectivity_export_mt6306_set_gpio_out
#define KERNEL_mt6306_set_gpio_dir connectivity_export_mt6306_set_gpio_dir
void connectivity_export_mt6306_set_gpio_out(unsigned long pin,
unsigned long output);
void connectivity_export_mt6306_set_gpio_dir(unsigned long pin,
unsigned long dir);
#endif
#ifdef CONFIG_ARCH_MT6570
#define CPU_BOOST y
#endif
#ifdef CONFIG_ARCH_MT6755
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6757
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6758
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6763
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6799
#define CPU_BOOST y
#endif
#ifdef CONFIG_MACH_MT6739
#define CPU_BOOST y
#endif
#ifdef CPU_BOOST
#include "mtk_ppm_api.h"
#include "mtk_spm_resource_req.h"
#endif
#define KERNEL_show_stack connectivity_export_show_stack
#define KERNEL_tracing_record_cmdline connectivity_export_tracing_record_cmdline
#define KERNEL_dump_thread_state connectivity_export_dump_thread_state
#ifdef CPU_BOOST
#define KERNEL_mt_ppm_sysboost_freq connectivity_export_mt_ppm_sysboost_freq
#define KERNEL_mt_ppm_sysboost_core connectivity_export_mt_ppm_sysboost_core
#define KERNEL_mt_ppm_sysboost_set_core_limit \
connectivity_export_mt_ppm_sysboost_set_core_limit
#define KERNEL_mt_ppm_sysboost_set_freq_limit \
connectivity_export_mt_ppm_sysboost_set_freq_limit
#define KERNEL_spm_resource_req connectivity_export_spm_resource_req
#else
#define KERNEL_mt_ppm_sysboost_freq
#define KERNEL_mt_ppm_sysboost_core
#define KERNEL_mt_ppm_sysboost_set_core_limit
#define KERNEL_mt_ppm_sysboost_set_freq_limit
#define KERNEL_spm_resource_req
#endif
extern void tracing_record_cmdline(struct task_struct *tsk);
extern void show_stack(struct task_struct *tsk, unsigned long *sp);
#ifdef CPU_BOOST
extern void mt_ppm_sysboost_freq(enum ppm_sysboost_user user,
unsigned int freq);
extern void mt_ppm_sysboost_core(enum ppm_sysboost_user user,
unsigned int core_num);
extern void mt_ppm_sysboost_set_core_limit(enum ppm_sysboost_user user,
unsigned int cluster,
int min_core, int max_core);
extern void mt_ppm_sysboost_set_freq_limit(enum ppm_sysboost_user user,
unsigned int cluster,
int min_freq, int max_freq);
extern bool spm_resource_req(unsigned int user, unsigned int req_mask);
#endif
#ifdef CONFIG_ARM64
extern void __flush_dcache_area(void *addr, size_t len);
#else
extern void v7_flush_kern_dcache_area(void *addr, size_t len);
#endif
void connectivity_export_show_stack(struct task_struct *tsk, unsigned long *sp);
void connectivity_export_dump_thread_state(const char *name);
void connectivity_export_tracing_record_cmdline(struct task_struct *tsk);
struct connsys_state_info {
unsigned int chip_info;
phys_addr_t emi_phy_addr;
};
void connectivity_export_conap_scp_init(unsigned int chip_info, phys_addr_t emi_phy_addr);
void connectivity_export_conap_scp_deinit(void);
void connectivity_register_state_notifier(struct notifier_block *nb);
void connectivity_unregister_state_notifier(struct notifier_block *nb);
#ifdef CPU_BOOST
void connectivity_export_mt_ppm_sysboost_freq(enum ppm_sysboost_user user,
unsigned int freq);
void connectivity_export_mt_ppm_sysboost_core(enum ppm_sysboost_user user,
unsigned int core_num);
void connectivity_export_mt_ppm_sysboost_set_core_limit(
enum ppm_sysboost_user user,
unsigned int cluster,
int min_core, int max_core);
void connectivity_export_mt_ppm_sysboost_set_freq_limit(
enum ppm_sysboost_user user,
unsigned int cluster,
int min_freq, int max_freq);
bool connectivity_export_spm_resource_req(unsigned int user,
unsigned int req_mask);
#endif
/*********************************************
* copy from
* kernel-3.18/include/linux/ftrace_event.h
* kernel-4.4/include/linux/trace_events.h
*
* event_trace_printk()
*********************************************/
#ifndef CONFIG_MACH_MT6739
#define KERNEL_event_trace_printk(ip, fmt, args...) \
do { \
__trace_printk_check_format(fmt, ##args); \
KERNEL_tracing_record_cmdline(current); \
if (__builtin_constant_p(fmt)) { \
static const char *trace_printk_fmt \
__attribute__((section("__trace_printk_fmt"))) = \
__builtin_constant_p(fmt) ? fmt : NULL; \
__trace_bprintk(ip, trace_printk_fmt, ##args); \
} else \
__trace_printk(ip, fmt, ##args); \
} while (0)
#endif
/******************************************************************************
* GPIO dump information
******************************************************************************/
#ifndef CONFIG_MTK_GPIO
#define KERNEL_gpio_dump_regs_range connectivity_export_dump_gpio_info
extern void gpio_dump_regs_range(int start, int end);
void connectivity_export_dump_gpio_info(int start, int end);
#endif
int connectivity_export_gpio_get_tristate_input(unsigned int pin);
#endif /* CONNECTIVITY_BUILD_IN_ADAPTER_H */
@@ -0,0 +1,392 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include "wmt_build_in_adapter.h"
#include <linux/string.h>
#include <linux/printk.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/ctype.h>
#include <linux/cdev.h>
/*device tree mode*/
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/irqreturn.h>
#include <linux/of_address.h>
#endif
#include <linux/interrupt.h>
#include <linux/ratelimit.h>
#define CONNADP_LOG_LOUD 4
#define CONNADP_LOG_DBG 3
#define CONNADP_LOG_INFO 2
#define CONNADP_LOG_WARN 1
#define CONNADP_LOG_ERR 0
/*******************************************************************************
* Connsys adaptation layer logging utility
******************************************************************************/
static unsigned int gConnAdpDbgLvl = CONNADP_LOG_INFO;
#define CONNADP_LOUD_FUNC(fmt, arg...) \
do { \
if (gConnAdpDbgLvl >= CONNADP_LOG_LOUD) \
pr_info("[L]%s:" fmt, __func__, ##arg); \
} while (0)
#define CONNADP_DBG_FUNC(fmt, arg...) \
do { \
if (gConnAdpDbgLvl >= CONNADP_LOG_DBG) \
pr_info("[D]%s:" fmt, __func__, ##arg); \
} while (0)
#define CONNADP_INFO_FUNC(fmt, arg...) \
do { \
if (gConnAdpDbgLvl >= CONNADP_LOG_INFO) \
pr_info("[I]%s:" fmt, __func__, ##arg); \
} while (0)
#define CONNADP_WARN_FUNC(fmt, arg...) \
do { \
if (gConnAdpDbgLvl >= CONNADP_LOG_WARN) \
pr_info("[W]%s:" fmt, __func__, ##arg); \
} while (0)
#define CONNADP_ERR_FUNC(fmt, arg...) \
do { \
if (gConnAdpDbgLvl >= CONNADP_LOG_ERR) \
pr_info("[E]%s(%d):" fmt, __func__, __LINE__, ##arg); \
} while (0)
/* device node related macro */
#define CONN_DBG_DEV_NUM 1
#define CONN_DBG_DRVIER_NAME "conn_dbg_drv"
#define CONN_DBG_DEVICE_NAME "conn_dbg_dev"
#define CONN_DBG_DEV_MAJOR 156
/* device node related */
static int gConnDbgMajor = CONN_DBG_DEV_MAJOR;
static struct class *pConnDbgClass;
static struct device *pConnDbgDev;
static struct cdev gConnDbgdev;
/*******************************************************************************
* Bridging from platform -> wmt_drv.ko
******************************************************************************/
static struct wmt_platform_bridge bridge;
ssize_t conn_dbg_dev_write(struct file *filp, const char __user *buffer,
size_t count, loff_t *f_pos)
{
if (bridge.debug_write_cb)
return bridge.debug_write_cb(filp, buffer, count, f_pos);
return 0;
}
ssize_t conn_dbg_dev_read(struct file *filp, char __user *buffer,
size_t count, loff_t *f_pos)
{
if (bridge.debug_read_cb)
return bridge.debug_read_cb(filp, buffer, count, f_pos);
return 0;
}
const struct file_operations gConnDbgDevFops = {
.write = conn_dbg_dev_write,
.read = conn_dbg_dev_read,
};
static int conn_dbg_dev_init(void)
{
dev_t dev_id = MKDEV(gConnDbgMajor, 0);
int ret = 0;
ret = register_chrdev_region(dev_id, CONN_DBG_DEV_NUM, CONN_DBG_DRVIER_NAME);
if (ret) {
pr_info("%s fail to register chrdev.(%d)\n", __func__, ret);
return -1;
}
cdev_init(&gConnDbgdev, &gConnDbgDevFops);
gConnDbgdev.owner = THIS_MODULE;
ret = cdev_add(&gConnDbgdev, dev_id, CONN_DBG_DEV_NUM);
if (ret) {
pr_info("cdev_add() fails (%d)\n", ret);
goto err1;
}
pConnDbgClass = class_create(THIS_MODULE, CONN_DBG_DEVICE_NAME);
if (IS_ERR(pConnDbgClass)) {
pr_info("class create fail, error code(%ld)\n", PTR_ERR(pConnDbgClass));
goto err2;
}
pConnDbgDev = device_create(pConnDbgClass, NULL, dev_id, NULL, CONN_DBG_DEVICE_NAME);
if (IS_ERR(pConnDbgDev)) {
pr_info("device create fail, error code(%ld)\n", PTR_ERR(pConnDbgDev));
goto err3;
}
return 0;
err3:
pr_info("[%s] err3", __func__);
if (pConnDbgClass) {
class_destroy(pConnDbgClass);
pConnDbgClass = NULL;
}
err2:
pr_info("[%s] err2", __func__);
cdev_del(&gConnDbgdev);
err1:
pr_info("[%s] err1", __func__);
unregister_chrdev_region(dev_id, CONN_DBG_DEV_NUM);
return -1;
}
static int conn_dbg_dev_deinit(void)
{
dev_t dev_id = MKDEV(gConnDbgMajor, 0);
if (pConnDbgDev) {
device_destroy(pConnDbgClass, dev_id);
pConnDbgDev = NULL;
}
if (pConnDbgClass) {
class_destroy(pConnDbgClass);
pConnDbgClass = NULL;
}
cdev_del(&gConnDbgdev);
unregister_chrdev_region(dev_id, CONN_DBG_DEV_NUM);
return 0;
}
void wmt_export_platform_bridge_register(struct wmt_platform_bridge *cb)
{
if (unlikely(!cb))
return;
bridge.thermal_query_cb = cb->thermal_query_cb;
bridge.trigger_assert_cb = cb->trigger_assert_cb;
bridge.clock_fail_dump_cb = cb->clock_fail_dump_cb;
bridge.conninfra_reg_readable_cb = cb->conninfra_reg_readable_cb;
bridge.conninfra_reg_is_bus_hang_cb = cb->conninfra_reg_is_bus_hang_cb;
if (cb->debug_write_cb != NULL && cb->debug_read_cb != NULL) {
bridge.debug_write_cb = cb->debug_write_cb;
bridge.debug_read_cb = cb->debug_read_cb;
conn_dbg_dev_init();
}
CONNADP_INFO_FUNC("\n");
}
EXPORT_SYMBOL(wmt_export_platform_bridge_register);
void wmt_export_platform_bridge_unregister(void)
{
if (bridge.debug_write_cb && bridge.debug_read_cb)
conn_dbg_dev_deinit();
memset(&bridge, 0, sizeof(struct wmt_platform_bridge));
CONNADP_INFO_FUNC("\n");
}
EXPORT_SYMBOL(wmt_export_platform_bridge_unregister);
int mtk_wcn_cmb_stub_query_ctrl(void)
{
CONNADP_DBG_FUNC("\n");
if (unlikely(!bridge.thermal_query_cb)) {
CONNADP_WARN_FUNC("Thermal query not registered\n");
return -1;
} else
return bridge.thermal_query_cb();
}
int mtk_wcn_cmb_stub_trigger_assert(void)
{
CONNADP_DBG_FUNC("\n");
/* dump backtrace for checking assert reason */
dump_stack();
if (unlikely(!bridge.trigger_assert_cb)) {
CONNADP_WARN_FUNC("Trigger assert not registered\n");
return -1;
} else
return bridge.trigger_assert_cb();
}
void mtk_wcn_cmb_stub_clock_fail_dump(void)
{
CONNADP_DBG_FUNC("\n");
if (unlikely(!bridge.clock_fail_dump_cb))
CONNADP_WARN_FUNC("Clock fail dump not registered\n");
else
bridge.clock_fail_dump_cb();
}
int mtk_wcn_conninfra_reg_readable(void)
{
static DEFINE_RATELIMIT_STATE(_rs, 5*HZ, 1);
if (unlikely(!bridge.conninfra_reg_readable_cb)) {
if (__ratelimit(&_rs))
CONNADP_WARN_FUNC("reg_readable not registered\n");
return -1;
} else
return bridge.conninfra_reg_readable_cb();
}
int mtk_wcn_conninfra_is_bus_hang(void)
{
static DEFINE_RATELIMIT_STATE(_rs, 5*HZ, 1);
if (unlikely(!bridge.conninfra_reg_is_bus_hang_cb)) {
if (__ratelimit(&_rs))
CONNADP_WARN_FUNC("is_bus_hang not registered\n");
return -1;
} else
return bridge.conninfra_reg_is_bus_hang_cb();
}
/*******************************************************************************
* SDIO integration with platform MMC driver
******************************************************************************/
static void mtk_wcn_cmb_sdio_request_eirq(msdc_sdio_irq_handler_t irq_handler,
void *data);
static void mtk_wcn_cmb_sdio_enable_eirq(void);
static void mtk_wcn_cmb_sdio_disable_eirq(void);
static void mtk_wcn_cmb_sdio_register_pm(pm_callback_t pm_cb, void *data);
struct sdio_ops mt_sdio_ops[4] = {
{NULL, NULL, NULL, NULL},
{NULL, NULL, NULL, NULL},
{mtk_wcn_cmb_sdio_request_eirq, mtk_wcn_cmb_sdio_enable_eirq,
mtk_wcn_cmb_sdio_disable_eirq, mtk_wcn_cmb_sdio_register_pm},
{mtk_wcn_cmb_sdio_request_eirq, mtk_wcn_cmb_sdio_enable_eirq,
mtk_wcn_cmb_sdio_disable_eirq, mtk_wcn_cmb_sdio_register_pm}
};
static atomic_t sdio_claim_irq_enable_flag;
static atomic_t irq_enable_flag;
static msdc_sdio_irq_handler_t mtk_wcn_cmb_sdio_eirq_handler;
static void *mtk_wcn_cmb_sdio_eirq_data;
unsigned int wifi_irq = 0xffffffff;
EXPORT_SYMBOL(wifi_irq);
pm_callback_t mtk_wcn_cmb_sdio_pm_cb;
EXPORT_SYMBOL(mtk_wcn_cmb_sdio_pm_cb);
void *mtk_wcn_cmb_sdio_pm_data;
EXPORT_SYMBOL(mtk_wcn_cmb_sdio_pm_data);
static int _mtk_wcn_sdio_irq_flag_set(int flag)
{
if (flag != 0)
atomic_set(&sdio_claim_irq_enable_flag, 1);
else
atomic_set(&sdio_claim_irq_enable_flag, 0);
CONNADP_DBG_FUNC("sdio_claim_irq_enable_flag:%d\n",
atomic_read(&sdio_claim_irq_enable_flag));
return atomic_read(&sdio_claim_irq_enable_flag);
}
int wmt_export_mtk_wcn_sdio_irq_flag_set(int flag)
{
return _mtk_wcn_sdio_irq_flag_set(flag);
}
EXPORT_SYMBOL(wmt_export_mtk_wcn_sdio_irq_flag_set);
static irqreturn_t mtk_wcn_cmb_sdio_eirq_handler_stub(int irq, void *data)
{
if ((mtk_wcn_cmb_sdio_eirq_handler != NULL) &&
(atomic_read(&sdio_claim_irq_enable_flag) != 0))
mtk_wcn_cmb_sdio_eirq_handler(mtk_wcn_cmb_sdio_eirq_data);
return IRQ_HANDLED;
}
static void mtk_wcn_cmb_sdio_request_eirq(msdc_sdio_irq_handler_t irq_handler,
void *data)
{
#ifdef CONFIG_OF
struct device_node *node;
int ret = -EINVAL;
CONNADP_INFO_FUNC("enter\n");
_mtk_wcn_sdio_irq_flag_set(0);
atomic_set(&irq_enable_flag, 1);
mtk_wcn_cmb_sdio_eirq_data = data;
mtk_wcn_cmb_sdio_eirq_handler = irq_handler;
node = (struct device_node *)of_find_compatible_node(NULL, NULL,
"mediatek,connectivity-combo");
if (node) {
wifi_irq = irq_of_parse_and_map(node, 0);/* get wifi eint num */
ret = request_irq(wifi_irq, mtk_wcn_cmb_sdio_eirq_handler_stub,
IRQF_TRIGGER_LOW, "WIFI-eint", NULL);
CONNADP_DBG_FUNC("WIFI EINT irq %d !!\n", wifi_irq);
if (ret)
CONNADP_WARN_FUNC("WIFI EINT LINE NOT AVAILABLE!!\n");
else
mtk_wcn_cmb_sdio_disable_eirq();/*state:power off*/
} else
CONNADP_WARN_FUNC("can't find connectivity compatible node\n");
CONNADP_INFO_FUNC("exit\n");
#else
CONNADP_ERR_FUNC("not implemented\n");
#endif
}
static void mtk_wcn_cmb_sdio_register_pm(pm_callback_t pm_cb, void *data)
{
CONNADP_DBG_FUNC("cmb_sdio_register_pm (0x%p, 0x%p)\n", pm_cb, data);
/* register pm change callback */
mtk_wcn_cmb_sdio_pm_cb = pm_cb;
mtk_wcn_cmb_sdio_pm_data = data;
}
static void mtk_wcn_cmb_sdio_enable_eirq(void)
{
if (atomic_read(&irq_enable_flag))
CONNADP_DBG_FUNC("wifi eint has been enabled\n");
else {
atomic_set(&irq_enable_flag, 1);
if (wifi_irq != 0xfffffff) {
enable_irq(wifi_irq);
CONNADP_DBG_FUNC(" enable WIFI EINT %d!\n", wifi_irq);
}
}
}
static void mtk_wcn_cmb_sdio_disable_eirq(void)
{
if (!atomic_read(&irq_enable_flag))
CONNADP_DBG_FUNC("wifi eint has been disabled!\n");
else {
if (wifi_irq != 0xfffffff) {
disable_irq_nosync(wifi_irq);
CONNADP_DBG_FUNC("disable WIFI EINT %d!\n", wifi_irq);
}
atomic_set(&irq_enable_flag, 0);
}
}
void wmt_export_mtk_wcn_cmb_sdio_disable_eirq(void)
{
mtk_wcn_cmb_sdio_disable_eirq();
}
EXPORT_SYMBOL(wmt_export_mtk_wcn_cmb_sdio_disable_eirq);
@@ -0,0 +1,52 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef WMT_BUILD_IN_ADAPTER_H
#define WMT_BUILD_IN_ADAPTER_H
#include <mtk_wcn_cmb_stub.h>
#include <linux/types.h>
#include <linux/fs.h>
/*******************************************************************************
* Bridging from platform -> wmt_drv.ko
******************************************************************************/
typedef int (*wmt_bridge_thermal_query_cb)(void);
typedef int (*wmt_bridge_trigger_assert_cb)(void);
typedef void (*wmt_bridge_connsys_clock_fail_dump_cb)(void);
typedef int (*wmt_bridge_conninfra_reg_readable)(void);
typedef int (*wmt_bridge_conninfra_reg_is_bus_hang)(void);
typedef ssize_t (*wmt_bridge_debug_write_cb)(struct file *, const char __user *, size_t, loff_t *);
typedef ssize_t (*wmt_bridge_debug_read_cb)(struct file *, char __user *, size_t, loff_t *);
struct wmt_platform_bridge {
wmt_bridge_thermal_query_cb thermal_query_cb;
wmt_bridge_trigger_assert_cb trigger_assert_cb;
wmt_bridge_connsys_clock_fail_dump_cb clock_fail_dump_cb;
wmt_bridge_debug_write_cb debug_write_cb;
wmt_bridge_debug_read_cb debug_read_cb;
/* for CONNAC 2 */
wmt_bridge_conninfra_reg_readable conninfra_reg_readable_cb;
wmt_bridge_conninfra_reg_is_bus_hang conninfra_reg_is_bus_hang_cb;
};
void wmt_export_platform_bridge_register(struct wmt_platform_bridge *cb);
void wmt_export_platform_bridge_unregister(void);
/*******************************************************************************
* SDIO integration with platform MMC driver
******************************************************************************/
extern unsigned int wifi_irq;
extern pm_callback_t mtk_wcn_cmb_sdio_pm_cb;
extern void *mtk_wcn_cmb_sdio_pm_data;
void wmt_export_mtk_wcn_cmb_sdio_disable_eirq(void);
int wmt_export_mtk_wcn_sdio_irq_flag_set(int flag);
#endif /* WMT_BUILD_IN_ADAPTER_H */