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,8 @@
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/inc/
ccflags-y += -I$(srctree)/drivers/misc/mediatek/lpm/
obj-y += mtk_lpm_platform.o
obj-y += mtk_lpm_irqremain.o
obj-y += mtk_lpm_resource_ctrl.o
obj-y += mtk_lpm_rc.o
obj-y += mtk_lpm_trace.o
@@ -0,0 +1,292 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/list.h>
#include <linux/slab.h>
#if defined(CONFIG_MTK_GIC_V3_EXT)
#include <linux/irqchip/mtk-gic-extend.h>
#endif
#include <mtk_lpm_platform.h>
#include <mtk_lpm_module.h>
#include <mtk_lpm_internal.h>
#include "mtk_lpm_irqremain.h"
#define MTK_LPM_IRQREMAIN_NODE "irq-remain"
#define MTK_LPM_IRQREMAIN_LISTNODE "irq-remain-list"
#define MTK_LPM_IRQREMAIN_LIST_METHOD "method"
#define MTK_LPM_IRQREMAIN_TARGET "target"
#define MTK_LPM_IRQREMAIN_PROP "value"
#define FOR_EACH_IRQ_REMAIN(edges)\
list_for_each_entry(edges,\
&mtk_irqremain, list)
#define IRQ_REMAIN_FREE(_irq_remain) ({\
if (_irq_remain) {\
kfree(_irq_remain->irqs);\
kfree(_irq_remain->wakeup_src_cat);\
kfree(_irq_remain->wakeup_src);\
kfree(_irq_remain);\
} })
enum MTK_LPM_IRQREMAIN_TYPE {
MTK_LPM_IRQREMAIN_LIST,
MTK_LPM_IRQREMAIN_SMC,
};
struct mtk_lpm_irqremain_node {
unsigned int irq;
unsigned int wakeup_src_cat;
unsigned int wakeup_src;
struct list_head list;
};
static LIST_HEAD(mtk_irqremain);
#define PLAT_COVERT_IRQ_NUM(irq) virq_to_hwirq(irq)
#if !defined(CONFIG_MTK_GIC_V3_EXT)
static inline unsigned int virq_to_hwirq(unsigned int virq)
{
struct irq_desc *desc;
unsigned int hwirq;
desc = irq_to_desc(virq);
WARN_ON(!desc);
hwirq = desc ? desc->irq_data.hwirq : 0;
return hwirq;
}
#endif
void mtk_lpm_irqremain_list_release(void)
{
unsigned long flag;
struct mtk_lpm_irqremain_node *cur;
struct mtk_lpm_irqremain_node *next;
if (list_empty(&mtk_irqremain))
return;
mtk_lpm_system_lock(flag);
cur = list_first_entry(&mtk_irqremain,
struct mtk_lpm_irqremain_node,
list);
do {
if (list_is_last(&cur->list, &mtk_irqremain))
next = NULL;
else
next = list_next_entry(cur, list);
list_del(&cur->list);
kfree(cur);
cur = next;
} while (cur);
INIT_LIST_HEAD(&mtk_irqremain);
mtk_lpm_system_unlock(flag);
}
EXPORT_SYMBOL(mtk_lpm_irqremain_list_release);
int mtk_lpm_irqremain_get(struct mtk_lpm_irqremain **irq)
{
unsigned long flag;
size_t count = 0;
struct mtk_lpm_irqremain_node *irqnode;
struct mtk_lpm_irqremain *tar;
if (!irq)
return -EINVAL;
if (list_empty(&mtk_irqremain))
return -EPERM;
mtk_lpm_system_lock(flag);
FOR_EACH_IRQ_REMAIN(irqnode)
count++;
*irq = NULL;
tar = kcalloc(1, sizeof(**irq), GFP_KERNEL);
if (!tar)
goto mtk_lpm_irqremain_release;
tar->irqs = tar->wakeup_src_cat = tar->wakeup_src = NULL;
tar->irqs = kcalloc(count,
sizeof(*tar->irqs), GFP_KERNEL);
if (!tar->irqs)
goto mtk_lpm_irqremain_release;
tar->wakeup_src_cat = kcalloc(count,
sizeof(*tar->wakeup_src_cat), GFP_KERNEL);
if (!tar->wakeup_src_cat)
goto mtk_lpm_irqremain_release;
tar->wakeup_src = kcalloc(count,
sizeof(*tar->wakeup_src), GFP_KERNEL);
if (!tar->wakeup_src)
goto mtk_lpm_irqremain_release;
tar->count = count;
count = 0;
FOR_EACH_IRQ_REMAIN(irqnode) {
tar->irqs[count] = irqnode->irq;
tar->wakeup_src_cat[count] = irqnode->wakeup_src_cat;
tar->wakeup_src[count] = irqnode->wakeup_src;
count++;
}
*irq = tar;
mtk_lpm_system_unlock(flag);
return 0;
mtk_lpm_irqremain_release:
IRQ_REMAIN_FREE(tar);
mtk_lpm_system_unlock(flag);
return -ENOMEM;
}
EXPORT_SYMBOL(mtk_lpm_irqremain_get);
void mtk_lpm_irqremain_put(struct mtk_lpm_irqremain *irqs)
{
IRQ_REMAIN_FREE(irqs);
}
EXPORT_SYMBOL(mtk_lpm_irqremain_put);
int __init mtk_lpm_irqremain_parsing(struct device_node *parent)
{
int ret = 0, idx = 0, irqnum;
u32 irqidx = 0, irqtype, irq_do = 0;
u32 wakeup_src = 0, wakeup_src_cat = 0;
int remain_count = 0;
struct mtk_lpm_irqremain_node *irqnode;
const __be32 *next = NULL;
struct property *prop;
struct device_node *np = NULL;
struct device_node *tar_np = NULL;
while ((np = of_parse_phandle(parent, MTK_LPM_IRQREMAIN_NODE, idx))) {
idx++;
next = NULL;
tar_np = of_parse_phandle(np, MTK_LPM_IRQREMAIN_TARGET, 0);
prop = of_find_property(np, MTK_LPM_IRQREMAIN_PROP, NULL);
do {
if (!prop || !tar_np)
break;
next = of_prop_next_u32(prop, next, &irq_do);
if (!next)
break;
next = of_prop_next_u32(prop, next, &irqidx);
if (!next)
break;
next = of_prop_next_u32(prop, next, &wakeup_src_cat);
if (!next)
break;
next = of_prop_next_u32(prop, next, &wakeup_src);
if (!next)
break;
irqnum = of_irq_get(tar_np, irqidx);
irqtype = irq_get_trigger_type(irqnum);
if (!(irqtype & IRQ_TYPE_EDGE_BOTH))
pr_info("[name:mtk_lpm][P] - %pOF irq(%d) type = 0x%x ?\n",
tar_np, irqidx, irqtype);
if (irq_do) {
irq_set_irq_type(irqnum, irqtype);
pr_info("[name:mtk_lpm][P] - %pOF set irq(%d) as type = 0x%x\n",
tar_np, irqidx, irqtype);
}
if (irqnum >= 0) {
irqnode = kcalloc(1, sizeof(*irqnode),
GFP_KERNEL);
if (irqnode) {
irqnode->irq =
PLAT_COVERT_IRQ_NUM(irqnum);
irqnode->wakeup_src_cat =
wakeup_src_cat;
irqnode->wakeup_src =
wakeup_src;
list_add(&irqnode->list,
&mtk_irqremain);
pr_info("[name:mtk_lpm][P] - irq_%u, wakeup-src=0x%x (%pOF) (%s:%d)\n",
irqnode->irq,
irqnode->wakeup_src,
tar_np,
__func__, __LINE__);
remain_count++;
}
} else
pr_info("[name:mtk_lpm][P] - invalid irq, erro=%d (%s:%d)\n",
irqnum, __func__, __LINE__);
} while (1);
if (tar_np)
of_node_put(tar_np);
of_node_put(np);
}
mtk_lpm_smc_cpu_pm(IRQ_REMAIN_LIST_ALLOC, remain_count, 0, 0);
mtk_lpm_smc_cpu_pm_lp(IRQS_REMAIN_ALLOC, MT_LPM_SMC_ACT_SET,
remain_count, 0);
remain_count = 0;
FOR_EACH_IRQ_REMAIN(irqnode) {
mtk_lpm_smc_cpu_pm(IRQ_REMAIN_IRQ_ADD,
irqnode->irq,
irqnode->wakeup_src_cat,
irqnode->wakeup_src);
mtk_lpm_smc_cpu_pm_lp(IRQS_REMAIN_IRQ,
MT_LPM_SMC_ACT_SET,
irqnode->irq, 0);
mtk_lpm_smc_cpu_pm_lp(IRQS_REMAIN_WAKEUP_CAT,
MT_LPM_SMC_ACT_SET,
irqnode->wakeup_src_cat, 0);
mtk_lpm_smc_cpu_pm_lp(IRQS_REMAIN_WAKEUP_SRC,
MT_LPM_SMC_ACT_SET,
irqnode->wakeup_src, 0);
mtk_lpm_smc_cpu_pm_lp(IRQS_REMAIN_CTRL,
MT_LPM_SMC_ACT_PUSH, 0, 0);
remain_count++;
}
mtk_lpm_smc_cpu_pm(IRQ_REMAIN_IRQ_SUBMIT, 0, 0, 0);
mtk_lpm_smc_cpu_pm_lp(IRQS_REMAIN_CTRL,
MT_LPM_SMC_ACT_SUBMIT, 0, 0);
return ret;
}
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_LPM_IRQREMAIN_H__
#define __MTK_LPM_IRQREMAIN_H__
int mtk_lpm_irqremain_parsing(struct device_node *parent);
#endif
@@ -0,0 +1,39 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/of.h>
#include <mtk_lpm.h>
#include <mtk_lpm_irqremain.h>
#include <mtk_lpm_resource_ctrl.h>
#include <mtk_lpm_rc.h>
#include <mtk_lpm_trace.h>
int mtk_lpm_platform_trace_get(int type, struct MTK_LPM_PLAT_TRACE *trace)
{
return mtk_lpm_trace_instance_get(type, trace);
}
static int __init mtk_lpm_platform(void)
{
struct device_node *devnp;
devnp = of_find_compatible_node(NULL, NULL,
MTK_LPM_DTS_COMPATIBLE);
if (devnp) {
mtk_lpm_irqremain_parsing(devnp);
mtk_lpm_resource_ctrl_parsing(devnp);
mtk_lpm_rc_parsing(devnp);
mtk_lpm_trace_parsing(devnp);
of_node_put(devnp);
}
return 0;
}
device_initcall(mtk_lpm_platform);
@@ -0,0 +1,44 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <mtk_lpm_platform.h>
#include <mtk_lpm_module.h>
#include <mtk_lpm_internal.h>
#include "mtk_lpm_resource_ctrl.h"
#define MTK_LPM_RC_NODE "constraints"
#define MTK_LPM_RC_LISTNODE "constraint-list"
#define MTK_LPM_RC_ID "id"
#define MTK_LPM_RC_VALUE "value"
int __init mtk_lpm_rc_parsing(struct device_node *parent)
{
int ret = 0, idx = 0;
u32 value = 0, id = 0;
struct device_node *np = NULL;
while ((np = of_parse_phandle(parent, MTK_LPM_RC_NODE, idx))) {
idx++;
of_property_read_u32(np, MTK_LPM_RC_ID, &id);
of_property_read_u32(np, MTK_LPM_RC_VALUE, &value);
of_node_put(np);
if (!!value)
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_DOE_RC,
MT_LPM_SMC_ACT_SET, id, 0);
else
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_DOE_RC,
MT_LPM_SMC_ACT_CLR, id, 0);
}
return ret;
}
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_LPM_RC_H__
#define __MTK_LPM_RC_H__
int mtk_lpm_rc_parsing(struct device_node *parent);
#endif
@@ -0,0 +1,40 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <mtk_lpm_platform.h>
#include <mtk_lpm_module.h>
#include <mtk_lpm_internal.h>
#include "mtk_lpm_resource_ctrl.h"
#define MTK_LPM_RESOURCE_NODE "resource-ctrl"
#define MTK_LPM_RESOURCE_LISTNODE "resource-ctrl-list"
#define MTK_LPM_RESOURCE_ID "id"
#define MTK_LPM_RESOURCE_VALUE "value"
int __init mtk_lpm_resource_ctrl_parsing(struct device_node *parent)
{
int ret = 0, idx = 0;
u32 value = 0, id = 0;
struct device_node *np = NULL;
while ((np = of_parse_phandle(parent, MTK_LPM_RESOURCE_NODE, idx))) {
idx++;
of_property_read_u32(np, MTK_LPM_RESOURCE_ID, &id);
of_property_read_u32(np, MTK_LPM_RESOURCE_VALUE, &value);
of_node_put(np);
mtk_lpm_smc_spm_dbg(MT_SPM_DBG_SMC_UID_DOE_RESOURCE_CTRL,
MT_LPM_SMC_ACT_SET, id, value);
}
return ret;
}
@@ -0,0 +1,11 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_LPM_RESOURCE_CTRL_H__
#define __MTK_LPM_RESOURCE_CTRL_H__
int mtk_lpm_resource_ctrl_parsing(struct device_node *parent);
#endif
@@ -0,0 +1,102 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <mtk_lpm_module.h>
#include <mtk_lpm_internal.h>
#include <mtk_lpm_trace.h>
#define MTK_LPM_TRACE_SYSRAM_MEMCPY_DEST(_offset, _buf, _sz) ({\
memcpy(buf, (void *)(mtk_lpm_trace_ins.mmu + _offset),\
_sz); })
#define MTK_LPM_TRACE_SYSRAM_MEMCPY_SRC(_offset, _buf, _sz) ({\
memcpy((void *)(mtk_lpm_trace_ins.mmu + _offset), buf,\
_sz); })
struct MTK_LPM_TRACE_INS {
void __iomem *mmu;
size_t size;
};
static struct MTK_LPM_TRACE_INS mtk_lpm_trace_ins;
int __init mtk_lpm_trace_parsing(struct device_node *parent)
{
struct device_node *node;
if (!parent)
return -EINVAL;
node = of_find_compatible_node(parent, NULL,
"mediatek,lpm-sysram");
if (node) {
struct resource res;
if (!of_address_to_resource(node, 0, &res)) {
mtk_lpm_trace_ins.size = (size_t)resource_size(&res);
mtk_lpm_trace_ins.mmu = ioremap(res.start,
resource_size(&res));
}
of_node_put(node);
}
return 0;
}
size_t mtk_lpm_trace_sysram_read(unsigned long offset,
void *buf, size_t sz)
{
size_t rSz = 0;
if ((offset >= mtk_lpm_trace_ins.size)
|| !mtk_lpm_trace_ins.mmu)
return -EINVAL;
rSz = ((offset + sz) < mtk_lpm_trace_ins.size) ?
sz : (mtk_lpm_trace_ins.size - offset);
MTK_LPM_TRACE_SYSRAM_MEMCPY_DEST(offset, buf, rSz);
return rSz;
}
size_t mtk_lpm_trace_sysram_wrtie(unsigned long offset,
const void *buf, size_t sz)
{
size_t rSz = 0;
if ((offset >= mtk_lpm_trace_ins.size)
|| !mtk_lpm_trace_ins.mmu)
return -EINVAL;
rSz = ((offset + sz) < mtk_lpm_trace_ins.size) ?
sz : (mtk_lpm_trace_ins.size - offset);
MTK_LPM_TRACE_SYSRAM_MEMCPY_SRC(offset, buf, rSz);
return 0;
}
int mtk_lpm_trace_instance_get(int type, struct MTK_LPM_PLAT_TRACE *ins)
{
int ret = 0;
if (!ins)
return -EINVAL;
if (type == MT_LPM_PLAT_TRACE_SYSRAM) {
ins->read = mtk_lpm_trace_sysram_read;
ins->write = mtk_lpm_trace_sysram_wrtie;
} else
ret = -EINVAL;
return ret;
}
@@ -0,0 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __MTK_LPM_TRACE_H__
#define __MTK_LPM_TRACE_H__
#include <mtk_lpm_platform.h>
int mtk_lpm_trace_parsing(struct device_node *parent);
int mtk_lpm_trace_instance_get(int type, struct MTK_LPM_PLAT_TRACE *ins);
#endif