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

+7
View File
@@ -0,0 +1,7 @@
config MTK_SYSTRACKER_V2
bool "Enable MTK System Tracker Debugger V2"
help
SYSTRACKER driver is a debugging feature.
SYSTRACKER is a hardware debugger to record timeout transaction
and trigger SLV_ERR or interrupt to notify CPU.
Support 2 stage timeout & watchpoint SLV_ERR
+14
View File
@@ -0,0 +1,14 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y += systracker_interface_v2.o
@@ -0,0 +1,19 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y := systracker_platform.o
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
CFLAGS_systracker_platform.o := -DDEBUG
endif
@@ -0,0 +1,279 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <mtk_ram_console.h>
#include <asm/system_misc.h>
#include <asm/traps.h>
#include <linux/signal.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "../systracker_v2.h"
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1;
void __iomem *mm_area1;
#endif
#ifdef CONFIG_ARM64
static int read_timeout_handler(unsigned long addr,
unsigned int fsr, struct pt_regs *regs)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
pr_notice("%s:%d: read timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x,",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
/* return -1 to indicate kernel go on its flow */
return -1;
}
static void write_timeout_handler(struct pt_regs *regs, void *priv)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
pr_debug("%s:%d: write timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
((BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1))) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
}
}
static int systracker_platform_hook_fault(void)
{
int ret = 0;
/* We use ARM64's synchroneous external abort for read timeout */
hook_fault_code(0x10,
read_timeout_handler,
SIGTRAP,
0,
"Systracker debug exception");
/* for 64bit, we should register async abort handler */
ret = register_async_abort_handler(write_timeout_handler, NULL);
if (ret) {
pr_notice("%s:%d: register_async_abort_handler failed\n",
__func__,
__LINE__);
return -1;
}
return 0;
}
#else
int systracker_handler(unsigned long addr,
unsigned int fsr,
struct pt_regs *regs)
{
int i;
#ifdef SYSTRACKER_TEST_SUIT
writel(readl(p1) & ~(0x1 << 6), p1);
#endif
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
}
return -1;
}
/* ARM32 version */
static int __init systracker_platform_hook_fault(void)
{
#ifdef CONFIG_ARM_LPAE
hook_fault_code(0x10,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x11,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#else
hook_fault_code(0x8,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x16,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#endif
return 0;
}
#endif
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1;
void __iomem *mm_area1;
static int systracker_platform_test_init(void)
{
p1 = ioremap(0x10001220, 0x4);
/* use mmsys reg base for our test */
mm_area1 = ioremap(0x14000000, 0x4);
return 0;
}
static void systracker_platform_test_cleanup(void)
{
writel(readl(p1) & ~(0x1 << 6), p1);
}
static void systracker_platform_wp_test(void)
{
void __iomem *ptr;
/* use eint reg base as our watchpoint */
ptr = ioremap(0x1000b000, 0x4);
pr_debug("%s:%d: we got p = 0x%p\n", __func__, __LINE__, ptr);
systracker_set_watchpoint_addr(0x1000b000);
systracker_watchpoint_enable();
/* touch it */
writel(0, ptr);
pr_debug("after we touched watchpoint\n");
iounmap(ptr);
}
static void systracker_platform_read_timeout_test(void)
{
/* FIXME: testing
* track_config.enable_slave_err = 0;
* systracker_enable();
*/
writel(readl(p1) | (0x1 << 6), p1);
readl(mm_area1);
writel(readl(p1) & ~(0x1 << 6), p1);
}
static void systracker_platform_write_timeout_test(void)
{
writel(readl(p1) | (0x1 << 6), p1);
writel(0x0, mm_area1);
writel(readl(p1) & ~(0x1 << 6), p1);
}
static void systracker_platform_withrecord_test(void)
{
writel(readl(IOMEM(BUS_DBG_CON)) |
BUS_DBG_CON_HALT_ON_EN, IOMEM(BUS_DBG_CON));
writel(readl(p1) | (0x1 << 6), p1);
readl(mm_area1);
#if 0
/* FIXME: related function not ready on FPGA */
wdt_arch_reset(1);
#endif
}
static void systracker_platform_notimeout_test(void)
{
writel(readl(p1) | (0x1 << 6), p1);
/* disable timeout */
writel(readl(IOMEM(BUS_DBG_CON)) &
~(BUS_DBG_CON_TIMEOUT_EN), IOMEM(BUS_DBG_CON));
/* read it, should cause bus hang */
readl(mm_area1);
/* never come back */
pr_notice("failed??\n");
}
#endif
/* end of SYSTRACKER_TEST_SUIT */
/*
* mt_systracker_init: initialize driver.
* Always return 0.
*/
static int __init mt_systracker_init(void)
{
struct mt_systracker_driver *systracker_drv;
systracker_drv = get_mt_systracker_drv();
systracker_drv->systracker_hook_fault =
systracker_platform_hook_fault;
#ifdef SYSTRACKER_TEST_SUIT
systracker_drv->systracker_test_init =
systracker_platform_test_init;
systracker_drv->systracker_test_cleanup =
systracker_platform_test_cleanup;
systracker_drv->systracker_wp_test =
systracker_platform_wp_test;
systracker_drv->systracker_read_timeout_test =
systracker_platform_read_timeout_test;
systracker_drv->systracker_write_timeout_test =
systracker_platform_write_timeout_test;
systracker_drv->systracker_withrecord_test =
systracker_platform_withrecord_test;
systracker_drv->systracker_notimeout_test =
systracker_platform_notimeout_test;
#endif
return 0;
}
arch_initcall(mt_systracker_init);
MODULE_DESCRIPTION("system tracker driver v2.0");
@@ -0,0 +1,19 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y := systracker_platform.o
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
CFLAGS_systracker_platform.o := -DDEBUG
endif
@@ -0,0 +1,289 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <mtk_ram_console.h>
#include <asm/system_misc.h>
#include <asm/traps.h>
#include <linux/signal.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "../systracker_v2.h"
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1;
void __iomem *mm_area1;
#endif
#ifdef CONFIG_ARM64
static int read_timeout_handler(unsigned long addr,
unsigned int fsr, struct pt_regs *regs)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
pr_notice("%s:%d: read timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x,",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
/* return -1 to indicate kernel go on its flow */
return -1;
}
static void write_timeout_handler(struct pt_regs *regs, void *priv)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
pr_debug("%s:%d: write timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
((BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1))) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
}
static int systracker_platform_hook_fault(void)
{
int ret = 0;
/* We use ARM64's synchroneous external abort for read timeout */
hook_fault_code(0x10,
read_timeout_handler,
SIGTRAP,
0,
"Systracker debug exception");
/* for 64bit, we should register async abort handler */
ret = register_async_abort_handler(write_timeout_handler, NULL);
if (ret) {
pr_notice("%s:%d: register_async_abort_handler failed\n",
__func__,
__LINE__);
return -1;
}
return 0;
}
#else
int systracker_handler(unsigned long addr,
unsigned int fsr,
struct pt_regs *regs)
{
int i;
#ifdef SYSTRACKER_TEST_SUIT
writel(readl(p1) & ~(0x1 << 6), p1);
#endif
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
return -1;
}
/* ARM32 version */
static int __init systracker_platform_hook_fault(void)
{
#ifdef CONFIG_ARM_LPAE
hook_fault_code(0x10,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x11,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#else
hook_fault_code(0x8,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x16,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#endif
return 0;
}
#endif
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1;
void __iomem *mm_area1;
static int systracker_platform_test_init(void)
{
p1 = ioremap(0x10001220, 0x4);
/* use mmsys reg base for our test */
mm_area1 = ioremap(0x14000000, 0x4);
return 0;
}
static void systracker_platform_test_cleanup(void)
{
writel(readl(p1) & ~(0x1 << 6), p1);
}
static void systracker_platform_wp_test(void)
{
void __iomem *ptr;
/* use eint reg base as our watchpoint */
ptr = ioremap(0x1000b000, 0x4);
pr_debug("%s:%d: we got p = 0x%p\n", __func__, __LINE__, ptr);
systracker_set_watchpoint_addr(0x1000b000);
systracker_watchpoint_enable();
/* touch it */
writel(0, ptr);
pr_debug("after we touched watchpoint\n");
iounmap(ptr);
}
static void systracker_platform_read_timeout_test(void)
{
/* FIXME: testing
* track_config.enable_slave_err = 0;
* systracker_enable();
*/
writel(readl(p1) | (0x1 << 6), p1);
readl(mm_area1);
writel(readl(p1) & ~(0x1 << 6), p1);
}
static void systracker_platform_write_timeout_test(void)
{
writel(readl(p1) | (0x1 << 6), p1);
writel(0x0, mm_area1);
writel(readl(p1) & ~(0x1 << 6), p1);
}
static void systracker_platform_withrecord_test(void)
{
writel(readl(IOMEM(BUS_DBG_CON)) |
BUS_DBG_CON_HALT_ON_EN, IOMEM(BUS_DBG_CON));
writel(readl(p1) | (0x1 << 6), p1);
readl(mm_area1);
#if 0
/* FIXME: related function not ready on FPGA */
wdt_arch_reset(1);
#endif
}
static void systracker_platform_notimeout_test(void)
{
writel(readl(p1) | (0x1 << 6), p1);
/* disable timeout */
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~(BUS_DBG_CON_TIMEOUT_EN), IOMEM(BUS_DBG_CON_INFRA));
/* read it, should cause bus hang */
readl(mm_area1);
/* never come back */
pr_notice("failed??\n");
}
#endif
/* end of SYSTRACKER_TEST_SUIT */
/*
* mt_systracker_init: initialize driver.
* Always return 0.
*/
static int __init mt_systracker_init(void)
{
struct mt_systracker_driver *systracker_drv;
systracker_drv = get_mt_systracker_drv();
systracker_drv->systracker_hook_fault =
systracker_platform_hook_fault;
#ifdef SYSTRACKER_TEST_SUIT
systracker_drv->systracker_test_init =
systracker_platform_test_init;
systracker_drv->systracker_test_cleanup =
systracker_platform_test_cleanup;
systracker_drv->systracker_wp_test =
systracker_platform_wp_test;
systracker_drv->systracker_read_timeout_test =
systracker_platform_read_timeout_test;
systracker_drv->systracker_write_timeout_test =
systracker_platform_write_timeout_test;
systracker_drv->systracker_withrecord_test =
systracker_platform_withrecord_test;
systracker_drv->systracker_notimeout_test =
systracker_platform_notimeout_test;
#endif
return 0;
}
arch_initcall(mt_systracker_init);
MODULE_DESCRIPTION("system tracker driver v2.0");
@@ -0,0 +1,19 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y := systracker_platform.o
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
CFLAGS_systracker_platform.o := -DDEBUG
endif
@@ -0,0 +1,327 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2016 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <mtk_ram_console.h>
#include <asm/system_misc.h>
#include <asm/traps.h>
#include <linux/signal.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "../systracker_v2.h"
#include <mt-plat/devapc_public.h>
#ifdef CONFIG_ARM64
static int read_timeout_handler(unsigned long addr,
unsigned int fsr, struct pt_regs *regs)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_notice("%s:%d: read timeout\n", __func__, __LINE__);
#ifdef CONFIG_MTK_DEVAPC
if (devapc_vio_check()) {
pr_notice("%s:%d: [DEVAPC] SLVERR/DECERR occurs\n",
__func__, __LINE__);
dump_dbg_info();
} else
pr_info("[DEVAPC] no violation is triggered\n");
#endif
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < 32; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x,",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
/* return -1 to indicate kernel go on its flow */
return -1;
}
static void write_timeout_handler(struct pt_regs *regs, void *priv)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_debug("%s:%d: write timeout\n", __func__, __LINE__);
#ifdef CONFIG_MTK_DEVAPC
if (devapc_vio_check()) {
pr_notice("%s:%d: [DEVAPC] SLVERR/DECERR occurs\n",
__func__, __LINE__);
dump_dbg_info();
} else
pr_info("[DEVAPC] no violation is triggered\n");
#endif
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
((BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1))) {
for (i = 0; i < 32; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
}
static int systracker_platform_hook_fault(void)
{
int ret = 0;
/* We use ARM64's synchroneous external abort for read timeout */
hook_fault_code(0x10,
read_timeout_handler,
SIGTRAP,
0,
"Systracker debug exception");
/* for 64bit, we should register async abort handler */
ret = register_async_abort_handler(write_timeout_handler, NULL);
if (ret) {
pr_notice("%s:%d: register_async_abort_handler failed\n",
__func__,
__LINE__);
return -1;
}
return 0;
}
#else
int systracker_handler(unsigned long addr,
unsigned int fsr,
struct pt_regs *regs)
{
int i;
#ifdef SYSTRACKER_TEST_SUIT
writel(0x1 << 6, p1_clr);
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) & BUS_DBG_CON_IRQ_WP_STA) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
}
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
return -1;
}
/* ARM32 version */
static int __init systracker_platform_hook_fault(void)
{
#ifdef CONFIG_ARM_LPAE
hook_fault_code(0x10,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x11,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#else
hook_fault_code(0x8,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x16,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#endif
return 0;
}
#endif
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1_set;
void __iomem *p1_clr;
void __iomem *mm_area1;
void __iomem *wp_ptr;
static int systracker_platform_test_init(void)
{
p1_set = ioremap(0x100012A0, 0x4);
p1_clr = ioremap(0x100012A4, 0x4);
/* use mmsys reg base for our test */
mm_area1 = ioremap(0x14000000, 0x4);
/* use EMI CONA for our test */
wp_ptr = ioremap(0x10219000, 0x4);
return 0;
}
static void systracker_platform_test_cleanup(void)
{
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_wp_test(void)
{
unsigned int val;
pr_info("%s:%d: we use ptr = 0x%p\n", __func__, __LINE__, wp_ptr);
systracker_set_watchpoint_addr(0x10219000);
systracker_watchpoint_enable();
/* touch it */
val = readl(wp_ptr);
pr_info("after we touched watchpoint %x\n", val);
}
static void systracker_platform_read_timeout_test(void)
{
/* FIXME: testing
* track_config.enable_slave_err = 0;
* systracker_enable();
*/
writel(0x1 << 6, p1_set);
readl(mm_area1);
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_write_timeout_test(void)
{
writel(0x1 << 6, p1_set);
writel(0x0, mm_area1);
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_withrecord_test(void)
{
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~BUS_DBG_CON_HALT_ON_EN, IOMEM(BUS_DBG_CON_INFRA));
writel(0x1 << 6, p1_set);
readl(mm_area1);
}
static void systracker_platform_notimeout_test(void)
{
writel(0x1 << 6, p1_set);
/* disable timeout */
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~(BUS_DBG_CON_TIMEOUT_EN), IOMEM(BUS_DBG_CON_INFRA));
/* read it, should cause bus hang */
readl(mm_area1);
/* never come back */
pr_notice("failed??\n");
}
#endif
/* end of SYSTRACKER_TEST_SUIT */
/*
* mt_systracker_init: initialize driver.
* Always return 0.
*/
static int __init mt_systracker_init(void)
{
struct mt_systracker_driver *systracker_drv;
systracker_drv = get_mt_systracker_drv();
systracker_drv->systracker_hook_fault =
systracker_platform_hook_fault;
#ifdef SYSTRACKER_TEST_SUIT
systracker_drv->systracker_test_init =
systracker_platform_test_init;
systracker_drv->systracker_test_cleanup =
systracker_platform_test_cleanup;
systracker_drv->systracker_wp_test =
systracker_platform_wp_test;
systracker_drv->systracker_read_timeout_test =
systracker_platform_read_timeout_test;
systracker_drv->systracker_write_timeout_test =
systracker_platform_write_timeout_test;
systracker_drv->systracker_withrecord_test =
systracker_platform_withrecord_test;
systracker_drv->systracker_notimeout_test =
systracker_platform_notimeout_test;
#endif
return 0;
}
arch_initcall(mt_systracker_init);
MODULE_DESCRIPTION("system tracker driver v2.0");
@@ -0,0 +1,19 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y := systracker_platform.o
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
CFLAGS_systracker_platform.o := -DDEBUG
endif
@@ -0,0 +1,306 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <mtk_ram_console.h>
#include <asm/system_misc.h>
#include <asm/traps.h>
#include <linux/signal.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "../systracker_v2.h"
#ifdef CONFIG_ARM64
static int read_timeout_handler(unsigned long addr,
unsigned int fsr, struct pt_regs *regs)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_notice("%s:%d: read timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < 32; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x,",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
/* return -1 to indicate kernel go on its flow */
return -1;
}
static void write_timeout_handler(struct pt_regs *regs, void *priv)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_debug("%s:%d: write timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
((BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1))) {
for (i = 0; i < 32; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
}
static int systracker_platform_hook_fault(void)
{
int ret = 0;
/* We use ARM64's synchroneous external abort for read timeout */
hook_fault_code(0x10,
read_timeout_handler,
SIGTRAP,
0,
"Systracker debug exception");
/* for 64bit, we should register async abort handler */
ret = register_async_abort_handler(write_timeout_handler, NULL);
if (ret) {
pr_notice("%s:%d: register_async_abort_handler failed\n",
__func__,
__LINE__);
return -1;
}
return 0;
}
#else
int systracker_handler(unsigned long addr,
unsigned int fsr,
struct pt_regs *regs)
{
int i;
#ifdef SYSTRACKER_TEST_SUIT
writel(0x1 << 6, p1_clr);
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) & BUS_DBG_CON_IRQ_WP_STA) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
}
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
return -1;
}
/* ARM32 version */
static int __init systracker_platform_hook_fault(void)
{
#ifdef CONFIG_ARM_LPAE
hook_fault_code(0x10,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x11,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#else
hook_fault_code(0x8,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x16,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#endif
return 0;
}
#endif
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1_set;
void __iomem *p1_clr;
void __iomem *mm_area1;
void __iomem *wp_ptr;
static int systracker_platform_test_init(void)
{
p1_set = ioremap(0x10001250, 0x4);
p1_clr = ioremap(0x10001e98, 0x4);
/* use mmsys reg base for our test */
mm_area1 = ioremap(0x13000000, 0x4);
/* use EMI CONA for our test */
wp_ptr = ioremap(0x10219000, 0x4);
return 0;
}
static void systracker_platform_test_cleanup(void)
{
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_wp_test(void)
{
unsigned int val;
pr_info("%s:%d: we use ptr = 0x%p\n", __func__, __LINE__, wp_ptr);
systracker_set_watchpoint_addr(0x10219000);
systracker_set_watchpoint_mask(0x7fff);
systracker_watchpoint_enable();
/* touch it */
val = readl(wp_ptr);
pr_info("after we touched watchpoint %x\n", val);
}
static void systracker_platform_read_timeout_test(void)
{
/* FIXME: testing
* track_config.enable_slave_err = 0;
* systracker_enable();
*/
void __iomem *tmp = ioremap(0x13000000, 0x4);
pr_info("0x13000000=0x%x\n", readl(tmp));
}
static void systracker_platform_write_timeout_test(void)
{
void __iomem *tmp = ioremap(0x13000000, 0x4);
writel(0xdeaddead, tmp);
}
static void systracker_platform_withrecord_test(void)
{
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~BUS_DBG_CON_HALT_ON_EN, IOMEM(BUS_DBG_CON_INFRA));
writel(0x1 << 6, p1_set);
readl(mm_area1);
}
static void systracker_platform_notimeout_test(void)
{
writel(0x1 << 6, p1_set);
/* disable timeout */
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~(BUS_DBG_CON_TIMEOUT_EN), IOMEM(BUS_DBG_CON_INFRA));
/* read it, should cause bus hang */
readl(mm_area1);
/* never come back */
pr_notice("failed??\n");
}
#endif
/* end of SYSTRACKER_TEST_SUIT */
/*
* mt_systracker_init: initialize driver.
* Always return 0.
*/
static int __init mt_systracker_init(void)
{
struct mt_systracker_driver *systracker_drv;
systracker_drv = get_mt_systracker_drv();
systracker_drv->systracker_hook_fault =
systracker_platform_hook_fault;
#ifdef SYSTRACKER_TEST_SUIT
systracker_drv->systracker_test_init =
systracker_platform_test_init;
systracker_drv->systracker_test_cleanup =
systracker_platform_test_cleanup;
systracker_drv->systracker_wp_test =
systracker_platform_wp_test;
systracker_drv->systracker_read_timeout_test =
systracker_platform_read_timeout_test;
systracker_drv->systracker_write_timeout_test =
systracker_platform_write_timeout_test;
systracker_drv->systracker_withrecord_test =
systracker_platform_withrecord_test;
systracker_drv->systracker_notimeout_test =
systracker_platform_notimeout_test;
#endif
return 0;
}
arch_initcall(mt_systracker_init);
MODULE_DESCRIPTION("system tracker driver v2.0");
@@ -0,0 +1,19 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y := systracker_platform.o
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
CFLAGS_systracker_platform.o := -DDEBUG
endif
@@ -0,0 +1,313 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <mtk_ram_console.h>
#include <asm/system_misc.h>
#include <asm/traps.h>
#include <linux/signal.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "../systracker_v2.h"
#ifdef CONFIG_ARM64
static int read_timeout_handler(unsigned long addr,
unsigned int fsr, struct pt_regs *regs)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_notice("%s:%d: read timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < 32; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x,",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
/* return -1 to indicate kernel go on its flow */
return -1;
}
static void write_timeout_handler(struct pt_regs *regs, void *priv)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_debug("%s:%d: write timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
((BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1))) {
for (i = 0; i < 32; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
}
static int systracker_platform_hook_fault(void)
{
int ret = 0;
/* We use ARM64's synchroneous external abort for read timeout */
hook_fault_code(0x10,
read_timeout_handler,
SIGTRAP,
0,
"Systracker debug exception");
/* for 64bit, we should register async abort handler */
ret = register_async_abort_handler(write_timeout_handler, NULL);
if (ret) {
pr_notice("%s:%d: register_async_abort_handler failed\n",
__func__,
__LINE__);
return -1;
}
return 0;
}
#else
int systracker_handler(unsigned long addr,
unsigned int fsr,
struct pt_regs *regs)
{
int i;
#ifdef SYSTRACKER_TEST_SUIT
writel(0x1 << 6, p1_clr);
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) & BUS_DBG_CON_IRQ_WP_STA) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
}
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
return -1;
}
/* ARM32 version */
static int __init systracker_platform_hook_fault(void)
{
#ifdef CONFIG_ARM_LPAE
hook_fault_code(0x10,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x11,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#else
hook_fault_code(0x8,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x16,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#endif
return 0;
}
#endif
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1_set;
void __iomem *p1_clr;
void __iomem *mm_area1;
void __iomem *wp_ptr;
static int systracker_platform_test_init(void)
{
p1_set = ioremap(0x10001250, 0x4);
p1_clr = ioremap(0x10001e98, 0x4);
/* use mmsys reg base for our test */
mm_area1 = ioremap(0x13000000, 0x4);
/* use EMI CONA for our test */
wp_ptr = ioremap(0x10219000, 0x4);
return 0;
}
static void systracker_platform_test_cleanup(void)
{
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_wp_test(void)
{
unsigned int val;
pr_info("%s:%d: we use ptr = 0x%p\n", __func__, __LINE__, wp_ptr);
systracker_set_watchpoint_addr(0x10219000);
systracker_set_watchpoint_mask(0x7fff);
systracker_watchpoint_enable();
/* touch it */
val = readl(wp_ptr);
pr_info("after we touched watchpoint %x\n", val);
}
static void systracker_platform_read_timeout_test(void)
{
/* FIXME: testing
* track_config.enable_slave_err = 0;
* systracker_enable();
*/
writel(readl(p1_set) | (0x1 << 21), p1_set);
writel(readl(p1_clr) & ~(0x1 << 11), p1_clr);
readl(mm_area1);
}
static void systracker_platform_write_timeout_test(void)
{
writel(readl(p1_set) | (0x1 << 21), p1_set);
writel(readl(p1_clr) & ~(0x1 << 11), p1_clr);
writel(0x1, mm_area1);
writel(0x1 << 6, p1_set);
writel(0x0, mm_area1);
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_withrecord_test(void)
{
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~BUS_DBG_CON_HALT_ON_EN, IOMEM(BUS_DBG_CON_INFRA));
writel(0x1 << 6, p1_set);
readl(mm_area1);
}
static void systracker_platform_notimeout_test(void)
{
writel(0x1 << 6, p1_set);
/* disable timeout */
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~(BUS_DBG_CON_TIMEOUT_EN), IOMEM(BUS_DBG_CON_INFRA));
/* read it, should cause bus hang */
readl(mm_area1);
/* never come back */
pr_notice("failed??\n");
}
#endif
/* end of SYSTRACKER_TEST_SUIT */
/*
* mt_systracker_init: initialize driver.
* Always return 0.
*/
static int __init mt_systracker_init(void)
{
struct mt_systracker_driver *systracker_drv;
systracker_drv = get_mt_systracker_drv();
systracker_drv->systracker_hook_fault =
systracker_platform_hook_fault;
#ifdef SYSTRACKER_TEST_SUIT
systracker_drv->systracker_test_init =
systracker_platform_test_init;
systracker_drv->systracker_test_cleanup =
systracker_platform_test_cleanup;
systracker_drv->systracker_wp_test =
systracker_platform_wp_test;
systracker_drv->systracker_read_timeout_test =
systracker_platform_read_timeout_test;
systracker_drv->systracker_write_timeout_test =
systracker_platform_write_timeout_test;
systracker_drv->systracker_withrecord_test =
systracker_platform_withrecord_test;
systracker_drv->systracker_notimeout_test =
systracker_platform_notimeout_test;
#endif
return 0;
}
arch_initcall(mt_systracker_init);
MODULE_DESCRIPTION("system tracker driver v2.0");
@@ -0,0 +1,19 @@
#
# Copyright (C) 2015 MediaTek Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
obj-y := systracker_platform.o
ifeq ($(CONFIG_MTK_ENG_BUILD),y)
CFLAGS_systracker_platform.o := -DDEBUG
endif
@@ -0,0 +1,309 @@
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (c) 2019 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <mtk_ram_console.h>
#include <asm/system_misc.h>
#include <asm/traps.h>
#include <linux/signal.h>
#include <mt-plat/sync_write.h>
#include <mt-plat/mtk_io.h>
#include "../systracker_v2.h"
#ifdef CONFIG_ARM64
static int read_timeout_handler(unsigned long addr,
unsigned int fsr, struct pt_regs *regs)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_notice("%s:%d: read timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < 32; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x,",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
/* return -1 to indicate kernel go on its flow */
return -1;
}
static void write_timeout_handler(struct pt_regs *regs, void *priv)
{
int i = 0;
#ifdef SYSTRACKER_TEST_SUIT
systracker_test_cleanup();
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_WP_STA | BUS_DBG_CON_IRQ_WP_RD_STA)) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
} else
pr_debug("%s:%d: write timeout\n", __func__, __LINE__);
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
((BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1))) {
for (i = 0; i < 32; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
}
static int systracker_platform_hook_fault(void)
{
int ret = 0;
/* We use ARM64's synchroneous external abort for read timeout */
hook_fault_code(0x10,
read_timeout_handler,
SIGTRAP,
0,
"Systracker debug exception");
/* for 64bit, we should register async abort handler */
ret = register_async_abort_handler(write_timeout_handler, NULL);
if (ret) {
pr_notice("%s:%d: register_async_abort_handler failed\n",
__func__,
__LINE__);
return -1;
}
return 0;
}
#else
int systracker_handler(unsigned long addr,
unsigned int fsr,
struct pt_regs *regs)
{
int i;
#ifdef SYSTRACKER_TEST_SUIT
writel(0x1 << 6, p1_clr);
#endif
/* avoid nested hit */
if (readl(IOMEM(BUS_DBG_CON)) & BUS_DBG_CON_IRQ_WP_STA) {
pr_notice("%s:%d: WP_TRACKER hit\n", __func__, __LINE__);
systracker_watchpoint_disable();
}
aee_dump_backtrace(regs, NULL);
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AR_STA0|BUS_DBG_CON_IRQ_AR_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AR_TRACKER Timeout Entry[%d]: ReadAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AR_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AR_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AR_TRANS_TID(i))));
}
}
if (readl(IOMEM(BUS_DBG_CON)) &
(BUS_DBG_CON_IRQ_AW_STA0|BUS_DBG_CON_IRQ_AW_STA1)) {
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
pr_notice("AW_TRACKER Timeout Entry[%d]: WriteAddr:0x%x, ",
i,
readl(IOMEM(BUS_DBG_AW_TRACK_L(i))));
pr_notice("Length:0x%x, TransactionID:0x%x!\n",
readl(IOMEM(BUS_DBG_AW_TRACK_H(i))),
readl(IOMEM(BUS_DBG_AW_TRANS_TID(i))));
}
pr_notice("W_TRACK_DATA6:0x%x, W_TRACK_DATA7:0x%x, W_TRACK_DATA_VALID:0x%x!\n",
readl(IOMEM(BUS_DBG_W_TRACK_DATA6)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA7)),
readl(IOMEM(BUS_DBG_W_TRACK_DATA_VALID)));
}
return -1;
}
/* ARM32 version */
static int __init systracker_platform_hook_fault(void)
{
#ifdef CONFIG_ARM_LPAE
hook_fault_code(0x10,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x11,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#else
hook_fault_code(0x8,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
hook_fault_code(0x16,
systracker_handler,
SIGTRAP,
0,
"Systracker debug exception");
#endif
return 0;
}
#endif
#ifdef SYSTRACKER_TEST_SUIT
void __iomem *p1_set;
void __iomem *p1_clr;
void __iomem *mm_area1;
void __iomem *wp_ptr;
static int systracker_platform_test_init(void)
{
p1_set = ioremap(0x100012A0, 0x4);
p1_clr = ioremap(0x100012A4, 0x4);
/* use mmsys reg base for our test */
mm_area1 = ioremap(0x14000000, 0x4);
/* use EMI CONA for our test */
wp_ptr = ioremap(0x10219000, 0x4);
return 0;
}
static void systracker_platform_test_cleanup(void)
{
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_wp_test(void)
{
unsigned int val;
pr_info("%s:%d: we use ptr = 0x%p\n", __func__, __LINE__, wp_ptr);
systracker_set_watchpoint_addr(0x10219000);
systracker_watchpoint_enable();
/* touch it */
val = readl(wp_ptr);
pr_info("after we touched watchpoint %x\n", val);
}
static void systracker_platform_read_timeout_test(void)
{
/* FIXME: testing
* track_config.enable_slave_err = 0;
* systracker_enable();
*/
writel(0x1 << 6, p1_set);
readl(mm_area1);
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_write_timeout_test(void)
{
writel(0x1 << 6, p1_set);
writel(0x0, mm_area1);
writel(0x1 << 6, p1_clr);
}
static void systracker_platform_withrecord_test(void)
{
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~BUS_DBG_CON_HALT_ON_EN, IOMEM(BUS_DBG_CON_INFRA));
writel(0x1 << 6, p1_set);
readl(mm_area1);
}
static void systracker_platform_notimeout_test(void)
{
writel(0x1 << 6, p1_set);
/* disable timeout */
writel(readl(IOMEM(BUS_DBG_CON_INFRA)) &
~(BUS_DBG_CON_TIMEOUT_EN), IOMEM(BUS_DBG_CON_INFRA));
/* read it, should cause bus hang */
readl(mm_area1);
/* never come back */
pr_notice("failed??\n");
}
#endif
/* end of SYSTRACKER_TEST_SUIT */
/*
* mt_systracker_init: initialize driver.
* Always return 0.
*/
static int __init mt_systracker_init(void)
{
struct mt_systracker_driver *systracker_drv;
systracker_drv = get_mt_systracker_drv();
systracker_drv->systracker_hook_fault =
systracker_platform_hook_fault;
#ifdef SYSTRACKER_TEST_SUIT
systracker_drv->systracker_test_init =
systracker_platform_test_init;
systracker_drv->systracker_test_cleanup =
systracker_platform_test_cleanup;
systracker_drv->systracker_wp_test =
systracker_platform_wp_test;
systracker_drv->systracker_read_timeout_test =
systracker_platform_read_timeout_test;
systracker_drv->systracker_write_timeout_test =
systracker_platform_write_timeout_test;
systracker_drv->systracker_withrecord_test =
systracker_platform_withrecord_test;
systracker_drv->systracker_notimeout_test =
systracker_platform_notimeout_test;
#endif
return 0;
}
arch_initcall(mt_systracker_init);
MODULE_DESCRIPTION("system tracker driver v2.0");
@@ -0,0 +1,598 @@
// 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/platform_device.h>
#include <linux/kallsyms.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/signal.h>
#include <linux/cpu.h>
#include "systracker_v2.h"
void __iomem *BUS_DBG_BASE;
void __iomem *BUS_DBG_INFRA_BASE;
struct systracker_config_t track_config;
struct systracker_entry_t track_entry;
static const struct of_device_id systracker_of_ids[] = {
{ .compatible = "mediatek,bus_dbg-v2", },
{}
};
static struct mt_systracker_driver mt_systracker_drv = {
.driver = {
.driver = {
.name = "systracker",
.bus = &platform_bus_type,
.owner = THIS_MODULE,
.of_match_table = systracker_of_ids,
},
.probe = systracker_probe,
.remove = systracker_remove,
.suspend = systracker_suspend,
.resume = systracker_resume,
},
.device = {
.name = "systracker",
},
};
static int systracker_probe(struct platform_device *pdev)
{
void __iomem *infra_ao_base;
unsigned int bus_dbg_con_offset;
pr_notice("systracker probe\n");
/* iomap register */
BUS_DBG_BASE = of_iomap(pdev->dev.of_node, 0);
if (!BUS_DBG_BASE) {
pr_notice("can't of_iomap for systracker!!\n");
return -ENOMEM;
}
pr_notice("of_iomap for systracker @ 0x%p\n", BUS_DBG_BASE);
infra_ao_base = of_iomap(pdev->dev.of_node, 1);
if (!infra_ao_base) {
pr_notice("[systracker] bus_dbg_con is in infra\n");
BUS_DBG_INFRA_BASE = BUS_DBG_BASE;
} else {
pr_notice("[systracker] bus_dbg_con is in infra_ao\n");
if (of_property_read_u32
(pdev->dev.of_node, "mediatek,bus_dbg_con_offset",
&bus_dbg_con_offset)) {
pr_notice
("[systracker] cannot get bus_dbg_con_offset\n");
return -ENODEV;
}
BUS_DBG_INFRA_BASE = infra_ao_base + bus_dbg_con_offset;
}
/* save entry info */
save_entry();
memset(&track_config, 0, sizeof(struct systracker_config_t));
track_config.enable_timeout = 1;
track_config.enable_slave_err = 1;
track_config.enable_irq = 0;
track_config.timeout_ms = 100;
track_config.timeout2_ms = 2000;
systracker_reset();
systracker_enable();
return 0;
}
int systracker_remove(struct platform_device *pdev)
{
return 0;
}
int systracker_suspend(struct platform_device *pdev, pm_message_t state)
{
return 0;
}
static int systracker_resume_default(struct platform_device *pdev)
{
if (track_config.state || track_config.enable_wp)
systracker_enable();
return 0;
}
int systracker_resume(struct platform_device *pdev)
{
return systracker_resume_default(pdev);
}
void save_entry(void)
{
int i = 0;
track_entry.dbg_con = readl(BUS_DBG_CON);
track_entry.dbg_con_infra = readl(BUS_DBG_CON_INFRA);
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
track_entry.ar_track_l[i] =
readl(BUS_DBG_AR_TRACK_L(i));
track_entry.ar_track_h[i] =
readl(BUS_DBG_AR_TRACK_H(i));
track_entry.ar_trans_tid[i] =
readl(BUS_DBG_AR_TRANS_TID(i));
track_entry.aw_track_l[i] =
readl(BUS_DBG_AW_TRACK_L(i));
track_entry.aw_track_h[i] =
readl(BUS_DBG_AW_TRACK_H(i));
track_entry.aw_trans_tid[i] =
readl(BUS_DBG_AW_TRANS_TID(i));
}
track_entry.w_track_data6 = readl(BUS_DBG_W_TRACK_DATA6);
track_entry.w_track_data7 = readl(BUS_DBG_W_TRACK_DATA7);
track_entry.w_track_data_valid =
readl(BUS_DBG_W_TRACK_DATA_VALID);
}
static int systracker_watchpoint_enable_default(void)
{
unsigned int con;
track_config.enable_wp = 1;
writel(track_config.wp_phy_address, BUS_DBG_WP);
writel(0x00000000, BUS_DBG_WP_MASK);
con = readl(BUS_DBG_CON_INFRA) | BUS_DBG_CON_WP_EN;
writel(con, BUS_DBG_CON_INFRA);
/* ensure access complete */
mb();
return 0;
}
int systracker_watchpoint_enable(void)
{
return systracker_watchpoint_enable_default();
}
static int systracker_watchpoint_disable_default(void)
{
track_config.enable_wp = 0;
writel(readl(BUS_DBG_CON_INFRA) & (~BUS_DBG_CON_WP_EN),
BUS_DBG_CON_INFRA);
/* ensure access complete */
mb();
return 0;
}
int systracker_watchpoint_disable(void)
{
return systracker_watchpoint_disable_default();
}
void systracker_reset_default(void)
{
writel(readl(BUS_DBG_CON) |
BUS_DBG_CON_SW_RST, BUS_DBG_CON);
writel(readl(BUS_DBG_CON) |
BUS_DBG_CON_IRQ_CLR, BUS_DBG_CON);
writel(readl(BUS_DBG_CON) |
BUS_DBG_CON_TIMEOUT_CLR, BUS_DBG_CON);
/* ensure access complete */
mb();
}
void systracker_reset(void)
{
systracker_reset_default();
}
unsigned int systracker_timeout_value_default(void)
{
/* prescale = (133 * (10 ^ 6)) / 16 = 8312500/s */
return (BUS_DBG_BUS_MHZ * 1000 / 16) * track_config.timeout_ms;
}
unsigned int systracker_timeout2_value_default(void)
{
/* prescale = (133 * (10 ^ 6)) / 16 = 8312500/s */
return (BUS_DBG_BUS_MHZ * 1000 / 16) * track_config.timeout2_ms;
}
unsigned int systracker_timeout_value(void)
{
return systracker_timeout_value_default();
}
unsigned int systracker_timeout2_value(void)
{
return systracker_timeout2_value_default();
}
void systracker_enable_default(void)
{
unsigned int con;
unsigned int timer_control_value;
timer_control_value = systracker_timeout_value();
#ifndef CONFIG_FPGA_EARLY_PORTING
writel(timer_control_value, BUS_DBG_TIMER_CON0);
#else
writel(BUS_DBG_MAX_TIMEOUT_VAL, BUS_DBG_TIMER_CON0);
#endif
timer_control_value = systracker_timeout2_value();
#ifndef CONFIG_FPGA_EARLY_PORTING
writel(timer_control_value, BUS_DBG_TIMER_CON1);
#else
writel(BUS_DBG_MAX_TIMEOUT_VAL, BUS_DBG_TIMER_CON1);
#endif
track_config.state = 1;
con = BUS_DBG_CON_BUS_DBG_EN | BUS_DBG_CON_BUS_OT_EN;
if (track_config.enable_timeout)
con |= BUS_DBG_CON_TIMEOUT_EN;
if (track_config.enable_slave_err)
con |= BUS_DBG_CON_SLV_ERR_EN;
if (track_config.enable_irq) {
con |= BUS_DBG_CON_IRQ_EN;
con &= ~BUS_DBG_CON_IRQ_WP_EN;
}
con |= BUS_DBG_CON_HALT_ON_EN;
writel(con, BUS_DBG_CON_INFRA);
/* ensure access complete */
mb();
}
void systracker_enable(void)
{
systracker_enable_default();
}
void enable_systracker(void)
{
systracker_enable();
}
static void systracker_disable_default(void)
{
track_config.state = 0;
writel(readl(BUS_DBG_CON_INFRA) &
~BUS_DBG_CON_BUS_DBG_EN, BUS_DBG_CON_INFRA);
/* ensure access complete */
mb();
}
void systracker_disable(void)
{
systracker_disable_default();
}
int systracker_test_init(void)
{
if (mt_systracker_drv.systracker_test_init)
return mt_systracker_drv.systracker_test_init();
pr_notice("mt_systracker_drv.%s is NULL", __func__);
return -1;
}
int tracker_dump(char *buf)
{
char *ptr = buf;
unsigned int reg_value;
int i;
unsigned int entry_valid;
unsigned int entry_secure;
unsigned int entry_tid;
unsigned int entry_id;
unsigned int entry_address;
unsigned int entry_data_size;
unsigned int entry_burst_length;
{
/* Get tracker info and save to buf */
/* BUS_DBG_AR_TRACK_L(__n)
* [31:0] ARADDR: DBG read tracker entry read address
*/
/* BUS_DBG_AR_TRACK_H(__n)
* [21] Valid:DBG read tracker entry valid
* [20:8] ARID:DBG read tracker entry read ID
* [6:4] ARSIZE:DBG read tracker entry read data size
* [3:0] ARLEN: DBG read tracker entry read burst length
*/
/* BUS_DBG_AR_TRACK_TID(__n)
* [2:0] BUS_DBG_AR_TRANS0_ENTRY_ID:
* DBG read tracker entry ID of 1st transaction
*/
ptr += sprintf(ptr,
"[TRACKER] BUS_DBG_CON = (0x%x, 0x%x), T0= 0x%x, T1 = 0x%x\n",
track_entry.dbg_con,
readl(BUS_DBG_CON),
readl(BUS_DBG_TIMER_CON0),
readl(BUS_DBG_TIMER_CON1));
ptr += sprintf(ptr, "BUS_DBG_CON_INFRA = (0x%x, 0x%x)\n",
track_entry.dbg_con_infra,
readl(BUS_DBG_CON_INFRA));
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
entry_address = track_entry.ar_track_l[i];
reg_value = track_entry.ar_track_h[i];
entry_valid =
extract_n2mbits(reg_value, 22, 22);
entry_secure =
extract_n2mbits(reg_value, 21, 21);
entry_id =
extract_n2mbits(reg_value, 8, 20);
entry_data_size =
extract_n2mbits(reg_value, 4, 6);
entry_burst_length =
extract_n2mbits(reg_value, 0, 3);
entry_tid = track_entry.ar_trans_tid[i];
ptr += sprintf(ptr,
"read entry = %d, valid = 0x%x, secure = 0x%x,",
i, entry_valid, entry_secure);
ptr += sprintf(ptr,
"read id = 0x%x, address = 0x%x, data_size = 0x%x,",
entry_id, entry_address, entry_data_size);
ptr += sprintf(ptr, "burst_length = 0x%x\n",
entry_burst_length);
}
/* BUS_DBG_AW_TRACK_L(__n)
* [31:0] AWADDR: DBG write tracker entry write address
*/
/* BUS_DBG_AW_TRACK_H(__n)
* [21] Valid:DBG write tracker entry valid
* [20:8] ARID:DBG write tracker entry write ID
* [6:4] ARSIZE:DBG write tracker entry write data size
* [3:0] ARLEN: DBG write tracker entry write burst length
*/
/* BUS_DBG_AW_TRACK_TID(__n)
* [2:0] BUS_DBG_AW_TRANS0_ENTRY_ID:
* DBG write tracker entry ID of 1st transaction
*/
for (i = 0; i < BUS_DBG_NUM_TRACKER; i++) {
entry_address = track_entry.aw_track_l[i];
reg_value = track_entry.aw_track_h[i];
entry_valid =
extract_n2mbits(reg_value, 22, 22);
entry_secure =
extract_n2mbits(reg_value, 21, 21);
entry_id =
extract_n2mbits(reg_value, 8, 20);
entry_data_size =
extract_n2mbits(reg_value, 4, 6);
entry_burst_length =
extract_n2mbits(reg_value, 0, 3);
entry_tid = track_entry.aw_trans_tid[i];
ptr += sprintf(ptr,
"write entry = %d, valid = 0x%x, secure = 0x%x,",
i, entry_valid, entry_secure);
ptr += sprintf(ptr,
"read id = 0x%x, address = 0x%x, data_size = 0x%x, ",
entry_id, entry_address, entry_data_size);
ptr += sprintf(ptr,
"burst_length = 0x%x\n",
entry_burst_length);
}
ptr += sprintf(ptr,
"write entry ~ 6, valid = 0x%x, data = 0x%x\n",
((track_entry.w_track_data_valid&(0x1<<6))>>6),
track_entry.w_track_data6);
ptr += sprintf(ptr,
"write entry ~ 7, valid = 0x%x, data = 0x%x\n",
((track_entry.w_track_data_valid&(0x1<<7))>>7),
track_entry.w_track_data7);
return strlen(buf);
}
return -1;
}
static ssize_t tracker_run_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE,
"BUS_DBG_CON=0x%x, BUS_DBG_CON_INFRA=0x%x\n",
readl(BUS_DBG_CON),
readl(BUS_DBG_CON_INFRA));
}
static ssize_t tracker_run_store(struct device_driver *driver,
const char *buf, size_t count)
{
unsigned int value;
if (kstrtou32(buf, 10, &value))
return -EINVAL;
if (value == 1)
systracker_enable();
else if (value == 0)
systracker_disable();
else
return -EINVAL;
return count;
}
DRIVER_ATTR_RW(tracker_run);
static ssize_t enable_wp_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%x\n", track_config.enable_wp);
}
static ssize_t enable_wp_store(struct device_driver *driver,
const char *buf, size_t count)
{
unsigned int value;
if (kstrtou32(buf, 10, &value))
return -EINVAL;
if (value == 1)
systracker_watchpoint_enable();
else if (value == 0)
systracker_watchpoint_disable();
else
return -EINVAL;
return count;
}
static DRIVER_ATTR_RW(enable_wp);
static ssize_t set_wp_address_show(struct device_driver *driver, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%x\n", track_config.wp_phy_address);
}
int systracker_set_watchpoint_addr(unsigned int addr)
{
if (mt_systracker_drv.set_watchpoint_address)
return mt_systracker_drv.set_watchpoint_address(addr);
track_config.wp_phy_address = addr;
return 0;
}
static ssize_t set_wp_address_store
(struct device_driver *driver, const char *buf, size_t count)
{
unsigned int value;
int ret;
ret = kstrtou32(buf, 16, &value);
pr_debug("watch address:0x%x, ret = %d\n", value, ret);
systracker_set_watchpoint_addr(value);
return count;
}
static DRIVER_ATTR_RW(set_wp_address);
static ssize_t tracker_entry_dump_show
(struct device_driver *driver, char *buf)
{
int ret = tracker_dump(buf);
if (ret == -1)
pr_notice("Dump error in %s, %d\n", __func__, __LINE__);
return strlen(buf);
}
static ssize_t tracker_swtrst_show(struct device_driver *driver, char *buf)
{
return 0;
}
static ssize_t tracker_swtrst_store
(struct device_driver *driver, const char *buf, size_t count)
{
writel(readl(BUS_DBG_CON) |
BUS_DBG_CON_SW_RST, BUS_DBG_CON);
return count;
}
static DRIVER_ATTR_RW(tracker_swtrst);
static ssize_t tracker_entry_dump_store
(struct device_driver *driver, const char *buf, size_t count)
{
return count;
}
static DRIVER_ATTR_RW(tracker_entry_dump);
static ssize_t tracker_last_status_show
(struct device_driver *driver, char *buf)
{
if (track_entry.dbg_con & BUS_DBG_CON_TIMEOUT)
return snprintf(buf, PAGE_SIZE, "1\n");
else
return snprintf(buf, PAGE_SIZE, "0\n");
}
static ssize_t tracker_last_status_store
(struct device_driver *driver, const char *buf, size_t count)
{
return count;
}
static DRIVER_ATTR_RW(tracker_last_status);
/*
* driver initialization entry point
*/
static int __init systracker_init(void)
{
int err = 0;
int ret = 0;
err = platform_driver_register(&mt_systracker_drv.driver);
if (err)
return err;
/* Create sysfs entry */
ret = driver_create_file(&mt_systracker_drv.driver.driver,
&driver_attr_tracker_entry_dump);
ret |= driver_create_file(&mt_systracker_drv.driver.driver,
&driver_attr_tracker_run);
ret |= driver_create_file(&mt_systracker_drv.driver.driver,
&driver_attr_enable_wp);
ret |= driver_create_file(&mt_systracker_drv.driver.driver,
&driver_attr_set_wp_address);
ret |= driver_create_file(&mt_systracker_drv.driver.driver,
&driver_attr_tracker_swtrst);
ret |= driver_create_file(&mt_systracker_drv.driver.driver,
&driver_attr_tracker_last_status);
if (ret)
pr_notice("Fail to create systracker_drv sysfs files");
pr_debug("systracker init done\n");
return 0;
}
/*
* driver exit point
*/
static void __exit systracker_exit(void)
{
}
arch_initcall_sync(systracker_init);
module_exit(systracker_exit);
@@ -0,0 +1,160 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (C) 2019 MediaTek Inc.
*/
#ifndef __SYSTRAKCER_V2_H__
#define __SYSTRAKCER_V2_H__
#include <linux/platform_device.h>
#define BUS_DBG_CON (BUS_DBG_BASE)
#define BUS_DBG_CON_INFRA (BUS_DBG_INFRA_BASE)
#define BUS_DBG_TIMER_CON0 (BUS_DBG_BASE + 0x0004)
#define BUS_DBG_TIMER_CON1 (BUS_DBG_BASE + 0x0008)
#define BUS_DBG_TIMER_R0 (BUS_DBG_BASE + 0x000C)
#define BUS_DBG_TIMER_R1 (BUS_DBG_BASE + 0x0010)
#define BUS_DBG_WP (BUS_DBG_BASE + 0x0014)
#define BUS_DBG_WP_MASK (BUS_DBG_BASE + 0x0018)
#define BUS_DBG_MON (BUS_DBG_BASE + 0x001C)
#define BUS_DBG_W_TRACK_DATA_VALID (BUS_DBG_BASE + 0x0020)
#define BUS_DBG_AR_TRACK_L(__n) (BUS_DBG_BASE + 0x0100 + 8 * (__n))
#define BUS_DBG_AR_TRACK_H(__n) (BUS_DBG_BASE + 0x0104 + 8 * (__n))
#define BUS_DBG_AR_TRANS_TID(__n) (BUS_DBG_BASE + 0x0180 + 4 * (__n))
#define BUS_DBG_AW_TRACK_L(__n) (BUS_DBG_BASE + 0x0200 + 8 * (__n))
#define BUS_DBG_AW_TRACK_H(__n) (BUS_DBG_BASE + 0x0204 + 8 * (__n))
#define BUS_DBG_AW_TRANS_TID(__n) (BUS_DBG_BASE + 0x0280 + 4 * (__n))
#define BUS_DBG_W_TRACK_DATA6 (BUS_DBG_BASE + 0x02D8)
#define BUS_DBG_W_TRACK_DATA7 (BUS_DBG_BASE + 0x02DC)
#define BUS_DBG_BUS_MHZ (266)
#define BUS_DBG_NUM_TRACKER (8)
#define BUS_DBG_CON_BUS_DBG_EN (0x00000001)
#define BUS_DBG_CON_TIMEOUT_EN (0x00000002)
#define BUS_DBG_CON_SLV_ERR_EN (0x00000004)
#define BUS_DBG_CON_WP_EN (0x00000108)
#define BUS_DBG_CON_IRQ_AR_EN (0x00000010)
#define BUS_DBG_CON_IRQ_AW_EN (0x00000020)
#define BUS_DBG_CON_SW_RST_DN (0x00000040)
/* more human-readable register name than above one */
#define BUS_DBG_CON_IRQ_WP_EN (0x00000040)
#define BUS_DBG_CON_IRQ_CLR (0x00000080)
#define BUS_DBG_CON_IRQ_AR_STA0 (0x00000100)
#define BUS_DBG_CON_IRQ_AW_STA0 (0x00000200)
#define BUS_DBG_CON_IRQ_WP_STA (0x00000400)
#define BUS_DBG_CON_WDT_RST_EN (0x00001000)
#define BUS_DBG_CON_HALT_ON_EN (0x00002000)
#define BUS_DBG_CON_BUS_OT_EN (0x00004000)
#define BUS_DBG_CON_SW_RST (0x00010000)
#define BUS_DBG_CON_IRQ_AR_STA1 (0x00100000)
#define BUS_DBG_CON_IRQ_AW_STA1 (0x00200000)
#define BUS_DBG_CON_TIMEOUT_CLR (0x00800000)
/* detect all stages of timeout */
#define BUS_DBG_CON_TIMEOUT \
(BUS_DBG_CON_IRQ_AR_STA0 | BUS_DBG_CON_IRQ_AW_STA0| \
BUS_DBG_CON_IRQ_AR_STA1 | BUS_DBG_CON_IRQ_AW_STA1)
#define BUS_DBG_CON_IRQ_EN \
(BUS_DBG_CON_IRQ_AR_EN | BUS_DBG_CON_IRQ_AW_EN | \
BUS_DBG_CON_IRQ_WP_EN)
#define BUS_DBG_MAX_TIMEOUT_VAL (0xffffffff)
static inline unsigned int extract_n2mbits(unsigned int input, int n, int m)
{
/*
* 1. ~0 = 1111 1111 1111 1111 1111 1111 1111 1111
* 2. ~0 << (m - n + 1) = 1111 1111 1111 1111 1100 0000 0000 0000
* // assuming we are extracting 14 bits, the +1 is added
* for inclusive selection
* 3. ~(~0 << (m - n + 1)) = 0000 0000 0000 0000 0011 1111 1111 1111
*/
int mask;
if (n > m) {
n = n + m;
m = n - m;
n = n - m;
}
mask = ~(~0 << (m - n + 1));
return ((input >> n) & mask);
}
struct mt_systracker_driver {
struct platform_driver driver;
struct platform_device device;
u32 support_2_stage_timeout;
void (*reset_systracker)(void);
int (*enable_watchpoint)(void);
int (*disable_watchpoint)(void);
int (*set_watchpoint_address)(unsigned int wp_phy_address);
void (*enable_systracker)(void);
void (*disable_systracker)(void);
int (*test_systracker)(void);
int (*systracker_probe)(struct platform_device *pdev);
unsigned int (*systracker_timeout_value)(void);
unsigned int (*systracker_timeout2_value)(void);
int (*systracker_remove)(struct platform_device *pdev);
int (*systracker_suspend)(struct platform_device *pdev,
pm_message_t state);
int (*systracker_resume)(struct platform_device *pdev);
int (*systracker_hook_fault)(void);
int (*systracker_test_init)(void);
void (*systracker_test_cleanup)(void);
void (*systracker_wp_test)(void);
void (*systracker_read_timeout_test)(void);
void (*systracker_write_timeout_test)(void);
void (*systracker_withrecord_test)(void);
void (*systracker_notimeout_test)(void);
};
struct systracker_entry_t {
unsigned int dbg_con;
unsigned int dbg_con_infra;
unsigned int ar_track_l[BUS_DBG_NUM_TRACKER];
unsigned int ar_track_h[BUS_DBG_NUM_TRACKER];
unsigned int ar_trans_tid[BUS_DBG_NUM_TRACKER];
unsigned int aw_track_l[BUS_DBG_NUM_TRACKER];
unsigned int aw_track_h[BUS_DBG_NUM_TRACKER];
unsigned int aw_trans_tid[BUS_DBG_NUM_TRACKER];
unsigned int w_track_data6;
unsigned int w_track_data7;
unsigned int w_track_data_valid;
};
struct systracker_config_t {
int state;
int enable_timeout;
int enable_slave_err;
int enable_wp;
int enable_irq;
int timeout_ms;
int timeout2_ms;
int wp_phy_address;
};
int tracker_dump(char *buf);
void dump_backtrace_entry_ramconsole_print
(unsigned long where, unsigned long from, unsigned long frame);
void dump_regs
(const char *fmt, const char v1, const unsigned int reg,
const unsigned int reg_val);
static void save_entry(void);
static int systracker_probe(struct platform_device *pdev);
static int systracker_remove(struct platform_device *pdev);
static int systracker_suspend
(struct platform_device *pdev, pm_message_t state);
static int systracker_resume(struct platform_device *pdev);
static void systracker_reset(void);
static void systracker_enable(void);
static void systracker_disable(void);
int systracker_set_watchpoint_addr(unsigned int phy_addr);
int systracker_watchpoint_disable(void);
int systracker_watchpoint_enable(void);
/* #define SYSTRACKER_TEST_SUIT */ /* enable for driver poring test suit */
/* #define TRACKER_DEBUG 0 */
#endif