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

+17
View File
@@ -0,0 +1,17 @@
config MTK_DEBUG_TRACER
bool "MediaTek Debug Tracer Configuration"
help
Select to enable MediaTek Debug Tracer configuration.
DEBUG TRACER is a debugging feature to record the historical
information on bus. After rebooting, these information could
be dumped for debugging.
config MTK_BUS_TRACER
bool "MediaTek BUS TRACER"
depends on MTK_DEBUG_TRACER
help
BUS TRACER is a debugging feature to record the historical
information on bus. After rebooting, these information could
be dumped for debugging. It can also debug with watchpoint,
bypass, id, and rw filters
+1
View File
@@ -0,0 +1 @@
obj-$(CONFIG_MTK_BUS_TRACER) += bus_tracer/
+3
View File
@@ -0,0 +1,3 @@
obj-y += bus_tracer_interface.o
obj-y += v1/
@@ -0,0 +1,906 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/cpumask.h>
#include <linux/list.h>
#include <linux/printk.h>
#include <linux/platform_device.h>
#include <linux/kallsyms.h>
#include <linux/of_address.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/slab.h>
#include <linux/io.h>
#include "bus_tracer_interface.h"
static const struct of_device_id bus_tracer_of_ids[] = {
{}
};
static int bus_tracer_probe(struct platform_device *pdev);
static int bus_tracer_remove(struct platform_device *pdev);
static int bus_tracer_suspend(struct platform_device *pdev, pm_message_t state);
static int bus_tracer_resume(struct platform_device *pdev);
static char *bus_tracer_dump_buf;
#define DRIVER_ATTR(_name, _mode, _show, _store) \
struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store)
static struct bus_tracer bus_tracer_drv = {
.plt_drv = {
.driver = {
.name = "bus_tracer",
.bus = &platform_bus_type,
.owner = THIS_MODULE,
.of_match_table = bus_tracer_of_ids,
},
.probe = bus_tracer_probe,
.remove = bus_tracer_remove,
.suspend = bus_tracer_suspend,
.resume = bus_tracer_resume,
},
};
static int bus_tracer_probe(struct platform_device *pdev)
{
struct bus_tracer_plt *plt = NULL;
pr_debug("%s:%d: enter\n", __func__, __LINE__);
plt = bus_tracer_drv.cur_plt;
if (plt && plt->ops && plt->ops->probe)
return plt->ops->probe(plt, pdev);
return 0;
}
static int bus_tracer_remove(struct platform_device *pdev)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
pr_debug("%s:%d: enter\n", __func__, __LINE__);
if (plt && plt->ops && plt->ops->remove)
return plt->ops->remove(plt, pdev);
return 0;
}
static int bus_tracer_suspend(struct platform_device *pdev, pm_message_t state)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
pr_debug("%s:%d: enter\n", __func__, __LINE__);
if (plt && plt->ops && plt->ops->suspend)
return plt->ops->suspend(plt, pdev, state);
return 0;
}
static int bus_tracer_resume(struct platform_device *pdev)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
pr_debug("%s:%d: enter\n", __func__, __LINE__);
if (plt && plt->ops && plt->ops->resume)
return plt->ops->resume(plt, pdev);
return 0;
}
int bus_tracer_register(struct bus_tracer_plt *plt)
{
if (!plt) {
pr_notice("%s%d: plt is NULL\n", __func__, __LINE__);
return -EINVAL;
}
bus_tracer_drv.cur_plt = plt;
return 0;
}
int bus_tracer_dump(char *buf, int len)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!buf) {
pr_notice("%s:%d: buf is NULL\n", __func__, __LINE__);
return -EINVAL;
}
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->dump)
return plt->ops->dump(plt, buf, len);
pr_notice("no dump function implemented\n");
return 0;
}
int bus_tracer_enable(unsigned char force_enable, unsigned int tracer_id)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->enable)
return plt->ops->enable(plt, force_enable, tracer_id);
pr_notice("no enable function implemented\n");
return 0;
}
int bus_tracer_disable(void)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->disable)
return plt->ops->disable(plt);
pr_notice("no disable function implemented\n");
return 0;
}
int bus_tracer_set_watchpoint_filter(struct watchpoint_filter f,
unsigned int tracer_id)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->set_watchpoint_filter)
return plt->ops->set_watchpoint_filter(plt, f, tracer_id);
pr_notice("no set_watchpoint_filter function implemented\n");
return 0;
}
int bus_tracer_set_bypass_filter(struct bypass_filter f, unsigned int tracer_id)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->set_bypass_filter)
return plt->ops->set_bypass_filter(plt, f, tracer_id);
pr_notice("no set_bypass_filter function implemented\n");
return 0;
}
int bus_tracer_set_id_filter(struct id_filter f, unsigned int tracer_id,
unsigned int idf_id)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->set_id_filter)
return plt->ops->set_id_filter(plt, f, tracer_id, idf_id);
pr_notice("no set_id_filter function implemented\n");
return 0;
}
int bus_tracer_set_rw_filter(struct rw_filter f, unsigned int tracer_id)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->set_rw_filter)
return plt->ops->set_rw_filter(plt, f, tracer_id);
pr_notice("no set_rw_filter function implemented\n");
return 0;
}
int bus_tracer_dump_setting(char *buf, int len)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->num_tracer <= 0) {
pr_notice("%s:%d: plt->num_tracer <= 0\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops && plt->ops->dump_setting)
return plt->ops->dump_setting(plt, buf, len);
pr_notice("no dump_setting function implemented\n");
return 0;
}
int bus_tracer_dump_min_len(void)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt) {
pr_notice("%s:%d: plt is NULL\n", __func__, __LINE__);
return -ENODEV;
}
if (!plt->min_buf_len)
pr_notice("%s:%d: min_buf_len is 0\n", __func__, __LINE__);
return plt->min_buf_len;
}
int mt_bus_tracer_dump(char *buf)
{
strncpy(buf, bus_tracer_dump_buf, strlen(bus_tracer_dump_buf)+1);
return 0;
}
/*
* interface: /sys/bus/platform/drivers/bus_tracer/dump_to_buf
* dump traces to internal buffer
*/
static ssize_t bus_tracer_dump_to_buf_show(struct device_driver *driver,
char *buf)
{
if (!bus_tracer_dump_buf)
bus_tracer_dump_buf = kzalloc(
bus_tracer_drv.cur_plt->min_buf_len, GFP_KERNEL);
if (!bus_tracer_dump_buf)
return -ENOMEM;
if (bus_tracer_drv.cur_plt)
bus_tracer_dump(bus_tracer_dump_buf,
bus_tracer_drv.cur_plt->min_buf_len);
return snprintf(buf, PAGE_SIZE, "copy trace to internal buffer..\n"
"using command \"cat /proc/bus_tracer/dump_db\"\n"
"to see the trace\n");
}
static ssize_t bus_tracer_dump_to_buf_store(struct device_driver *driver,
const char *buf, size_t count)
{
return count;
}
static DRIVER_ATTR(dump_to_buf, 0664, bus_tracer_dump_to_buf_show,
bus_tracer_dump_to_buf_store);
#if 0
/*
* interface: /proc/bus_trcaer/dump_db
* AEE read this seq_file to get the content of internal buffer and generate db
*/
static int bus_tracer_dump_db_show(struct seq_file *m, void *v)
{
seq_printf(m, "%s\n", bus_tracer_dump_buf);
return 0;
}
static int bus_tracer_dump_db_open(struct inode *inode, struct file *file)
{
return single_open(file, bus_tracer_dump_db_show, PDE_DATA(inode));
}
static int bus_tracer_dump_db_release(struct inode *inode, struct file *file)
{
/* release buffer after dumping to db */
kfree(bus_tracer_dump_buf);
bus_tracer_dump_buf = NULL;
return single_release(inode, file);
}
#endif
#if 0
static const struct file_operations bus_tracer_dump_db_proc_fops = {
.open = bus_tracer_dump_db_open,
.read = seq_read,
.llseek = seq_lseek,
.release = bus_tracer_dump_db_release,
};
#endif
/*
* interface: /sys/bus/platform/drivers/bus_tracer/tracer_enable
* enable tracer from sysfs in runtime
*/
static ssize_t bus_tracer_enable_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE, "Usage:\n"
"echo $tracer_id $enabled >\n"
"/sys/bus/platform/drivers/bus_tracer/tracer_enable\n");
}
static ssize_t bus_tracer_enable_store(struct device_driver *driver,
const char *buf, size_t count)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
unsigned int tracer_id = 0, enable = 0;
unsigned long input;
char *p = (char *)buf, *arg;
int ret = 0, i = 0;
while ((arg = strsep(&p, " ")) && (i <= 1)) {
if (kstrtoul(arg, 16, &input) != 0) {
pr_notice("%s: kstrtoul fail for %s\n", __func__, p);
return 0;
}
switch (i) {
case 0:
tracer_id = (unsigned int) input & 1;
break;
case 1:
enable = (unsigned char) input & 1;
break;
default:
break;
}
i++;
}
if (plt && plt->ops) {
if (enable)
ret = plt->ops->enable(plt, 1, tracer_id);
else
pr_notice("%s: not support for runtime disabling\n",
__func__);
if (ret)
pr_notice("%s: enable failed\n", __func__);
}
return count;
}
static DRIVER_ATTR(tracer_enable, 0664, bus_tracer_enable_show,
bus_tracer_enable_store);
/*
* interface: /sys/bus/platform/drivers/bus_tracer/trace_recording
* pause/resume trace recording from sysfs in runtime
*/
static ssize_t bus_tracer_recording_show(struct device_driver *driver,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "Usage:\ninput 0 to pause recording,\n"
"input 1 to resume.\n");
}
static ssize_t bus_tracer_recording_store(struct device_driver *driver,
const char *buf, size_t count)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
char *p = (char *)buf;
unsigned long arg = 0;
int ret = -1;
if (kstrtoul(p, 10, &arg) != 0) {
pr_notice("%s: kstrtoul fail for %s\n", __func__, p);
return 0;
}
/* 0 to pause recording, 1 or other ints to resume */
if (plt && plt->ops) {
if (plt->ops->set_recording)
ret = plt->ops->set_recording(plt, !(arg & 1));
if (ret)
pr_notice("%s: recording failed\n", __func__);
}
return count;
}
static DRIVER_ATTR(tracer_recording, 0664, bus_tracer_recording_show,
bus_tracer_recording_store);
#if 0
/*
* interface: /sys/bus/platform/drivers/bus_tracer/watchpoint_filter
* setup watchpoint filter
*/
static ssize_t bus_tracer_watchpoint_filter_show(struct device_driver *driver,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "Usage:\n"
"echo $tracer_id $enabled $addr_h $addr $mask >\n"
"/sys/bus/platform/drivers/bus_tracer/watchpoint_filter\n");
}
static ssize_t bus_tracer_watchpoint_filter_store(struct device_driver *driver,
const char *buf, size_t count)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
unsigned long input = 0;
int ret = -1, i = 0, tracer_id = 0;
char *p = (char *)buf, *arg;
struct watchpoint_filter f = {
.enabled = 0,
.addr_h = 0,
.addr = 0,
.mask = 0,
};
while ((arg = strsep(&p, " ")) && (i <= 4)) {
if (kstrtoul(arg, 16, &input) != 0) {
pr_notice("%s: kstrtoul fail for %s\n", __func__, p);
return 0;
}
switch (i) {
case 0:
tracer_id = (unsigned int) input & 1;
break;
case 1:
f.enabled = (unsigned char) input & 1;
break;
case 2:
f.addr_h = (unsigned int) input;
break;
case 3:
f.addr = (unsigned int) input;
break;
case 4:
f.mask = (unsigned int) input;
break;
default:
break;
}
i++;
}
if (i <= 4) {
pr_notice("%s: too few arguments\n", __func__);
return count;
}
if (plt && plt->ops) {
ret = plt->ops->set_watchpoint_filter(plt, f, tracer_id);
if (ret)
pr_notice("%s:%d: recording failed\n", __func__);
}
return count;
}
static DRIVER_ATTR(watchpoint_filter, 0664, bus_tracer_watchpoint_filter_show,
bus_tracer_watchpoint_filter_store);
/*
* interface: /sys/bus/platform/drivers/bus_tracer/bypass_filter
* setup bypass filter
*/
static ssize_t bus_tracer_bypass_filter_show(struct device_driver *driver,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "Usage:\n"
"echo $tracer_id $enabled $addr $mask >\n"
"/sys/bus/platform/drivers/bus_tracer/bypass_filter\n");
}
static ssize_t bus_tracer_bypass_filter_store(struct device_driver *driver,
const char *buf, size_t count)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
char *p = (char *)buf, *arg;
unsigned long input = 0;
int ret = -1, i = 0, tracer_id = 0;
struct bypass_filter f = {
.enabled = 0,
.addr = 0,
.mask = 0,
};
while ((arg = strsep(&p, " ")) && (i <= 3)) {
if (kstrtoul(arg, 16, &input) != 0) {
pr_notice("%s: kstrtoul fail for %s\n", __func__, p);
return 0;
}
switch (i) {
case 0:
tracer_id = (unsigned int) input & 1;
break;
case 1:
f.enabled = (unsigned char) input & 1;
break;
case 2:
f.addr = (unsigned int) input;
break;
case 3:
f.mask = (unsigned int) input;
break;
default:
break;
}
i++;
}
if (i <= 3) {
pr_notice("%s: too few arguments\n", __func__);
return count;
}
if (plt && plt->ops) {
ret = plt->ops->set_bypass_filter(plt, f, tracer_id);
if (ret)
pr_notice("%s: recording failed\n", __func__);
}
return count;
}
static DRIVER_ATTR(bypass_filter, 0664, bus_tracer_bypass_filter_show,
bus_tracer_bypass_filter_store);
/*
* interface: /sys/bus/platform/drivers/bus_tracer/id_filter
* setup id filter
*/
static ssize_t bus_tracer_id_filter_show(struct device_driver *driver,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "Usage:\n"
"echo $tracer_id $idf_id $enabled $ID >\n"
"/sys/bus/platform/drivers/bus_tracer/id_filter\n");
}
static ssize_t bus_tracer_id_filter_store(struct device_driver *driver,
const char *buf, size_t count)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
char *p = (char *)buf, *arg;
unsigned long input = 0;
int ret = -1, i = 0, tracer_id = 0, idf_id;
struct id_filter f = {
.enabled = 0,
.id = 0,
};
while ((arg = strsep(&p, " ")) && (i <= 3)) {
if (kstrtoul(arg, 16, &input) != 0) {
pr_notice("%s: kstrtoul fail for %s\n", __func__, p);
return 0;
}
switch (i) {
case 0:
tracer_id = (unsigned int) input & 1;
break;
case 1:
idf_id = (unsigned int) input;
break;
case 2:
f.enabled = (unsigned char) input & 1;
break;
case 3:
f.id = (unsigned int) input;
break;
default:
break;
}
i++;
}
if (i <= 3) {
pr_notice("%s:%d: too few arguments\n", __func__, __LINE__);
return count;
}
if (plt && plt->ops) {
ret = plt->ops->set_id_filter(plt, f, tracer_id, idf_id);
if (ret)
pr_notice("%s: recording failed\n", __func__);
}
return count;
}
static DRIVER_ATTR(id_filter, 0664, bus_tracer_id_filter_show,
bus_tracer_id_filter_store);
/*
* interface: /sys/bus/platform/drivers/bus_tracer/rw_filter
* setup read/write filter
*/
static ssize_t bus_tracer_rw_filter_show(struct device_driver *driveri,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "Usage:\n"
"echo $tracer_id $read $write >\n"
"/sys/bus/platform/drivers/bus_tracer/rw_filter\n");
}
static ssize_t bus_tracer_rw_filter_store(struct device_driver *driver,
const char *buf, size_t count)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
char *p = (char *)buf, *arg;
unsigned long input = 0;
int ret = -1, i = 0, tracer_id = 0;
struct rw_filter f = {
.read = 0,
.write = 0,
};
while ((arg = strsep(&p, " ")) && (i <= 2)) {
if (kstrtoul(arg, 16, &input) != 0) {
pr_notice("%s: kstrtoul fail for %s\n", __func__, p);
return 0;
}
switch (i) {
case 0:
tracer_id = (unsigned int) input & 1;
break;
case 1:
f.read = (unsigned char) input & 1;
break;
case 2:
f.write = (unsigned char) input & 1;
break;
default:
break;
}
i++;
}
if (i <= 2) {
pr_notice("%s: too few arguments\n", __func__);
return count;
}
if (plt && plt->ops) {
ret = plt->ops->set_rw_filter(plt, f, tracer_id);
if (ret)
pr_notice("%s: recording failed\n", __func__);
}
return count;
}
static DRIVER_ATTR(rw_filter, 0664, bus_tracer_rw_filter_show,
bus_tracer_rw_filter_store);
#endif
/*
* interface: /sys/bus/platform/drivers/bus_tracer/dump_setting
* dump current setting of bus tracers
*/
static ssize_t bus_dump_setting_show(struct device_driver *driver, char *buf)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
int ret = 0;
ret = plt->ops->dump_setting(plt, buf, -1);
if (ret)
pr_notice("%s:%d: dump failed\n", __func__, __LINE__);
return strlen(buf);
}
static ssize_t bus_dump_setting_store(struct device_driver *driver,
const char *buf, size_t count)
{
return count;
}
static DRIVER_ATTR(dump_setting, 0664, bus_dump_setting_show,
bus_dump_setting_store);
#if 0
/*
* interface: /sys/bus/platform/drivers/bus_tracer/last_status
* read this status from ram-console to check whether the bus tracer
* was recording before system resets
*/
static ssize_t last_status_show(struct device_driver *driver, char *buf)
{
/* FIXME: get the last status from ram console */
snprintf(buf, PAGE_SIZE, "1\n");
return strlen(buf);
}
static ssize_t last_status_store(struct device_driver *driver, const char *buf,
size_t count)
{
return count;
}
static DRIVER_ATTR(last_status, 0664, last_status_show, last_status_store);
#endif
static int bus_tracer_start(void)
{
struct bus_tracer_plt *plt = bus_tracer_drv.cur_plt;
if (!plt)
return -ENODEV;
if (!plt->ops) {
pr_notice("%s:%d: ops not installed\n", __func__, __LINE__);
return -ENODEV;
}
if (plt->ops->start)
return plt->ops->start(plt);
return 0;
}
static int __init bus_tracer_init(void)
{
int ret;
#if 0
static struct proc_dir_entry *root_dir;
#endif
ret = bus_tracer_start();
if (ret) {
pr_notice("%s: bus_tracer_start failed\n", __func__);
return -ENODEV;
}
/* our probe would be callback after this registration */
ret = platform_driver_register(&bus_tracer_drv.plt_drv);
if (ret) {
pr_notice("%s: platform_driver_register failed\n", __func__);
return -ENODEV;
}
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_dump_to_buf);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_tracer_enable);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_tracer_recording);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
#if 0
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_watchpoint_filter);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_bypass_filter);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_id_filter);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_rw_filter);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
#endif
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_dump_setting);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
#if 0
ret = driver_create_file(&bus_tracer_drv.plt_drv.driver,
&driver_attr_last_status);
if (ret)
pr_notice("%s: driver_create_file failed.\n", __func__);
#endif
#if 0
/* create /proc/bus_tracer */
root_dir = proc_mkdir("bus_tracer", NULL);
if (!root_dir)
return -EINVAL;
/* create /proc/bus_tracer/dump_db */
proc_create("dump_db", 0640, root_dir, &bus_tracer_dump_db_proc_fops);
#endif
bus_tracer_dump_buf = kzalloc(bus_tracer_drv.cur_plt->min_buf_len,
GFP_KERNEL);
if (!bus_tracer_dump_buf)
return -ENOMEM;
#if 0
bus_tracer_dump(bus_tracer_dump_buf,
bus_tracer_drv.cur_plt->min_buf_len);
#endif
/* force_enable=0 to enable all the tracers with enabled=1 */
bus_tracer_enable(0, -1);
pr_notice("%s: running...\n", __func__);
return 0;
}
postcore_initcall(bus_tracer_init);
@@ -0,0 +1,118 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __BUS_TRACER_H__
#define __BUS_TRACER_H__
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/compiler.h>
struct bus_tracer_plt;
struct watchpoint_filter {
unsigned int addr_h;
unsigned int addr;
unsigned int mask;
unsigned char enabled;
};
struct bypass_filter {
unsigned int addr;
unsigned int mask;
unsigned char enabled;
};
struct id_filter {
unsigned int id;
unsigned char enabled;
};
struct rw_filter {
unsigned char read;
unsigned char write;
};
struct bus_tracer_filter {
struct watchpoint_filter watchpoint;
struct bypass_filter bypass;
struct id_filter *idf;
struct rw_filter rwf;
};
struct bus_tracer_plt_operations {
/* if platform needs special settings before */
int (*start)(struct bus_tracer_plt *plt);
/* dump for tracer */
int (*dump)(struct bus_tracer_plt *plt, char *buf, int len);
/* enable the bus_tracer functionality */
int (*enable)(struct bus_tracer_plt *plt,
unsigned char force_enable, unsigned int tracer_id);
/* disable the bus_tracer functionality */
int (*disable)(struct bus_tracer_plt *plt);
/* pause/resume recording */
int (*set_recording)(struct bus_tracer_plt *plt, unsigned char pause);
/* setup watchpoint filter */
int (*set_watchpoint_filter)(struct bus_tracer_plt *plt,
struct watchpoint_filter f, unsigned int tracer_id);
/* setup bypass filter */
int (*set_bypass_filter)(struct bus_tracer_plt *plt,
struct bypass_filter f, unsigned int tracer_id);
/* setup id filter */
int (*set_id_filter)(struct bus_tracer_plt *plt,
struct id_filter f, unsigned int tracer_id,
unsigned int idf_id);
/* setup rw filter */
int (*set_rw_filter)(struct bus_tracer_plt *plt,
struct rw_filter f, unsigned int tracer_id);
/* dump current setting of tracers */
int (*dump_setting)(struct bus_tracer_plt *plt, char *buf, int len);
/* if you want to do anything more than bus_tracer_probe() */
int (*probe)(struct bus_tracer_plt *plt, struct platform_device *pdev);
/* if you want to do anything more than bus_tracer_remove() */
int (*remove)(struct bus_tracer_plt *plt, struct platform_device *pdev);
/* if you want to do anything more than bus_tracer_suspend() */
int (*suspend)(struct bus_tracer_plt *plt, struct platform_device *pdev,
pm_message_t state);
/* if you want to do anything more than bus_tracer_resume() */
int (*resume)(struct bus_tracer_plt *plt, struct platform_device *pdev);
};
struct tracer {
void __iomem *base;
unsigned char enabled;
unsigned char recording;
unsigned char at_id;
struct bus_tracer_filter filter;
};
struct bus_tracer_plt {
unsigned int min_buf_len;
unsigned int num_tracer;
unsigned int err_flag;
struct bus_tracer_plt_operations *ops;
struct tracer *tracer;
void __iomem *dem_base;
void __iomem *dbgao_base;
void __iomem *funnel_base;
void __iomem *etb_base;
void __iomem *dfdsoc_base;
void __iomem *lastbus_base;
};
struct bus_tracer {
struct platform_driver plt_drv;
struct bus_tracer_plt *cur_plt;
};
/* for platform register their specific bus_tracer behaviors
* (chip or various versions of bus_tracer)
*/
int bus_tracer_register(struct bus_tracer_plt *plt);
#endif /* end of __BUS_TRACER_H__ */
@@ -0,0 +1 @@
obj-y += bus_tracer_v1.o
@@ -0,0 +1,741 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/circ_buf.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/of_address.h>
#include <linux/slab.h>
#include <mt-plat/mtk_platform_debug.h>
#include "../bus_tracer_interface.h"
#include "bus_tracer_v1.h"
static int start(struct bus_tracer_plt *plt)
{
struct device_node *node;
int ret, num_tracer, i;
/* u32 args[3]; */
if (!plt) {
pr_notice("%s:%d: plt == NULL\n", __func__, __LINE__);
return -1;
}
node = of_find_compatible_node(NULL, NULL, "mediatek,bus_tracer-v1");
if (!node) {
pr_notice("can't find compatible node for bus_tracer\n");
return -1;
}
if (of_property_read_u32(node, "mediatek,err_flag",
&plt->err_flag) != 0)
plt->err_flag = 0xFFF8FFFF;
if (of_property_read_u32(node, "mediatek,num_tracer",
&num_tracer) != 0) {
pr_notice("can't find property \"mediatek,num_tracer\"\n");
return -1;
}
if (num_tracer <= 0) {
pr_notice("[bus tracer] fatal error: num_tracer <= 0\n");
return -1;
}
plt->dem_base = of_iomap(node, 0);
plt->dbgao_base = of_iomap(node, 1);
plt->funnel_base = of_iomap(node, 2);
plt->etb_base = of_iomap(node, 3);
plt->num_tracer = num_tracer;
plt->tracer = kcalloc(num_tracer, sizeof(struct tracer), GFP_KERNEL);
if (!plt->tracer)
return -ENOMEM;
for (i = 0; i <= num_tracer-1; ++i) {
if (of_property_read_u32_index(node, "mediatek,enabled_tracer",
i, &ret) == 0)
plt->tracer[i].enabled = ret & 0x1;
else
plt->tracer[i].enabled = 0;
if (of_property_read_u32_index(node, "mediatek,at_id", i,
&ret) == 0)
plt->tracer[i].at_id = ret;
#if 0
/* arguments for filters */
if (of_property_read_u32_array(node,
"mediatek,watchpoint_filter", args, 3) == 0) {
plt->tracer[i].filter.watchpoint.addr_h = args[0];
plt->tracer[i].filter.watchpoint.addr = args[1];
plt->tracer[i].filter.watchpoint.mask = args[2];
plt->tracer[i].filter.watchpoint.enabled = 1;
} else
plt->tracer[i].filter.watchpoint.enabled = 0;
if (of_property_read_u32_array(node,
"mediatek,bypass_filter", args, 2) == 0) {
plt->tracer[i].filter.bypass.addr = args[0];
plt->tracer[i].filter.bypass.mask = args[1];
plt->tracer[i].filter.bypass.enabled = 1;
} else
plt->tracer[i].filter.bypass.enabled = 0;
plt->tracer[i].filter.idf = (struct id_filter *)
kcalloc(NUM_ID_FILTER, sizeof(struct id_filter),
GFP_KERNEL);
if (plt->tracer[i].filter.idf) {
if (of_property_read_u32_array(node,
"mediatek,id_filter", args, NUM_ID_FILTER) ==
0) {
for (j = 0; j <= NUM_ID_FILTER-1; ++j) {
plt->tracer[i].filter.idf[j].id =
args[j];
plt->tracer[i].filter.idf[j].enabled =
1;
}
} else
for (j = 0; j <= NUM_ID_FILTER-1; ++j)
plt->tracer[i].filter.idf[j].enabled =
0;
} else {
pr_notice("failed to alloc id filter for tracer %d\n",
i);
return -ENOMEM;
}
if (of_property_read_u32_array(node, "mediatek,rw_filter",
args, 2) == 0) {
plt->tracer[i].filter.rwf.read = args[0];
plt->tracer[i].filter.rwf.write = args[1];
} else {
plt->tracer[i].filter.rwf.read = 0;
plt->tracer[i].filter.rwf.write = 0;
}
#endif
plt->tracer[i].base = of_iomap(node, 4+i);
plt->tracer[i].recording = 0;
}
return 0;
}
#if 0
static void disable_etb(void __iomem *base)
{
if (!base)
return;
CS_UNLOCK(base);
writel(0x0, base + ETB_CTRL);
CS_LOCK(base);
dsb(sy);
}
#endif
static void enable_etb(void __iomem *base)
{
unsigned int depth, i;
if (!base)
return;
CS_UNLOCK(base);
depth = readl(base + ETB_DEPTH);
writel(0x0, base + ETB_WRITEADDR);
for (i = 0; i < depth; ++i)
writel(0x0, base + ETB_RWD);
writel(0x0, base + ETB_WRITEADDR);
writel(0x0, base + ETB_READADDR);
writel(0x1, base + ETB_CTRL);
CS_LOCK(base);
dsb(sy);
}
#if 0
static int dump_etb(void __iomem *base, char **ptr)
{
unsigned int i;
unsigned long depth, rp, wp, ret;
unsigned long nr_words, nr_unaligned_bytes, packet;
if (!base)
return -1;
CS_UNLOCK(base);
ret = readl(base + ETB_STATUS);
rp = readl(base + ETB_READADDR);
wp = readl(base + ETB_WRITEADDR);
/* depth is counted in byte */
if (ret & 0x1)
depth = readl(base + ETB_DEPTH) << 2;
else
depth = CIRC_CNT(wp, rp, readl(base + ETB_DEPTH) << 2);
pr_notice("[bus tracer] etb depth = 0x%lx bytes", depth);
pr_notice("[bus tracer] etb status = 0x%lx, rp = 0x%lx, wp = 0x%lx\n)",
ret, rp, wp);
if (depth == 0)
return -1;
(*ptr) += sprintf((*ptr), "[BUS TRACER] nr_bytes_in_etb = %ld\n",
depth);
nr_words = depth / 4;
nr_unaligned_bytes = depth % 4;
for (i = 0; i < nr_words; i++) {
packet = readl(base + ETB_READMEM);
/*pr_notice("%d %lx\n", i, packet);*/
(*ptr) += sprintf((*ptr), "%08lx\n", packet);
}
if (nr_unaligned_bytes != 0) {
/* bus tracer always generate word-aligned transactions */
pr_notice("etb depth is unaligned!\n");
(*ptr) += sprintf((*ptr), "etb depth is unaligned!\n");
}
writel(0x0, base + ETB_CTRL);
writel(0x0, base + ETB_TRIGGERCOUNT);
writel(0x0, base + ETB_READADDR);
writel(0x0, base + ETB_WRITEADDR);
CS_LOCK(base);
dsb(sy);
return 0;
}
#endif
static int dump(struct bus_tracer_plt *plt, char *buf, int len)
{
#if 0
int i;
for (i = 0; i <= plt->num_tracer-1; ++i) {
if (plt->tracer[i].recording) {
pr_notice("[bus tracer] tracer %d is running,\n"
"you must pause it before first\n", i);
buf += sprintf(buf,
"[bus tracer] tracer %d is running,\n"
"you must pause it first\n", i);
return -1;
}
}
disable_etb(plt->etb_base);
if (dump_etb(plt->etb_base, &buf) < 0) {
pr_notice("[bus tracer] error when dumping etb\n");
return -2;
}
#endif
return 0;
}
/* force_enable=0 to enable all the tracers with enabled=1 */
static int enable(struct bus_tracer_plt *plt, unsigned char force_enable,
unsigned int tracer_id)
{
int i, j;
unsigned long ret;
if (!plt->tracer) {
pr_notice("%s:%d: plt->tracer == NULL\n", __func__, __LINE__);
return -1;
}
if (!plt->dem_base) {
pr_notice("%s:%d: dem_base == NULL\n", __func__, __LINE__);
return -1;
}
if (!plt->dbgao_base) {
pr_notice("%s:%d: dbgao_base == NULL\n", __func__, __LINE__);
return -1;
}
if (!plt->funnel_base) {
pr_notice("%s:%d: funnel_base == NULL\n", __func__, __LINE__);
return -1;
}
if (force_enable) {
for (j = 0; j <= plt->num_tracer - 1; ++j)
plt->tracer[j].enabled = 1;
} else {
j = 0;
for (i = 0; i <= plt->num_tracer - 1; ++i)
j += plt->tracer[i].enabled;
if (j == 0) {
pr_debug("%s:%d: all the tracers are disabled\n",
__func__, __LINE__);
return -2;
}
}
/* enable ATB clk */
writel(0x1, plt->dbgao_base + DEM_ATB_CLK);
dsb(sy);
#if 0
writel(0x8, plt->dem_base + DEM_ATB_CLK);
dsb(sy);
writel(0x0, plt->dem_base + DEM_ATB_CLK);
dsb(sy);
#endif
writel(0x1, plt->dem_base + DEM_ATB_CLK);
dsb(sy);
/* set dem_ao unlock */
CS_UNLOCK(plt->dbgao_base);
dsb(sy);
/* set DBGRST_ALL to 0 */
writel(0x2, plt->dbgao_base + DEM_DBGRST_ALL);
dsb(sy);
CS_LOCK(plt->dbgao_base);
dsb(sy);
/* timestamp per 8us; 1: 76.923ns */
writel(0x6501, plt->dem_base + INSERT_TS0);
writel(plt->err_flag, plt->dbgao_base + DBG_ERR_FLAG_IRQ_POLARITY);
dsb(sy);
writel(0x0, plt->dbgao_base + DBG_ERR_FLAG_CON);
dsb(sy);
writel(0x3, plt->dbgao_base + DBG_ERR_FLAG_CON);
dsb(sy);
/* replicator 1 setup */
CS_UNLOCK(plt->funnel_base + REPLICATOR1_BASE);
#if 0
writel((~(1 << (plt->tracer[0].at_id >> 4)) & 0xff),
plt->funnel_base + REPLICATOR1_BASE + REPLICATOR_IDFILTER0);
if (plt->num_tracer > 1)
writel((~(1 << (plt->tracer[1].at_id >> 4)) & 0xff),
plt->funnel_base + REPLICATOR1_BASE +
REPLICATOR_IDFILTER1);
#else
writel(0x00, plt->funnel_base + REPLICATOR1_BASE +
REPLICATOR_IDFILTER0);
writel(0x00, plt->funnel_base + REPLICATOR1_BASE +
REPLICATOR_IDFILTER1);
#endif
CS_LOCK(plt->funnel_base + REPLICATOR1_BASE);
dsb(sy);
/* funnel setup */
CS_UNLOCK(plt->funnel_base);
writel(0xff, plt->funnel_base + FUNNEL_CTRL_REG);
CS_LOCK(plt->funnel_base);
dsb(sy);
for (i = 0; i <= plt->num_tracer - 1; ++i) {
/* enable ETB */
enable_etb(plt->etb_base);
/* set ID */
writel(plt->tracer[i].at_id, plt->tracer[i].base +
BUS_TRACE_ATID);
#if 0
/* setup filters */
if (plt->tracer[i].filter.watchpoint.enabled) {
writel(plt->tracer[i].filter.watchpoint.addr_h,
plt->tracer[i].base + BUS_TRACE_WATCHPOINT_H);
writel(plt->tracer[i].filter.watchpoint.addr,
plt->tracer[i].base + BUS_TRACE_WATCHPOINT);
writel(plt->tracer[i].filter.watchpoint.mask,
plt->tracer[i].base +
BUS_TRACE_WATCHPOINT_MASK);
writel(TRACE_WP_EN, plt->tracer[i].base + BUS_MON_CON);
}
if (plt->tracer[i].filter.bypass.enabled) {
writel(plt->tracer[i].filter.bypass.addr >>
BYPASS_FILTER_SHIFT, plt->tracer[i].base +
BUS_TRACE_BYPASS_ADDR);
writel(plt->tracer[i].filter.bypass.mask >>
BYPASS_FILTER_SHIFT, plt->tracer[i].base +
BUS_TRACE_BYPASS_MASK);
ret = readl(plt->tracer[i].base + BUS_MON_CON);
writel(TRACE_BYPASS_EN|ret, plt->tracer[i].base +
BUS_MON_CON);
}
if (plt->tracer[i].filter.idf) {
for (j = 0; j <= NUM_ID_FILTER-1; ++j) {
if (plt->tracer[i].filter.idf[j].enabled) {
writel(plt->tracer[i].filter.idf[j].id,
plt->tracer[i].base +
BUS_TRACE_IDF0 + (0x4 * j));
ret = readl(plt->tracer[i].base +
BUS_MON_CON);
writel(TRACE_IDF_EN|ret,
plt->tracer[i].base +
BUS_MON_CON);
}
}
}
writel(plt->tracer[i].filter.rwf.read |
(plt->tracer[i].filter.rwf.write << 1),
plt->tracer[i].base + BUS_TRACE_RW_FILTER);
#endif
/* enable tracer */
if (plt->tracer[i].enabled) {
ret = readl(plt->tracer[i].base + BUS_TRACE_CON);
#if 0
writel(ret & ~(SW_RST_B), plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
writel(0x9, plt->dem_base + DEM_ATB_CLK);
dsb(sy);
writel(0x9, plt->dbgao_base + DEM_ATB_CLK);
dsb(sy);
/* enable_etb(plt->etb_base);*/
writel(ret|SW_RST_B, plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
#endif
writel(ret|BUS_TRACE_EN|WDT_RST_EN|SW_RST_B,
plt->tracer[i].base + BUS_TRACE_CON);
plt->tracer[i].recording = 1;
}
dsb(sy);
}
return 0;
}
static int set_recording(struct bus_tracer_plt *plt, unsigned char pause)
{
int i;
unsigned long ret;
if (!plt->tracer) {
pr_notice("%s:%d: plt->tracer == NULL\n", __func__, __LINE__);
return -1;
}
for (i = 0; i <= plt->num_tracer - 1; ++i) {
/* only pause/resume tracers that are enabled*/
if (!plt->tracer[i].enabled)
continue;
if (pause) {
/* disable tracer */
ret = readl(plt->tracer[i].base);
writel(ret & ~(BUS_TRACE_EN), plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
/* disable etb */
/* disable_etb(plt->etb_base); */
plt->tracer[i].recording = 0;
} else {
/* enable ETB */
enable_etb(plt->etb_base);
/* enable tracer */
ret = readl(plt->tracer[i].base);
writel(ret|BUS_TRACE_EN, plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
plt->tracer[i].recording = 1;
}
}
return 0;
}
#if 0
static int set_watchpoint_filter(struct bus_tracer_plt *plt,
struct watchpoint_filter f, unsigned int tracer_id)
{
unsigned long ret;
if (!plt->tracer) {
pr_notice("%s: plt->tracer == NULL\n", __func__);
return -1;
}
if (tracer_id > plt->num_tracer) {
pr_notice("%s: tracer_id > plt->num_tracer\n", __func__);
return -1;
}
plt->tracer[tracer_id].filter.watchpoint = f;
writel(f.addr_h, plt->tracer[tracer_id].base + BUS_TRACE_WATCHPOINT_H);
writel(f.addr, plt->tracer[tracer_id].base + BUS_TRACE_WATCHPOINT);
writel(f.mask, plt->tracer[tracer_id].base + BUS_TRACE_WATCHPOINT_MASK);
ret = readl(plt->tracer[tracer_id].base + BUS_MON_CON);
if (f.enabled)
writel(TRACE_WP_EN|ret, plt->tracer[tracer_id].base +
BUS_MON_CON);
else
writel((~TRACE_WP_EN)&ret, plt->tracer[tracer_id].base +
BUS_MON_CON);
return 0;
}
static int set_bypass_filter(struct bus_tracer_plt *plt,
struct bypass_filter f, unsigned int tracer_id)
{
unsigned long ret;
if (!plt->tracer) {
pr_notice("%s: plt->tracer == NULL\n", __func__);
return -1;
}
if (tracer_id > plt->num_tracer) {
pr_notice("%s: tracer_id > plt->num_tracer\n", __func__);
return -1;
}
plt->tracer[tracer_id].filter.bypass = f;
writel(f.addr, plt->tracer[tracer_id].base + BUS_TRACE_BYPASS_ADDR);
writel(f.mask, plt->tracer[tracer_id].base + BUS_TRACE_BYPASS_MASK);
ret = readl(plt->tracer[tracer_id].base + BUS_MON_CON);
if (f.enabled)
writel(TRACE_BYPASS_EN|ret, plt->tracer[tracer_id].base +
BUS_MON_CON);
else
writel((~TRACE_BYPASS_EN)&ret, plt->tracer[tracer_id].base +
BUS_MON_CON);
return 0;
}
static int set_id_filter(struct bus_tracer_plt *plt,
struct id_filter f, unsigned int tracer_id, unsigned int idf_id)
{
unsigned long ret;
if (!plt->tracer) {
pr_notice("%s: plt->tracer == NULL\n", __func__);
return -1;
}
if (tracer_id > plt->num_tracer) {
pr_notice("%s: tracer_id > plt->num_tracer\n", __func__);
return -1;
}
if (!plt->tracer[tracer_id].filter.idf) {
pr_notice("%s: plt->tracer[tracer_id].filter.idf == NULL\n",
__func__);
return -1;
}
if (idf_id > NUM_ID_FILTER) {
pr_notice("%s: idf_id > NUM_ID_FILTER\n", __func__);
return -1;
}
plt->tracer[tracer_id].filter.idf[idf_id] = f;
writel(f.id, plt->tracer[tracer_id].base + BUS_TRACE_IDF0 +
(0x4 * idf_id));
ret = readl(plt->tracer[tracer_id].base + BUS_MON_CON);
if (f.enabled)
writel(TRACE_IDF_EN|ret, plt->tracer[tracer_id].base +
BUS_MON_CON);
else
writel((~TRACE_IDF_EN)&ret, plt->tracer[tracer_id].base +
BUS_MON_CON);
return 0;
}
static int set_rw_filter(struct bus_tracer_plt *plt, struct rw_filter f,
unsigned int tracer_id)
{
if (!plt->tracer) {
pr_notice("%s:%d: plt->tracer == NULL\n", __func__);
return -1;
}
if (tracer_id > plt->num_tracer) {
pr_notice("%s:%d: tracer_id > plt->num_tracer\n", __func__);
return -1;
}
plt->tracer[tracer_id].filter.rwf = f;
writel(f.read|(f.write << 1), plt->tracer[tracer_id].base +
BUS_TRACE_RW_FILTER);
return 0;
}
#endif
static int dump_setting(struct bus_tracer_plt *plt, char *buf, int len)
{
int i;
if (!plt->tracer) {
pr_notice("%s:%d: plt->tracer == NULL\n", __func__, __LINE__);
return -1;
}
for (i = 0; i <= plt->num_tracer-1; ++i) {
buf += sprintf(buf, "== dump setting of tracer %d ==\n", i);
buf += sprintf(buf, "enabled = %x\ntrace recording = %x\n",
plt->tracer[i].enabled, plt->tracer[i].recording);
#if 0
if (plt->tracer[i].filter.watchpoint.enabled)
buf += sprintf(buf, "watchpoint = 0x%x 0x%x 0x%x\n",
plt->tracer[i].filter.watchpoint.addr_h,
plt->tracer[i].filter.watchpoint.addr,
plt->tracer[i].filter.watchpoint.mask);
if (plt->tracer[i].filter.bypass.enabled)
buf += sprintf(buf, "bypass = 0x%x 0x%x\n",
plt->tracer[i].filter.bypass.addr,
plt->tracer[i].filter.bypass.mask);
for (j = 0; j <= NUM_ID_FILTER-1; ++j) {
if (plt->tracer[i].filter.idf &&
plt->tracer[i].filter.idf[j].enabled)
buf += sprintf(buf, "idf %d = 0x%x\n",
j, plt->tracer[i].filter.idf[j].id);
}
buf += sprintf(buf, "r = 0x%x, w = 0x%x\n",
plt->tracer[i].filter.rwf.read,
plt->tracer[i].filter.rwf.write);
#endif
buf += sprintf(buf, "==== register dump ====\n");
buf += sprintf(buf, "0x0 = 0x%lx\n0x10 = 0x%lx\n0x14 = 0x%lx\n"
"0x18 = 0x%lx\n",
(unsigned long) readl(plt->tracer[i].base),
(unsigned long) readl(plt->tracer[i].base + 0x10),
(unsigned long) readl(plt->tracer[i].base + 0x14),
(unsigned long) readl(plt->tracer[i].base + 0x18));
#if 0
buf += sprintf(buf, "0x20 = 0x%lx\n0x24 = 0x%lx\n"
"0x28 = 0x%lx\n",
(unsigned long) readl(plt->tracer[i].base + 0x20),
(unsigned long) readl(plt->tracer[i].base + 0x24),
(unsigned long) readl(plt->tracer[i].base + 0x28));
buf += sprintf(buf, "0x2c = 0x%lx\n0x30 = 0x%lx\n0x34 = 0x%lx\n"
"0x3c = 0x%lx\n",
(unsigned long) readl(plt->tracer[i].base + 0x2c),
(unsigned long) readl(plt->tracer[i].base + 0x30),
(unsigned long) readl(plt->tracer[i].base + 0x34),
(unsigned long) readl(plt->tracer[i].base + 0x3c));
#endif
}
buf += sprintf(buf, "== DBG_ERR_FLAG register dump ==\n");
buf += sprintf(buf, "0x80 = 0x%lx\n0x84 = 0x%lx\n0x88 = 0x%lx\n"
"0x8c = 0x%lx\n",
(unsigned long) readl(plt->dbgao_base + 0x80),
(unsigned long) readl(plt->dbgao_base + 0x84),
(unsigned long) readl(plt->dbgao_base + 0x88),
(unsigned long) readl(plt->dbgao_base + 0x8c));
buf += sprintf(buf, "0x90 = 0x%lx\n0x94 = 0x%lx\n0x98 = 0x%lx\n"
"0x9c = 0x%lx\n",
(unsigned long) readl(plt->dbgao_base + 0x90),
(unsigned long) readl(plt->dbgao_base + 0x94),
(unsigned long) readl(plt->dbgao_base + 0x98),
(unsigned long) readl(plt->dbgao_base + 0x9c));
return 0;
}
static int resume(struct bus_tracer_plt *plt, struct platform_device *pdev)
{
#if 0
int i;
unsigned long ret;
if (!plt->tracer) {
pr_notice("%s:%d: plt->tracer == NULL\n", __func__, __LINE__);
return -1;
}
for (i = 0; i <= plt->num_tracer - 1; ++i) {
ret = readl(plt->tracer[i].base + BUS_TRACE_CON);
if (ret & BUS_TRACE_EN) {
writel(ret & ~(BUS_TRACE_EN), plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
writel(ret|SW_RST_B, plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
writel(ret|BUS_TRACE_EN, plt->tracer[i].base +
BUS_TRACE_CON);
dsb(sy);
pr_notice("%s: plt->tracer[%d]\n", __func__, i);
}
}
#endif
return 0;
}
static struct bus_tracer_plt_operations bus_tracer_ops = {
.dump = dump,
.start = start,
.enable = enable,
.set_recording = set_recording,
/* .set_watchpoint_filter = set_watchpoint_filter, */
/* .set_bypass_filter = set_bypass_filter, */
/* .set_id_filter = set_id_filter, */
/* .set_rw_filter = set_rw_filter, */
.dump_setting = dump_setting,
.resume = resume,
};
static int __init bus_tracer_init(void)
{
struct bus_tracer_plt *plt = NULL;
int ret = 0;
plt = kzalloc(sizeof(struct bus_tracer_plt), GFP_KERNEL);
if (!plt)
return -ENOMEM;
plt->ops = &bus_tracer_ops;
plt->min_buf_len = 8192; /* 8K */
ret = bus_tracer_register(plt);
if (ret) {
pr_notice("%s: bus_tracer_register failed\n", __func__);
goto register_bus_tracer_err;
}
set_sram_flag_timestamp();
return 0;
register_bus_tracer_err:
kfree(plt);
return ret;
}
core_initcall(bus_tracer_init);
@@ -0,0 +1,131 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#ifndef __BUS_TRACER_V1_H__
#define __BUS_TRACER_V1_H__
#define get_bit_at(reg, pos) (((reg) >> (pos)) & 1)
#define NUM_ID_FILTER 2
#define SW_RST_B (1 << 0)
#define ID_FILTER0_EN (1 << 1)
#define ID_FILTER1_EN (1 << 2)
#define ID_FILTER2_EN (1 << 3)
#define ID_FILTER3_EN (1 << 4)
#define ID_WATCH_OR_BYPASS (1 << 5)
#define ID_FILTER_EN (1 << 6)
#define ADDR_FILTER0_EN (1 << 7)
#define ADDR_FILTER1_EN (1 << 8)
#define ADDR_FILTER2_EN (1 << 9)
#define ADDR_FILTER3_EN (1 << 10)
#define ADDR_WATCH_OR_BYPASS (1 << 11)
#define ADDR_FILTER_EN (1 << 12)
#define ADDR_RANGE0_EN (1 << 13)
#define ADDR_RANGE1_EN (1 << 14)
#define ADDR_RANGE_MODE (1 << 15)
#define BUS_TRACE_EN (1 << 16)
#define WDT_RST_EN (1 << 18)
#define AW_DISABLE (1 << 20)
#define AR_DISABLE (1 << 21)
#define W_DISABLE (1 << 22)
#define B_DISABLE (1 << 23)
#define R_DISABLE (1 << 24)
#define BYPASS_FILTER_SHIFT 12
#define BUS_TRACE_CON 0x0
#define BUS_TRACE_ADDR_RANGE0_L 0x10
#define BUS_TRACE_ADDR_RANGE0_H 0x14
#define BUS_TRACE_ADDR_RANGE1_L 0x18
#define BUS_TRACE_ADDR_RANGE2_H 0x1c
#define BUS_TRACE_ID_FILTER0 0x20
#define BUS_TRACE_ID_FILTER1 0x24
#define BUS_TRACE_ID_FILTER3 0x28
#define BUS_TRACE_ID_FILTER4 0x2c
#define BUS_TRACE_ID_MASK0 0x30
#define BUS_TRACE_ID_MASK1 0x34
#define BUS_TRACE_ID_MASK2 0x38
#define BUS_TRACE_ID_MASK3 0x3c
#define BUS_TRACE_ADDR_FILTER0_L 0x40
#define BUS_TRACE_ADDR_FILTER0_H 0x44
#define BUS_TRACE_ADDR_FILTER1_L 0x48
#define BUS_TRACE_ADDR_FILTER1_H 0x4c
#define BUS_TRACE_ADDR_FILTER2_L 0x50
#define BUS_TRACE_ADDR_FILTER2_H 0x54
#define BUS_TRACE_ADDR_FILTER3_L 0x58
#define BUS_TRACE_ADDR_FILTER3_H 0x5c
#define BUS_TRACE_ADDR_MASK0_L 0x60
#define BUS_TRACE_ADDR_MASK0_H 0x64
#define BUS_TRACE_ADDR_MASK1_L 0x68
#define BUS_TRACE_ADDR_MASK1_H 0x6c
#define BUS_TRACE_ADDR_MASK2_L 0x70
#define BUS_TRACE_ADDR_MASK2_H 0x74
#define BUS_TRACE_ADDR_MASK3_L 0x78
#define BUS_TRACE_ADDR_MASK3_H 0x7c
#define BUS_TRACE_ATID 0x80
#define BUS_TRACE_BUS_DBG_CON_AO 0xfc
/* ETB registers, "CoreSight Components TRM", 9.3 */
#define ETB_DEPTH 0x04
#define ETB_STATUS 0x0c
#define ETB_READMEM 0x10
#define ETB_READADDR 0x14
#define ETB_WRITEADDR 0x18
#define ETB_TRIGGERCOUNT 0x1c
#define ETB_CTRL 0x20
#define ETB_RWD 0x24
#define ETB_LAR 0xfb0
#define DEM_DBGRST_ALL 0x28
#define DEM_ATB_CLK 0x70
#define INSERT_TS0 0x80
#define ETR_AWID 0x84
#define ETR_AWUSER 0x88
#define DEM_LAR 0xfb0
#define DBG_ERR_FLAG_CON 0x80
#define DBG_ERR_FLAG_WDT_MASK_EN 0x84
#define DBG_ERR_FLAG_STATUS0 0x88
#define DBG_ERR_FLAG_STATUS1 0x8c
#define DBG_ERR_FLAG_SYSTIMER_L 0x90
#define DBG_ERR_FLAG_SYSTIMER_H 0x94
#define DBG_ERR_FLAG_ERR_STAGE 0x98
#define DBG_ERR_FLAG_IRQ_POLARITY 0x9c
#define REPLICATOR1_BASE 0x1000
#define REPLICATOR_LAR 0xfb0
#define REPLICATOR_IDFILTER0 0x0
#define REPLICATOR_IDFILTER1 0x4
#define FUNNEL_CTRL_REG 0x0
#define FUNNEL_LOCKACCESS 0xfb0
#define CORESIGHT_LAR 0xfb0
#define CORESIGHT_UNLOCK 0xc5acce55
static inline void CS_LOCK(void __iomem *addr)
{
do {
/* Wait for things to settle */
mb();
writel_relaxed(0x0, addr + CORESIGHT_LAR);
} while (0);
}
static inline void CS_UNLOCK(void __iomem *addr)
{
do {
writel_relaxed(CORESIGHT_UNLOCK, addr + CORESIGHT_LAR);
/* Make sure everyone has seen this */
mb();
} while (0);
}
#endif /* end of __BUS_TRACER_V1_H__ */