524 lines
14 KiB
C
524 lines
14 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Copyright (c) 2019 MediaTek Inc.
|
|
*/
|
|
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
|
#include <linux/debugfs.h>
|
|
#endif
|
|
#if IS_ENABLED(CONFIG_PROC_FS)
|
|
#include <linux/proc_fs.h>
|
|
#endif
|
|
#include <linux/of_address.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/uaccess.h>
|
|
#include <drm/drmP.h>
|
|
#include "mtk_drm_ddp_comp.h"
|
|
#include "mtk_drm_plane.h"
|
|
#include "mtk_drm_crtc.h"
|
|
#include "mtk_drm_drv.h"
|
|
#include "mtk_drm_debugfs.h"
|
|
|
|
struct mtk_drm_debugfs_table {
|
|
char name[8];
|
|
unsigned int offset[2];
|
|
unsigned int length[2];
|
|
unsigned long reg_base;
|
|
};
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* External variable declarations */
|
|
/* ------------------------------------------------------------------------- */
|
|
static void __iomem *gdrm_disp1_base[12];
|
|
static void __iomem *gdrm_disp2_base[7];
|
|
static struct mtk_drm_debugfs_table gdrm_disp1_reg_range[7] = {
|
|
{"OVL0 ", {0, 0xf40}, {0x260, 0x80}, 0},
|
|
{"COLOR0 ", {0x400, 0xc00}, {0x400, 0x100}, 0},
|
|
{"AAL0 ", {0, 0}, {0x100, 0}, 0},
|
|
{"OD0 ", {0, 0}, {0x100, 0}, 0},
|
|
{"RDMA0 ", {0, 0}, {0x100, 0}, 0},
|
|
{"CONFIG ", {0, 0}, {0x120, 0}, 0},
|
|
{"MUTEX ", {0, 0}, {0x100, 0}, 0} };
|
|
|
|
static struct mtk_drm_debugfs_table gdrm_disp2_reg_range[7] = {
|
|
{"OVL1 ", {0, 0xf40}, {0x260, 0x80}, 0},
|
|
{"COLOR1 ", {0x400, 0xc00}, {0x100, 0x100}, 0},
|
|
{"AAL1 ", {0, 0}, {0x100, 0}, 0},
|
|
{"OD1 ", {0, 0}, {0x100, 0}, 0},
|
|
{"RDMA1 ", {0, 0}, {0x100, 0}, 0},
|
|
{"CONFIG ", {0, 0}, {0x120, 0}, 0},
|
|
{"MUTEX ", {0, 0}, {0x100, 0}, 0} };
|
|
static bool dbgfs_alpha;
|
|
|
|
static void mtk_read_reg(unsigned long addr)
|
|
{
|
|
void __iomem *reg_va = 0;
|
|
|
|
reg_va = ioremap_nocache(addr, sizeof(reg_va));
|
|
pr_info("r:0x%8lx = 0x%08x\n", addr, readl(reg_va));
|
|
iounmap(reg_va);
|
|
}
|
|
|
|
static void mtk_write_reg(unsigned long addr, unsigned long val)
|
|
{
|
|
void __iomem *reg_va = 0;
|
|
|
|
reg_va = ioremap_nocache(addr, sizeof(reg_va));
|
|
writel(val, reg_va);
|
|
iounmap(reg_va);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* Debug Options */
|
|
/* ------------------------------------------------------------------------- */
|
|
static const char STR_HELP[] = "\n"
|
|
"USAGE\n"
|
|
" echo [ACTION]... > mtkdrm\n"
|
|
"\n"
|
|
"ACTION\n"
|
|
"\n"
|
|
" dump:\n"
|
|
" dump all hw registers\n"
|
|
"\n"
|
|
" regw:addr=val\n"
|
|
" write hw register\n"
|
|
"\n"
|
|
" regr:addr\n"
|
|
" read hw register\n";
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* Command Processor */
|
|
/* ------------------------------------------------------------------------- */
|
|
static void process_dbg_opt(char *opt)
|
|
{
|
|
if (strncmp(opt, "regw:", 5) == 0) {
|
|
char *p = (char *)opt + 5;
|
|
char *np;
|
|
unsigned long addr, val;
|
|
u64 i;
|
|
|
|
np = strsep(&p, "=");
|
|
if (kstrtoul(np, 16, &addr) != 0)
|
|
goto error;
|
|
|
|
if (p == NULL)
|
|
goto error;
|
|
|
|
np = strsep(&p, "=");
|
|
if (kstrtoul(np, 16, &val) != 0)
|
|
goto error;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp1_reg_range); i++) {
|
|
if (addr > gdrm_disp1_reg_range[i].reg_base &&
|
|
addr < gdrm_disp1_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
writel(val, gdrm_disp1_base[i] + addr -
|
|
gdrm_disp1_reg_range[i]
|
|
.reg_base);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp2_reg_range); i++) {
|
|
if (addr > gdrm_disp2_reg_range[i].reg_base &&
|
|
addr < gdrm_disp2_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
writel(val, gdrm_disp2_base[i] + addr -
|
|
gdrm_disp2_reg_range[i]
|
|
.reg_base);
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else if (strncmp(opt, "regr:", 5) == 0) {
|
|
char *p = (char *)opt + 5;
|
|
unsigned long addr;
|
|
u64 i;
|
|
|
|
if (kstrtoul(p, 16, &addr) != 0)
|
|
goto error;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp1_reg_range); i++) {
|
|
if (addr >= gdrm_disp1_reg_range[i].reg_base &&
|
|
addr < gdrm_disp1_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
DRM_INFO("%8s Read register 0x%08lX: 0x%08X\n",
|
|
gdrm_disp1_reg_range[i].name, addr,
|
|
readl(gdrm_disp1_base[i] + addr -
|
|
gdrm_disp1_reg_range[i]
|
|
.reg_base));
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp2_reg_range); i++) {
|
|
if (addr >= gdrm_disp2_reg_range[i].reg_base &&
|
|
addr < gdrm_disp2_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
DRM_INFO("%8s Read register 0x%08lX: 0x%08X\n",
|
|
gdrm_disp2_reg_range[i].name, addr,
|
|
readl(gdrm_disp2_base[i] + addr -
|
|
gdrm_disp2_reg_range[i]
|
|
.reg_base));
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else if (strncmp(opt, "autoregr:", 9) == 0) {
|
|
DRM_INFO("Set the register addr for Auto-test\n");
|
|
} else if (strncmp(opt, "dump:", 5) == 0) {
|
|
u64 i;
|
|
u32 j;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp1_reg_range); i++) {
|
|
if (gdrm_disp1_base[i] == NULL)
|
|
continue;
|
|
for (j = gdrm_disp1_reg_range[i].offset[0];
|
|
j < gdrm_disp1_reg_range[i].offset[0] +
|
|
gdrm_disp1_reg_range[i].length[0];
|
|
j += 16UL)
|
|
DRM_INFO("%8s 0x%08lX: %08X %08X %08X %08X\n",
|
|
gdrm_disp1_reg_range[i].name,
|
|
gdrm_disp1_reg_range[i].reg_base + j,
|
|
readl(gdrm_disp1_base[i] + j),
|
|
readl(gdrm_disp1_base[i] + j + 0x4),
|
|
readl(gdrm_disp1_base[i] + j + 0x8),
|
|
readl(gdrm_disp1_base[i] + j + 0xc));
|
|
|
|
for (j = gdrm_disp1_reg_range[i].offset[1];
|
|
j < gdrm_disp1_reg_range[i].offset[1] +
|
|
gdrm_disp1_reg_range[i].length[1];
|
|
j += 16UL)
|
|
DRM_INFO("%8s 0x%08lX: %08X %08X %08X %08X\n",
|
|
gdrm_disp1_reg_range[i].name,
|
|
gdrm_disp1_reg_range[i].reg_base + j,
|
|
readl(gdrm_disp1_base[i] + j),
|
|
readl(gdrm_disp1_base[i] + j + 0x4),
|
|
readl(gdrm_disp1_base[i] + j + 0x8),
|
|
readl(gdrm_disp1_base[i] + j + 0xc));
|
|
}
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp2_reg_range); i++) {
|
|
if (gdrm_disp2_base[i] == NULL)
|
|
continue;
|
|
for (j = gdrm_disp2_reg_range[i].offset[0];
|
|
j < gdrm_disp2_reg_range[i].offset[0] +
|
|
gdrm_disp2_reg_range[i].length[0];
|
|
j += 16)
|
|
DRM_INFO("%8s 0x%08lX: %08X %08X %08X %08X\n",
|
|
gdrm_disp2_reg_range[i].name,
|
|
gdrm_disp2_reg_range[i].reg_base + j,
|
|
readl(gdrm_disp2_base[i] + j),
|
|
readl(gdrm_disp2_base[i] + j + 0x4),
|
|
readl(gdrm_disp2_base[i] + j + 0x8),
|
|
readl(gdrm_disp2_base[i] + j + 0xc));
|
|
|
|
for (j = gdrm_disp2_reg_range[i].offset[1];
|
|
j < gdrm_disp2_reg_range[i].offset[1] +
|
|
gdrm_disp2_reg_range[i].length[1];
|
|
j += 16)
|
|
DRM_INFO("%8s 0x%08lX: %08X %08X %08X %08X\n",
|
|
gdrm_disp2_reg_range[i].name,
|
|
gdrm_disp2_reg_range[i].reg_base + j,
|
|
readl(gdrm_disp2_base[i] + j),
|
|
readl(gdrm_disp2_base[i] + j + 0x4),
|
|
readl(gdrm_disp2_base[i] + j + 0x8),
|
|
readl(gdrm_disp2_base[i] + j + 0xc));
|
|
}
|
|
|
|
} else if (strncmp(opt, "hdmi:", 5) == 0) {
|
|
} else if (strncmp(opt, "alpha", 5) == 0) {
|
|
if (dbgfs_alpha) {
|
|
DRM_INFO("set src alpha to src alpha\n");
|
|
dbgfs_alpha = false;
|
|
} else {
|
|
DRM_INFO("set src alpha to ONE\n");
|
|
dbgfs_alpha = true;
|
|
}
|
|
} else if (strncmp(opt, "r:", 2) == 0) {
|
|
char *p = (char *)opt + 2;
|
|
unsigned long addr;
|
|
|
|
if (kstrtoul(p, 16, &addr) != 0)
|
|
goto error;
|
|
|
|
mtk_read_reg(addr);
|
|
} else if (strncmp(opt, "w:", 2) == 0) {
|
|
char *p = (char *)opt + 2;
|
|
char *np;
|
|
unsigned long addr, val;
|
|
|
|
np = strsep(&p, "=");
|
|
if (kstrtoul(np, 16, &addr) != 0)
|
|
goto error;
|
|
|
|
if (p == NULL)
|
|
goto error;
|
|
|
|
np = strsep(&p, "=");
|
|
if (kstrtoul(np, 16, &val) != 0)
|
|
goto error;
|
|
|
|
mtk_write_reg(addr, val);
|
|
} else {
|
|
goto error;
|
|
}
|
|
|
|
return;
|
|
error:
|
|
DRM_ERROR("Parse command error!\n\n%s", STR_HELP);
|
|
}
|
|
|
|
static void process_dbg_cmd(char *cmd)
|
|
{
|
|
char *tok;
|
|
|
|
while ((tok = strsep(&cmd, " ")) != NULL)
|
|
process_dbg_opt(tok);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
/* Debug FileSystem Routines */
|
|
/* ------------------------------------------------------------------------- */
|
|
static int debug_open(struct inode *inode, struct file *file)
|
|
{
|
|
file->private_data = inode->i_private;
|
|
return 0;
|
|
}
|
|
|
|
static char dis_cmd_buf[512];
|
|
static ssize_t debug_read(struct file *file, char __user *ubuf, size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
if (strncmp(dis_cmd_buf, "regr:", 5) == 0) {
|
|
char read_buf[512] = {0};
|
|
char *p = (char *)dis_cmd_buf + 5;
|
|
unsigned long addr;
|
|
int ret;
|
|
u64 i;
|
|
|
|
if (kstrtoul(p, 16, &addr) != 0)
|
|
return 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp1_reg_range); i++) {
|
|
if (addr >= gdrm_disp1_reg_range[i].reg_base &&
|
|
addr < gdrm_disp1_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
ret = sprintf(
|
|
read_buf,
|
|
"%8s Read register 0x%08lX: 0x%08X\n",
|
|
gdrm_disp1_reg_range[i].name, addr,
|
|
readl(gdrm_disp1_base[i] + addr -
|
|
gdrm_disp1_reg_range[i]
|
|
.reg_base));
|
|
if (ret <= 0L)
|
|
DRM_INFO("autoregr fail\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp2_reg_range); i++) {
|
|
if (addr >= gdrm_disp2_reg_range[i].reg_base &&
|
|
addr < gdrm_disp2_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
ret = sprintf(
|
|
read_buf,
|
|
"%8s Read register 0x%08lX: 0x%08X\n",
|
|
gdrm_disp2_reg_range[i].name, addr,
|
|
readl(gdrm_disp2_base[i] + addr -
|
|
gdrm_disp2_reg_range[i]
|
|
.reg_base));
|
|
if (ret <= 0L)
|
|
DRM_INFO("autoregr fail\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return simple_read_from_buffer(ubuf, count, ppos, read_buf,
|
|
strlen(read_buf));
|
|
} else if (strncmp(dis_cmd_buf, "autoregr:", 9) == 0) {
|
|
char read_buf[512] = {0};
|
|
char read_buf2[512] = {0};
|
|
char *p = (char *)dis_cmd_buf + 9;
|
|
unsigned long addr;
|
|
unsigned long addr2;
|
|
int ret;
|
|
u64 i;
|
|
|
|
if (kstrtoul(p, 16, &addr) != 0)
|
|
return 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp1_reg_range); i++) {
|
|
if (addr >= gdrm_disp1_reg_range[i].reg_base &&
|
|
addr < gdrm_disp1_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
ret = sprintf(
|
|
read_buf,
|
|
"%8s Read register 0x%08lX: 0x%08X\n",
|
|
gdrm_disp1_reg_range[i].name, addr,
|
|
readl(gdrm_disp1_base[i] + addr -
|
|
gdrm_disp1_reg_range[i]
|
|
.reg_base));
|
|
if (ret <= 0L)
|
|
DRM_INFO("autoregr fail\n");
|
|
break;
|
|
}
|
|
}
|
|
addr2 = addr + 0x1000ULL;
|
|
for (i = 0; i < ARRAY_SIZE(gdrm_disp2_reg_range); i++) {
|
|
if (addr2 >= gdrm_disp2_reg_range[i].reg_base &&
|
|
addr2 < gdrm_disp2_reg_range[i].reg_base +
|
|
0x1000UL) {
|
|
ret = sprintf(
|
|
read_buf2,
|
|
"%8s Read register 0x%08lX: 0x%08X\n",
|
|
gdrm_disp2_reg_range[i].name, addr2,
|
|
readl(gdrm_disp2_base[i] + addr2 -
|
|
gdrm_disp2_reg_range[i]
|
|
.reg_base));
|
|
if (ret <= 0L)
|
|
DRM_INFO("autoregr fail\n");
|
|
break;
|
|
}
|
|
}
|
|
p = strncat(read_buf, read_buf2,
|
|
(sizeof(read_buf) - strlen(read_buf) - 1));
|
|
if (p == NULL)
|
|
DRM_INFO("autoregr strcat fail\n");
|
|
return simple_read_from_buffer(ubuf, count, ppos, read_buf,
|
|
strlen(read_buf));
|
|
} else {
|
|
return simple_read_from_buffer(ubuf, count, ppos, STR_HELP,
|
|
strlen(STR_HELP));
|
|
}
|
|
}
|
|
|
|
static ssize_t debug_write(struct file *file, const char __user *ubuf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
const u64 debug_bufmax = sizeof(dis_cmd_buf) - 1ULL;
|
|
ssize_t ret;
|
|
|
|
ret = (ssize_t)count;
|
|
|
|
if (count > debug_bufmax)
|
|
count = debug_bufmax;
|
|
|
|
if (copy_from_user(&dis_cmd_buf, ubuf, count) != 0ULL)
|
|
return -EFAULT;
|
|
|
|
dis_cmd_buf[count] = '\0';
|
|
|
|
process_dbg_cmd(dis_cmd_buf);
|
|
|
|
return ret;
|
|
}
|
|
#if S_ENABLED(CONFIG_DEBUG_FS)
|
|
static struct dentry *mtkdrm_dbgfs;
|
|
#endif
|
|
|
|
#if IS_ENABLED(CONFIG_PROC_FS)
|
|
static struct proc_dir_entry *mtkdrm_dbgfs;
|
|
#endif
|
|
|
|
static const struct file_operations debug_fops = {
|
|
.read = debug_read, .write = debug_write, .open = debug_open,
|
|
};
|
|
|
|
bool force_alpha(void)
|
|
{
|
|
return dbgfs_alpha;
|
|
}
|
|
|
|
void mtk_drm_debugfs_init(struct drm_device *dev, struct mtk_drm_private *priv)
|
|
{
|
|
void __iomem *mutex_regs;
|
|
unsigned long mutex_phys;
|
|
struct device_node *np;
|
|
struct resource res;
|
|
int i;
|
|
enum mtk_ddp_comp_id comp_id;
|
|
const struct mtk_crtc_path_data *main_path_data;
|
|
const struct mtk_crtc_path_data *ext_path_data;
|
|
int ret;
|
|
|
|
DRM_DEBUG_DRIVER("%s\n", __func__);
|
|
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
|
mtkdrm_dbgfs = debugfs_create_file("mtkdrm", 0644, NULL, (void *)0,
|
|
&debug_fops);
|
|
#endif
|
|
#if IS_ENABLED(CONFIG_PROC_FS)
|
|
mtkdrm_dbgfs = proc_create("mtkdrm", S_IFREG | 0640, NULL,
|
|
&debug_fops);
|
|
if (!mtkdrm_dbgfs) {
|
|
pr_info("[%s %d]failed to create mtkdrm in /proc\n",
|
|
__func__, __LINE__);
|
|
goto out;
|
|
}
|
|
#endif
|
|
/* TODO: The debugfs_init would be different in latest kernel version,
|
|
* so we will refine the debugfs with multiple path in latest verion.
|
|
*/
|
|
main_path_data = priv->data->main_path_data;
|
|
for (i = 0; i < priv->data->main_path_data->path_len[DDP_MAJOR][0] - 1;
|
|
i++) {
|
|
comp_id = main_path_data->path[DDP_MAJOR][0][i];
|
|
np = priv->comp_node[comp_id];
|
|
if (!priv->ddp_comp[comp_id])
|
|
continue;
|
|
gdrm_disp1_base[i] = priv->ddp_comp[comp_id]->regs;
|
|
|
|
ret = of_address_to_resource(np, 0, &res);
|
|
if (ret < 0)
|
|
DRM_INFO("comp_node[%d] map address fail\n", i);
|
|
gdrm_disp1_reg_range[i].reg_base = res.start;
|
|
}
|
|
|
|
gdrm_disp1_base[i] = priv->config_regs;
|
|
gdrm_disp1_reg_range[i++].reg_base = 0x14000000;
|
|
mutex_regs = of_iomap(priv->mutex_node, 0);
|
|
ret = of_address_to_resource(priv->mutex_node, 0, &res);
|
|
if (ret < 0)
|
|
DRM_INFO("mutex_node map address fail\n");
|
|
|
|
mutex_phys = res.start;
|
|
gdrm_disp1_base[i] = mutex_regs;
|
|
gdrm_disp1_reg_range[i++].reg_base = mutex_phys;
|
|
|
|
/* TODO: The debugfs_init would be different in latest kernel version,
|
|
* so we will refine the debugfs with multiple path in latest verion.
|
|
*/
|
|
ext_path_data = priv->data->ext_path_data;
|
|
if (ext_path_data) {
|
|
for (i = 0; i < ext_path_data->path_len[DDP_MAJOR][0] - 1;
|
|
i++) {
|
|
comp_id = ext_path_data->path[DDP_MAJOR][0][i];
|
|
np = priv->comp_node[comp_id];
|
|
if (!priv->ddp_comp[comp_id])
|
|
continue;
|
|
gdrm_disp2_base[i] = of_iomap(np, 0);
|
|
ret = of_address_to_resource(np, 0, &res);
|
|
if (ret < 0)
|
|
DRM_INFO("comp_node[%d] map address fail\n", i);
|
|
gdrm_disp2_reg_range[i].reg_base = res.start;
|
|
}
|
|
gdrm_disp2_base[i] = priv->config_regs;
|
|
gdrm_disp2_reg_range[i++].reg_base = 0x14000000;
|
|
gdrm_disp2_base[i] = mutex_regs;
|
|
gdrm_disp2_reg_range[i].reg_base = mutex_phys;
|
|
}
|
|
out:
|
|
DRM_DEBUG_DRIVER("%s..done\n", __func__);
|
|
}
|
|
|
|
void mtk_drm_debugfs_deinit(void)
|
|
{
|
|
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
|
debugfs_remove(mtkdrm_dbgfs);
|
|
#endif
|
|
#if IS_ENABLED(CONFIG_PROC_FS)
|
|
if (mtkdrm_dbgfs) {
|
|
proc_remove(mtkdrm_dbgfs);
|
|
mtkdrm_dbgfs = NULL;
|
|
}
|
|
#endif
|
|
}
|