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,6 @@
obj-y += lastbus.o
ifeq ($(CONFIG_MACH_MT6781),y)
obj-y += mt6781/
else
obj-y += $(subst ",,$(CONFIG_MTK_PLATFORM))/
endif
@@ -0,0 +1,217 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/printk.h>
#include <linux/platform_device.h>
#include <linux/of_address.h>
#include <linux/io.h>
#include "lastbus.h"
struct plt_cfg_bus_latch *lastbus_ctrl;
static int lastbus_probe(struct platform_device *pdev);
#define NUM_INFRA_EVENT_REG (lastbus_ctrl->num_infra_event_reg)
#define NUM_PERI_EVENT_REG (lastbus_ctrl->num_peri_event_reg)
int lastbus_setup(struct plt_cfg_bus_latch *p)
{
lastbus_ctrl = p;
return 0;
}
static const struct of_device_id lastbus_of_ids[] = {
{ .compatible = "mediatek,lastbus-v1", },
{}
};
static struct platform_driver lastbus_drv = {
.driver = {
.name = "lastbus",
.bus = &platform_bus_type,
.owner = THIS_MODULE,
.of_match_table = lastbus_of_ids,
},
.probe = lastbus_probe,
};
static ssize_t lastbus_dump_show(struct device_driver *driver, char *buf)
{
unsigned int wp = 0;
if (lastbus_ctrl->perisys_ops.dump)
wp += lastbus_ctrl->perisys_ops.dump(lastbus_ctrl, buf, &wp);
if (lastbus_ctrl->infrasys_ops.dump)
wp += lastbus_ctrl->infrasys_ops.dump(lastbus_ctrl, buf, &wp);
return strlen(buf);
}
DRIVER_ATTR_RO(lastbus_dump);
static ssize_t
infra_event_store(struct device_driver *driver, const char *buf, size_t count)
{
int ret = 0;
if (lastbus_ctrl->infrasys_ops.set_event)
ret = lastbus_ctrl->infrasys_ops.set_event(lastbus_ctrl, buf);
if (ret < 0)
pr_notice("lastbus: peri-event set error\n");
return count;
}
static ssize_t infra_event_show(struct device_driver *driver, char *buf)
{
ssize_t len = 0;
if (lastbus_ctrl->infrasys_ops.get_event)
len = lastbus_ctrl->infrasys_ops.get_event(lastbus_ctrl, buf);
if (len < 0)
pr_notice("lastbus: peri-event get event error\n");
return len;
}
DRIVER_ATTR_RW(infra_event);
static ssize_t
lastbus_timeout_store(struct device_driver *driver,
const char *buf, size_t count)
{
int ret = 0;
if (lastbus_ctrl->infrasys_ops.set_timeout)
ret = lastbus_ctrl->infrasys_ops.set_timeout(lastbus_ctrl, buf);
if (ret < 0)
pr_notice("lastbus: set timeout error\n");
return count;
}
static ssize_t lastbus_timeout_show(struct device_driver *driver, char *buf)
{
ssize_t len = 0;
if (lastbus_ctrl->infrasys_ops.get_timeout)
len = lastbus_ctrl->infrasys_ops.get_timeout(lastbus_ctrl, buf);
if (len < 0)
pr_notice("lastbus: get timeout error\n");
return len;
}
DRIVER_ATTR_RW(lastbus_timeout);
static ssize_t
peri_event_store(struct device_driver *driver,
const char *buf, size_t count)
{
int ret = 0;
if (lastbus_ctrl->perisys_ops.set_event)
ret = lastbus_ctrl->perisys_ops.set_event(lastbus_ctrl, buf);
if (ret < 0)
pr_notice("lastbus: peri-event set error\n");
return count;
}
static ssize_t peri_event_show(struct device_driver *driver, char *buf)
{
int len = 0;
if (lastbus_ctrl->perisys_ops.get_event)
len = lastbus_ctrl->perisys_ops.get_event(lastbus_ctrl, buf);
if (len < 0)
pr_notice("lastbus: peri-event get event error\n");
return len;
}
DRIVER_ATTR_RW(peri_event);
static int lastbus_probe(struct platform_device *pdev)
{
int ret = 0;
pr_debug("%s:%d: enter\n", __func__, __LINE__);
if (lastbus_ctrl->init)
lastbus_ctrl->init(lastbus_ctrl);
else {
lastbus_ctrl->infra_base = of_iomap(pdev->dev.of_node, 0);
if (!lastbus_ctrl->infra_base) {
pr_info("can't of_iomap for infra lastbus!!\n");
return -ENOMEM;
}
lastbus_ctrl->peri_base = of_iomap(pdev->dev.of_node, 1);
if (!lastbus_ctrl->peri_base) {
pr_info("can't of_iomap for peri lastbus!!\n");
return -ENOMEM;
}
lastbus_ctrl->spm_flag_base = of_iomap(pdev->dev.of_node, 2);
if (!lastbus_ctrl->peri_base) {
pr_info("can't of_iomap for peri lastbus!!\n");
return -ENOMEM;
}
}
ret = driver_create_file(&lastbus_drv.driver,
&driver_attr_lastbus_dump);
ret |= driver_create_file(&lastbus_drv.driver,
&driver_attr_infra_event);
ret |= driver_create_file(&lastbus_drv.driver,
&driver_attr_peri_event);
ret |= driver_create_file(&lastbus_drv.driver,
&driver_attr_lastbus_timeout);
if (ret)
pr_info("last bus create file failed\n");
return 0;
}
static int __init lastbus_init(void)
{
int err = 0;
if (lastbus_ctrl == NULL) {
pr_notice("kernel lastbus dump not support");
return -1;
}
err = platform_driver_register(&lastbus_drv);
if (err)
return err;
return 0;
}
late_initcall_sync(lastbus_init);
@@ -0,0 +1,62 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef _LASTBUS_H__
#define _LASTBUS_H__
#include <linux/sizes.h>
#include <linux/io.h>
#define LATCH_BUF_LENGTH SZ_4K
struct lastbus_perisys_offsets {
unsigned int bus_peri_r0;
unsigned int bus_peri_r1;
unsigned int bus_peri_mon;
};
struct lastbus_infrasys_offsets {
unsigned int bus_infra_ctrl;
unsigned int bus_infra_mask_l;
unsigned int bus_infra_mask_h;
unsigned int bus_infra_snapshot;
};
struct plt_cfg_bus_latch;
struct lastbus_ops {
int (*init)(const struct plt_cfg_bus_latch *self);
int (*is_timeout)(const struct plt_cfg_bus_latch *self);
int (*dump)(const struct plt_cfg_bus_latch *self, char *buf, int *wp);
int (*set_event)(const struct plt_cfg_bus_latch *self,
const char *buf);
int (*get_event)(const struct plt_cfg_bus_latch *self, char *buf);
int (*set_timeout)(const struct plt_cfg_bus_latch *self,
const char *buf);
int (*get_timeout)(const struct plt_cfg_bus_latch *self, char *buf);
};
struct plt_cfg_bus_latch {
unsigned int supported;
unsigned int num_perisys_mon;
unsigned int num_infrasys_mon;
unsigned int num_infra_event_reg;
unsigned int num_peri_event_reg;
unsigned int secure_perisys;
unsigned int perisys_enable;
unsigned int perisys_timeout;
unsigned int perisys_eventmask;
unsigned int infrasys_enable;
unsigned int infrasys_config;
struct lastbus_ops perisys_ops;
struct lastbus_ops infrasys_ops;
void __iomem *peri_base;
void __iomem *infra_base;
void __iomem *spm_flag_base;
struct lastbus_perisys_offsets perisys_offsets;
struct lastbus_infrasys_offsets infrasys_offsets;
int (*init)(const struct plt_cfg_bus_latch *self);
};
int lastbus_setup(struct plt_cfg_bus_latch *p);
#endif
@@ -0,0 +1 @@
obj-y += plat_lastbus.o
@@ -0,0 +1,296 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "./../lastbus.h"
#include "plat_lastbus.h"
#include <linux/seqlock.h>
#include <linux/irqflags.h>
static DEFINE_SPINLOCK(lastbus_spin_lock);
/*
* Usage: echo 0 0 {infra} {peri} >
* /sys/bus/platform/drivers/lastbus/lastbus_timeout
*/
int infra_set_timeout(const struct plt_cfg_bus_latch *self, const char *buf)
{
int i;
char *arg;
char *p = (char *)buf;
unsigned long input;
unsigned int settings[4];
unsigned int infra_timeout;
unsigned int peri_timeout;
for (i = 0; i < 4; i++) {
arg = strsep(&p, " ");
if (arg == NULL)
return -EINVAL;
if (kstrtoul(arg, 16, &input) != 0) {
pr_info("%s:%d: kstrtoul fail for %s\n",
__func__, __LINE__, p);
return -1;
}
settings[i] = (unsigned int)input;
}
infra_timeout = readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl) & ~(0xffff);
infra_timeout |= settings[2];
writel(infra_timeout, self->infra_base +
self->infrasys_offsets.bus_infra_ctrl);
peri_timeout = readl(self->peri_base +
self->perisys_offsets.bus_peri_r0) & ~0xffff;
peri_timeout |= settings[3];
writel(peri_timeout, self->peri_base +
self->perisys_offsets.bus_peri_r0);
return 0;
}
int infra_get_timeout(const struct plt_cfg_bus_latch *self, char *buf)
{
return snprintf(buf, PAGE_SIZE,
"infra_config=0x%x, peri_config=0x%x\n",
readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl),
readl(self->peri_base +
self->perisys_offsets.bus_peri_r0));
}
int infra_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *infra_base = self->infra_base;
unsigned int ctrl;
if (self->num_infrasys_mon != 0) {
ctrl = readl(infra_base +
self->infrasys_offsets.bus_infra_ctrl);
if (ctrl & 0x1) {
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS BUS DUMP:\n");
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS_CTRL = %04x\n", ctrl);
for (i = 0; i <= self->num_infrasys_mon-1; ++i)
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"INFRA SNAPSHOT%d = %04x\n",
i, readl(infra_base +
self->infrasys_offsets.bus_infra_snapshot
+ 4*i));
} else {
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS NO TIMEOUT\n");
}
}
return 0;
}
static unsigned long preisys_dump_offset[] = {
0x500, /* PERIBUS_DBG0 */
0x504, /* PERIBUS_DBG1 */
0x508, /* PERIBUS_DBG2 */
0x50C, /* PERIBUS_DBG3 */
0x510, /* PERIBUS_DBG4 */
0x514, /* PERIBUS_DBG5 */
0x518, /* PERIBUS_DBG6 */
0x51C, /* PERIBUS_DBG7 */
0x520, /* PERIBUS_DBG8 */
0x524, /* PERIBUS_DBG9 */
0x528, /* PERIBUS_DBG10 */
0x52C, /* PERIBUS_DBG11 */
0x530, /* PERIBUS_DBG12 */
0x534, /* PERIBUS_DBG13 */
0x538, /* PERIBUS_DBG14 */
0x53C, /* PERIBUS_DBG15 */
0x580, /* PERIBUS_DBG16 */
0x584, /* PERIBUS_DBG17 */
};
int peri_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *peri_base = self->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] PERISYS BUS DUMP:\n");
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"PERIBUS_DBG%d(%p) = %04x\n",
i, reg, data);
}
return 0;
}
struct plt_cfg_bus_latch cfg_bus_latch = {
.supported = 1,
.num_perisys_mon = 18,
.num_infrasys_mon = 17,
.perisys_offsets = {
.bus_peri_r0 = 0x0500,
.bus_peri_r1 = 0x0504,
.bus_peri_mon = 0x0500,
},
.infrasys_offsets = {
.bus_infra_ctrl = 0x0d04,
.bus_infra_snapshot = 0x0d00,
},
.perisys_ops = {
.dump = peri_dump,
},
.infrasys_ops = {
.dump = infra_dump,
.set_timeout = infra_set_timeout,
.get_timeout = infra_get_timeout,
},
};
struct plt_cfg_bus_latch *lb = &cfg_bus_latch;
int infra_timeout_dump(void)
{
unsigned int i;
void __iomem *infra_base = lb->infra_base;
pr_info("[LAST BUS] PERISYS BUS & INFRA BUS DUMP:\n");
pr_info("%08x\n", readl(infra_base +
lb->infrasys_offsets.bus_infra_ctrl));
if (lb->num_infrasys_mon != 0) {
for (i = 0; i <= lb->num_infrasys_mon-1; ++i)
pr_info("%08x\n",
readl(infra_base +
lb->infrasys_offsets.bus_infra_snapshot
+ 4*i));
}
return 0;
}
int peri_timeout_dump(void)
{
unsigned int i;
void __iomem *peri_base = lb->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
/* peribus_dbg_in_0 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r0));
/* peribus_dbg_in_1 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r1));
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
pr_info("%08x\n", data);
}
return 0;
}
int is_infra_timeout(void)
{
int ctrl = 0;
if (!lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return 0;
}
ctrl = (readl(lb->infra_base +
lb->infrasys_offsets.bus_infra_ctrl)) & 0x1;
return ctrl;
}
int is_peri_timeout(void)
{
int ctrl = 0;
if (!lb->peri_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return 0;
}
ctrl = (readl(lb->peri_base +
lb->perisys_offsets.bus_peri_r1)) & 0x1;
return ctrl;
}
void reset_infra(void)
{
writel(0x8, lb->infra_base + lb->infrasys_offsets.bus_infra_ctrl);
writel(0xffff000c,
lb->infra_base + lb->infrasys_offsets.bus_infra_ctrl);
}
void reset_peri(void)
{
writel(0x0, lb->peri_base + lb->perisys_offsets.bus_peri_r0);
writel(0x8, lb->peri_base + lb->perisys_offsets.bus_peri_r1);
writel(0x3fff, lb->peri_base + lb->perisys_offsets.bus_peri_r0);
writel(0xc, lb->peri_base + lb->perisys_offsets.bus_peri_r1);
}
int lastbus_timeout_dump(void)
{
int infra = 0, peri = 0;
unsigned long flags;
spin_lock_irqsave(&lastbus_spin_lock, flags);
if (!lb->peri_base || !lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return -1;
}
infra = is_infra_timeout();
peri = is_peri_timeout();
if (infra | peri) {
infra_timeout_dump();
peri_timeout_dump();
reset_infra();
reset_peri();
}
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return infra | peri;
}
static int __init plt_lastbus_init(void)
{
lastbus_setup(&cfg_bus_latch);
return 0;
}
late_initcall(plt_lastbus_init);
@@ -0,0 +1,17 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PLAT_LAST_BUS_H__
#define __PLAT_LAST_BUS_H__
#define PLAT_NUM_INFRA_EVENT_REG 2
#define PLAT_NUM_PERI_EVENT_REG 1
/*
* [31:16]peri,[15:0]infra
*/
#define FLAG_26 0xE24
#define FLAG_133 0xE34
#endif
@@ -0,0 +1 @@
obj-y += plat_lastbus.o
@@ -0,0 +1,395 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#include "./../lastbus.h"
#include "plat_lastbus.h"
#include <linux/seqlock.h>
#include <linux/irqflags.h>
static DEFINE_SPINLOCK(lastbus_spin_lock);
int infra_set_event(const struct plt_cfg_bus_latch *self, const char *buf)
{
int i;
char *arg;
char *p = (char *)buf;
unsigned long input;
unsigned int settings[PLAT_NUM_INFRA_EVENT_REG];
for (i = 0; i < self->num_infra_event_reg; i++) {
arg = strsep(&p, " ");
if (arg == NULL)
return -EINVAL;
if (kstrtoul(arg, 16, &input) != 0) {
pr_info("%s:%d: kstrtoul fail for %s\n",
__func__, __LINE__, p);
return -1;
}
settings[i] = (unsigned int)input;
}
writel(settings[0],
self->infra_base + self->infrasys_offsets.bus_infra_mask_l);
writel(settings[1],
self->infra_base + self->infrasys_offsets.bus_infra_mask_h);
return 0;
}
int infra_get_event(const struct plt_cfg_bus_latch *self, char *buf)
{
int ret;
ret = snprintf(buf, PAGE_SIZE,
"INFRA_MASKL = 0x%x, INFRA_MASKH = 0x%x\n",
readl(self->infra_base +
self->infrasys_offsets.bus_infra_mask_l),
readl(self->infra_base +
self->infrasys_offsets.bus_infra_mask_h));
return ret;
}
int infra_set_timeout(const struct plt_cfg_bus_latch *self, const char *buf)
{
int i;
char *arg;
char *p = (char *)buf;
unsigned long input;
unsigned int settings[4];
unsigned int infra_timeout;
unsigned int peri_timeout;
for (i = 0; i < 4; i++) {
arg = strsep(&p, " ");
if (arg == NULL)
return -EINVAL;
if (kstrtoul(arg, 16, &input) != 0) {
pr_info("%s:%d: kstrtoul fail for %s\n",
__func__, __LINE__, p);
return -1;
}
settings[i] = (unsigned int)input;
}
infra_timeout = readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl) & ~(0xffff);
infra_timeout = infra_timeout | settings[2];
writel(infra_timeout, self->infra_base +
self->infrasys_offsets.bus_infra_ctrl);
peri_timeout = readl(self->peri_base +
self->perisys_offsets.bus_peri_r0) & ~0xffff;
peri_timeout = peri_timeout | settings[3];
writel(peri_timeout, self->peri_base +
self->perisys_offsets.bus_peri_r0);
return 0;
}
int infra_get_timeout(const struct plt_cfg_bus_latch *self, char *buf)
{
return snprintf(buf, PAGE_SIZE,
"infra_config=0x%x, peri_config=0x%x\n",
readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl),
readl(self->peri_base +
self->perisys_offsets.bus_peri_r0));
}
int peri_set_event(const struct plt_cfg_bus_latch *self, const char *buf)
{
char *p = (char *)buf;
unsigned long input;
if (kstrtoul(p, 16, &input) != 0) {
pr_info("%s:%d: kstrtoul fail for %s\n",
__func__, __LINE__, p);
return -1;
}
writel(input, self->peri_base +
self->perisys_offsets.bus_peri_r1);
return 0;
}
int peri_get_event(const struct plt_cfg_bus_latch *self, char *buf)
{
int ret;
ret = snprintf(buf, PAGE_SIZE, "PERI_MASK = 0x%x\n",
readl(self->peri_base +
self->perisys_offsets.bus_peri_r1));
return ret;
}
int infra_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *infra_base = self->infra_base;
unsigned int ctrl;
if (self->num_infrasys_mon != 0) {
ctrl = readl(infra_base +
self->infrasys_offsets.bus_infra_ctrl);
if (ctrl & 0xFF000000) {
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS TIMEOUT:\n");
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS_CTRL = %04x\n", ctrl);
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS_MASKL = %04x\n",
readl(infra_base +
self->infrasys_offsets.bus_infra_ctrl));
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS_MASKH = %04x\n",
readl(infra_base +
self->infrasys_offsets.bus_infra_ctrl));
for (i = 0; i <= self->num_infrasys_mon-1; ++i)
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"INFRA SNAPSHOT%d = %04x\n",
i, readl(infra_base +
self->infrasys_offsets.bus_infra_snapshot
+ 4*i));
} else {
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS NO TIMEOUT:\n");
}
}
return 0;
}
static unsigned long preisys_dump_offset[] = {
0x508, /* PERIBUS_DBG0 */
0x50c, /* PERIBUS_DBG1 */
0x510, /* PERIBUS_DBG2 */
0x514, /* PERIBUS_DBG3 */
0x518, /* PERIBUS_DBG4 */
0x51c, /* PERIBUS_DBG5 */
0x520, /* PERIBUS_DBG6 */
0x524, /* PERIBUS_DBG7 */
0x528, /* PERIBUS_DBG8 */
0x52c, /* PERIBUS_DBG9 */
0x530, /* PERIBUS_DBG10 */
0x534, /* PERIBUS_DBG11 */
0x538, /* PERIBUS_DBG12 */
0x53c, /* PERIBUS_DBG13 */
0x580, /* PERIBUS_DBG14 */
0x584, /* PERIBUS_DBG15 */
0x588, /* PERIBUS_DBG16 */
0x58c, /* PERIBUS_DBG17 */
0x590, /* PERIBUS_DBG18 */
0x594, /* PERIBUS_DBG19 */
0x598, /* PERIBUS_DBG20 */
};
int peri_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *peri_base = self->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] PERISYS BUS DUMP:\n");
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"PERIBUS_DBG%d(%p) = %04x\n",
i, reg, data);
}
return 0;
}
struct plt_cfg_bus_latch cfg_bus_latch = {
.supported = 1,
.num_perisys_mon = 21,
.num_infrasys_mon = 48,
.num_infra_event_reg = PLAT_NUM_INFRA_EVENT_REG,
.num_peri_event_reg = PLAT_NUM_PERI_EVENT_REG,
.perisys_offsets = {
.bus_peri_r0 = 0x0500,
.bus_peri_r1 = 0x0504,
.bus_peri_mon = 0x0508,
},
.infrasys_offsets = {
.bus_infra_ctrl = 0x0d04,
.bus_infra_mask_l = 0x0d00,
.bus_infra_mask_h = 0x0df0,
.bus_infra_snapshot = 0x0d08,
},
.perisys_ops = {
.dump = peri_dump,
.set_event = peri_set_event,
.get_event = peri_get_event,
},
.infrasys_ops = {
.dump = infra_dump,
.set_event = infra_set_event,
.get_event = infra_get_event,
.set_timeout = infra_set_timeout,
.get_timeout = infra_get_timeout,
},
};
struct plt_cfg_bus_latch *lb = &cfg_bus_latch;
int infra_timeout_dump(void)
{
unsigned int i;
void __iomem *infra_base = lb->infra_base;
pr_info("[LAST BUS] PERISYS BUS & INFRA BUS DUMP:\n");
/* infrabus_dbg_in_0 */
pr_info("%08x\n", readl(infra_base +
lb->infrasys_offsets.bus_infra_mask_l));
/* infrabus_dbg_mask_2 */
pr_info("%08x\n", readl(infra_base +
lb->infrasys_offsets.bus_infra_mask_h));
/* infrabus_dbg_in_1 */
pr_info("%08x\n", readl(infra_base +
lb->infrasys_offsets.bus_infra_ctrl));
if (lb->num_infrasys_mon != 0) {
for (i = 0; i <= lb->num_infrasys_mon-1; ++i)
pr_info("%08x\n",
readl(infra_base +
lb->infrasys_offsets.bus_infra_snapshot
+ 4*i));
}
return 0;
}
int peri_timeout_dump(void)
{
unsigned int i;
void __iomem *peri_base = lb->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
/* peribus_dbg_in_0 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r0));
/* peribus_dbg_in_1 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r1));
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
pr_info("%08x\n", data);
}
return 0;
}
int is_infra_timeout(void)
{
int ctrl = 0;
if (!lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return 0;
}
ctrl = readl(lb->infra_base +
lb->infrasys_offsets.bus_infra_ctrl);
return ctrl & 0x1;
}
int is_peri_timeout(void)
{
int ctrl = 0;
if (!lb->peri_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return 0;
}
ctrl = readl(lb->peri_base +
lb->perisys_offsets.bus_peri_r1);
return ctrl & 0x1;
}
void reset_infra(void)
{
writel(0x8, lb->infra_base + lb->infrasys_offsets.bus_infra_ctrl);
writel(0xffff000c,
lb->infra_base + lb->infrasys_offsets.bus_infra_ctrl);
}
void reset_peri(void)
{
writel(0x0, lb->peri_base + lb->perisys_offsets.bus_peri_r0);
writel(0x8, lb->peri_base + lb->perisys_offsets.bus_peri_r1);
writel(0x3fff, lb->peri_base + lb->perisys_offsets.bus_peri_r0);
writel(0xc, lb->peri_base + lb->perisys_offsets.bus_peri_r1);
}
int lastbus_timeout_dump(void)
{
int infra = 0, peri = 0;
unsigned long flags;
spin_lock_irqsave(&lastbus_spin_lock, flags);
if (!lb->peri_base || !lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return -1;
}
infra = is_infra_timeout();
peri = is_peri_timeout();
if (infra | peri) {
infra_timeout_dump();
peri_timeout_dump();
reset_infra();
reset_peri();
}
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return infra | peri;
}
static int __init plt_lastbus_init(void)
{
lastbus_setup(&cfg_bus_latch);
return 0;
}
late_initcall(plt_lastbus_init);
@@ -0,0 +1,17 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __PLAT_LAST_BUS_H__
#define __PLAT_LAST_BUS_H__
#define PLAT_NUM_INFRA_EVENT_REG 2
#define PLAT_NUM_PERI_EVENT_REG 1
/*
* [31:16]peri,[15:0]infra
*/
#define FLAG_26 0xE24
#define FLAG_133 0xE34
#endif
@@ -0,0 +1 @@
obj-y += plat_lastbus.o
@@ -0,0 +1,278 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include "./../lastbus.h"
#include "plat_lastbus.h"
#include <linux/seqlock.h>
#include <linux/irqflags.h>
static DEFINE_SPINLOCK(lastbus_spin_lock);
/*
* Usage: echo 0 0 {infra} {peri} >
* /sys/bus/platform/drivers/lastbus/lastbus_timeout
*/
int infra_set_timeout(const struct plt_cfg_bus_latch *self, const char *buf)
{
int i;
char *arg;
char *p = (char *)buf;
unsigned long input;
unsigned int settings[4];
unsigned int infra_timeout;
unsigned int peri_timeout;
for (i = 0; i < 4; i++) {
arg = strsep(&p, " ");
if (arg == NULL)
return -EINVAL;
if (kstrtoul(arg, 16, &input) != 0) {
pr_info("%s:%d: kstrtoul fail for %s\n",
__func__, __LINE__, p);
return -1;
}
settings[i] = (unsigned int)input;
}
infra_timeout = readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl) & 0x0000FFFF;
infra_timeout |= (settings[2] << 16);
writel(infra_timeout, self->infra_base +
self->infrasys_offsets.bus_infra_ctrl);
peri_timeout = readl(self->peri_base +
self->perisys_offsets.bus_peri_r0) & 0xFFFF0000;
peri_timeout |= settings[3];
writel(peri_timeout, self->peri_base +
self->perisys_offsets.bus_peri_r0);
return 0;
}
int infra_get_timeout(const struct plt_cfg_bus_latch *self, char *buf)
{
return snprintf(buf, PAGE_SIZE,
"infra_config=0x%x, peri_config=0x%x\n",
readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl),
readl(self->peri_base +
self->perisys_offsets.bus_peri_r0));
}
int infra_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *infra_base = self->infra_base;
unsigned int ctrl;
if (self->num_infrasys_mon != 0) {
ctrl = readl(infra_base +
self->infrasys_offsets.bus_infra_ctrl);
if (ctrl & 0x1) {
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS BUS DUMP:\n");
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS_CTRL = %04x\n", ctrl);
for (i = 0; i <= self->num_infrasys_mon-1; ++i)
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"INFRA SNAPSHOT%d = %04x\n",
i, readl(infra_base +
self->infrasys_offsets.bus_infra_snapshot
+ 4*i));
} else {
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS NO TIMEOUT\n");
}
}
return 0;
}
static unsigned long preisys_dump_offset[] = {
0x500, /* PERIBUS_DBG0 */
0x504, /* PERIBUS_DBG1 */
0x508, /* PERIBUS_DBG2 */
0x50C, /* PERIBUS_DBG3 */
0x510, /* PERIBUS_DBG4 */
0x514, /* PERIBUS_DBG5 */
0x518, /* PERIBUS_DBG6 */
0x51C, /* PERIBUS_DBG7 */
0x520, /* PERIBUS_DBG8 */
0x524, /* PERIBUS_DBG9 */
0x528, /* PERIBUS_DBG10 */
0x52C, /* PERIBUS_DBG11 */
0x530, /* PERIBUS_DBG12 */
0x534, /* PERIBUS_DBG13 */
0x538, /* PERIBUS_DBG14 */
0x53C, /* PERIBUS_DBG15 */
0x580, /* PERIBUS_DBG16 */
};
int peri_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *peri_base = self->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] PERISYS BUS DUMP:\n");
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"PERIBUS_DBG%d(%p) = %04x\n",
i, reg, data);
}
return 0;
}
struct plt_cfg_bus_latch cfg_bus_latch = {
.supported = 1,
.num_perisys_mon = 15,
.num_infrasys_mon = 15,
.perisys_offsets = {
.bus_peri_r0 = 0x0500,
.bus_peri_r1 = 0x0504,
.bus_peri_mon = 0x0508,
},
.infrasys_offsets = {
.bus_infra_ctrl = 0x0d04,
.bus_infra_snapshot = 0x0d08,
},
.perisys_ops = {
.dump = peri_dump,
},
.infrasys_ops = {
.dump = infra_dump,
.set_timeout = infra_set_timeout,
.get_timeout = infra_get_timeout,
},
};
struct plt_cfg_bus_latch *lb = &cfg_bus_latch;
int infra_timeout_dump(void)
{
unsigned int i;
void __iomem *infra_base = lb->infra_base;
pr_info("[LAST BUS] PERISYS BUS & INFRA BUS DUMP:\n");
pr_info("%08x\n", readl(infra_base +
lb->infrasys_offsets.bus_infra_ctrl));
if (lb->num_infrasys_mon != 0) {
for (i = 0; i <= lb->num_infrasys_mon-1; ++i)
pr_info("%08x\n",
readl(infra_base +
lb->infrasys_offsets.bus_infra_snapshot
+ 4*i));
}
return 0;
}
int peri_timeout_dump(void)
{
unsigned int i;
void __iomem *peri_base = lb->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
/* peribus_dbg_in_0 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r0));
/* peribus_dbg_in_1 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r1));
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
pr_info("%08x\n", data);
}
return 0;
}
int is_infra_timeout(void)
{
int ctrl = 0;
if (!lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return -1;
}
ctrl = (readl(lb->infra_base +
lb->infrasys_offsets.bus_infra_ctrl)) & 0x1;
return ctrl;
}
int is_peri_timeout(void)
{
int ctrl = 0;
if (!lb->peri_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return -1;
}
ctrl = (readl(lb->peri_base +
lb->perisys_offsets.bus_peri_r1)) & 0x1;
return ctrl;
}
int lastbus_timeout_dump(void)
{
int infra = 0, peri = 0;
unsigned long flags;
spin_lock_irqsave(&lastbus_spin_lock, flags);
if (!lb->peri_base || !lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return -1;
}
infra = is_infra_timeout();
peri = is_peri_timeout();
if (infra | peri) {
infra_timeout_dump();
peri_timeout_dump();
}
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return infra | peri;
}
static int __init plt_lastbus_init(void)
{
lastbus_setup(&cfg_bus_latch);
return 0;
}
late_initcall(plt_lastbus_init);
@@ -0,0 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#ifndef __PLAT_LAST_BUS_H__
#define __PLAT_LAST_BUS_H__
#endif
@@ -0,0 +1 @@
obj-y += plat_lastbus.o
@@ -0,0 +1,283 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include "./../lastbus.h"
#include "plat_lastbus.h"
#include <linux/seqlock.h>
#include <linux/irqflags.h>
static DEFINE_SPINLOCK(lastbus_spin_lock);
/*
* Usage: echo 0 0 {infra} {peri} >
* /sys/bus/platform/drivers/lastbus/lastbus_timeout
*/
int infra_set_timeout(const struct plt_cfg_bus_latch *self, const char *buf)
{
int i;
char *arg;
char *p = (char *)buf;
unsigned long input;
unsigned int settings[4];
unsigned int infra_timeout;
unsigned int peri_timeout;
for (i = 0; i < 4; i++) {
arg = strsep(&p, " ");
if (arg == NULL)
return -EINVAL;
if (kstrtoul(arg, 16, &input) != 0) {
pr_info("%s:%d: kstrtoul fail for %s\n",
__func__, __LINE__, p);
return -1;
}
settings[i] = (unsigned int)input;
}
infra_timeout = readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl) & 0x0000FFFF;
infra_timeout |= (settings[2] << 16);
writel(infra_timeout, self->infra_base +
self->infrasys_offsets.bus_infra_ctrl);
peri_timeout = readl(self->peri_base +
self->perisys_offsets.bus_peri_r0) & 0xFFFF0000;
peri_timeout |= settings[3];
writel(peri_timeout, self->peri_base +
self->perisys_offsets.bus_peri_r0);
return 0;
}
int infra_get_timeout(const struct plt_cfg_bus_latch *self, char *buf)
{
return snprintf(buf, PAGE_SIZE,
"infra_config=0x%x, peri_config=0x%x\n",
readl(self->infra_base +
self->infrasys_offsets.bus_infra_ctrl),
readl(self->peri_base +
self->perisys_offsets.bus_peri_r1));
}
int infra_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *infra_base = self->infra_base;
unsigned int ctrl;
if (self->num_infrasys_mon != 0) {
ctrl = readl(infra_base +
self->infrasys_offsets.bus_infra_ctrl);
if (ctrl & 0x1) {
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS BUS DUMP:\n");
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS_CTRL = %04x\n", ctrl);
for (i = 0; i <= self->num_infrasys_mon-1; ++i)
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"INFRA SNAPSHOT%d = %04x\n",
i, readl(infra_base +
self->infrasys_offsets.bus_infra_snapshot
+ 4*i));
} else {
*wp += snprintf(buf + *wp,
LATCH_BUF_LENGTH - *wp,
"[LAST BUS] INFRASYS NO TIMEOUT\n");
}
}
return 0;
}
static unsigned long preisys_dump_offset[] = {
0x500, /* PERIBUS_DBG0 */
0x504, /* PERIBUS_DBG1 */
0x508, /* PERIBUS_DBG2 */
0x50C, /* PERIBUS_DBG3 */
0x510, /* PERIBUS_DBG4 */
0x514, /* PERIBUS_DBG5 */
0x518, /* PERIBUS_DBG6 */
0x51C, /* PERIBUS_DBG7 */
0x520, /* PERIBUS_DBG8 */
0x524, /* PERIBUS_DBG9 */
0x528, /* PERIBUS_DBG10 */
0x52C, /* PERIBUS_DBG11 */
0x530, /* PERIBUS_DBG12 */
0x534, /* PERIBUS_DBG13 */
0x538, /* PERIBUS_DBG14 */
0x53C, /* PERIBUS_DBG15 */
0x580, /* PERIBUS_DBG16 */
0x584, /* PERIBUS_DBG17 */
0x588, /* PERIBUS_DBG18 */
0x58C, /* PERIBUS_DBG19 */
0x590, /* PERIBUS_DBG20 */
0x594, /* PERIBUS_DBG21 */
0x598, /* PERIBUS_DBG22 */
};
int peri_dump(const struct plt_cfg_bus_latch *self, char *buf, int *wp)
{
unsigned int i;
void __iomem *peri_base = self->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"[LAST BUS] PERISYS BUS DUMP:\n");
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
*wp += snprintf(buf + *wp, LATCH_BUF_LENGTH - *wp,
"PERIBUS_DBG%d(%p) = %04x\n",
i, reg, data);
}
return 0;
}
struct plt_cfg_bus_latch cfg_bus_latch = {
.supported = 1,
.num_perisys_mon = 21,
.num_infrasys_mon = 48,
.perisys_offsets = {
.bus_peri_r0 = 0x0500,
.bus_peri_r1 = 0x0504,
.bus_peri_mon = 0x0508,
},
.infrasys_offsets = {
.bus_infra_ctrl = 0x0d04,
.bus_infra_snapshot = 0x0d08,
},
.perisys_ops = {
.dump = peri_dump,
},
.infrasys_ops = {
.dump = infra_dump,
.set_timeout = infra_set_timeout,
.get_timeout = infra_get_timeout,
},
};
struct plt_cfg_bus_latch *lb = &cfg_bus_latch;
int infra_timeout_dump(void)
{
unsigned int i;
void __iomem *infra_base = lb->infra_base;
pr_info("[LAST BUS] PERISYS BUS & INFRA BUS DUMP:\n");
pr_info("%08x\n", readl(infra_base +
lb->infrasys_offsets.bus_infra_ctrl));
if (lb->num_infrasys_mon != 0) {
for (i = 0; i <= lb->num_infrasys_mon-1; ++i)
pr_info("%08x\n",
readl(infra_base +
lb->infrasys_offsets.bus_infra_snapshot
+ 4*i));
}
return 0;
}
int peri_timeout_dump(void)
{
unsigned int i;
void __iomem *peri_base = lb->peri_base;
unsigned long dump_size =
sizeof(preisys_dump_offset) / sizeof(unsigned long);
unsigned __iomem *reg;
unsigned int data;
/* peribus_dbg_in_0 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r0));
/* peribus_dbg_in_1 */
pr_info("%08x\n", readl(peri_base +
lb->perisys_offsets.bus_peri_r1));
for (i = 0; i < dump_size; ++i) {
reg = peri_base + preisys_dump_offset[i];
data = readl(reg);
pr_info("%08x\n", data);
}
return 0;
}
int is_infra_timeout(void)
{
int ctrl = 0;
if (!lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return -1;
}
ctrl = (readl(lb->infra_base +
lb->infrasys_offsets.bus_infra_ctrl)) & 0x1;
return ctrl;
}
int is_peri_timeout(void)
{
int ctrl = 0;
if (!lb->peri_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
return -1;
}
ctrl = (readl(lb->peri_base +
lb->perisys_offsets.bus_peri_r1)) & 0x1;
return ctrl;
}
int lastbus_timeout_dump(void)
{
int infra = 0, peri = 0;
unsigned long flags;
spin_lock_irqsave(&lastbus_spin_lock, flags);
if (!lb->peri_base || !lb->infra_base) {
pr_info("%s:%d: not ready\n", __func__, __LINE__);
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return -1;
}
infra = is_infra_timeout();
peri = is_peri_timeout();
if (infra | peri) {
infra_timeout_dump();
peri_timeout_dump();
}
spin_unlock_irqrestore(&lastbus_spin_lock, flags);
return infra | peri;
}
static int __init plt_lastbus_init(void)
{
lastbus_setup(&cfg_bus_latch);
return 0;
}
late_initcall(plt_lastbus_init);
@@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __PLAT_LAST_BUS_H__
#define __PLAT_LAST_BUS_H__
#endif