shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-08 20:07:46 +09:00
Code Issues Packages Projects Releases Wiki Activity

gdc: add trace_mode debug node for gdc timeout issue [1/2]

Browse Source 
PD#GH-27

Problem:
gdc timeout when gdc processing data

Solution:
add trace_mode debug node

Verify:
verified on G12B-W400

Change-Id: I85ee5a4203c9da1af755844125716a844da54ad3
Signed-off-by: Jian Cao <jian.cao@amlogic.com>
This commit is contained in:
Jian Cao
2019-04-04 21:31:12 +08:00
committed by Chris KIM
parent 278859f161
commit a445e0884e
1 changed files with 275 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

279
drivers/amlogic/media/gdc/app/gdc_module.c
View File

@@ -47,6 +47,12 @@
unsigned int gdc_log_level;
struct gdc_manager_s gdc_manager;
static int trace_mode_enable;
static char *config_out_file;
static int config_out_path_defined;
#define WAIT_THRESHOLD 1000
#define CONFIG_PATH_LENG 128
static const struct of_device_id gdc_dt_match[] = {
{.compatible = "amlogic, g12b-gdc"},
@@ -352,7 +358,6 @@ attach_err:
return ret;
}
static void meson_gdc_dma_unmap(struct gdc_dma_cfg *cfg)
{
int fd = -1;
@@ -746,6 +751,84 @@ static long gdc_process_ex_info(struct mgdc_fh_s *fh,
return 0;
}
u8 __iomem *map_virt_from_phys(phys_addr_t phys, unsigned long total_size)
{
u32 offset, npages;
struct page **pages = NULL;
pgprot_t pgprot;
u8 __iomem *vaddr;
int i;
npages = PAGE_ALIGN(total_size) / PAGE_SIZE;
offset = phys & (~PAGE_MASK);
if (offset)
npages++;
pages = vmalloc(sizeof(struct page *) * npages);
if (!pages)
return NULL;
for (i = 0; i < npages; i++) {
pages[i] = phys_to_page(phys);
phys += PAGE_SIZE;
}
/*nocache*/
pgprot = pgprot_noncached(PAGE_KERNEL);
vaddr = vmap(pages, npages, VM_MAP, pgprot);
if (!vaddr) {
pr_err("vmaped fail, size: %d\n",
npages << PAGE_SHIFT);
vfree(pages);
return NULL;
}
vfree(pages);
return vaddr;
}
void unmap_virt_from_phys(u8 __iomem *vaddr)
{
if (vaddr) {
/* unmap prevois vaddr */
vunmap(vaddr);
vaddr = NULL;
}
}
int write_buf_to_file(char *path, char *buf, int size)
{
int ret = 0;
struct file *fp = NULL;
mm_segment_t old_fs;
loff_t pos = 0;
int w_size = 0;
if (!path || !config_out_path_defined) {
gdc_log(LOG_ERR, "please define path first\n");
return -1;
}
/* change to KERNEL_DS address limit */
old_fs = get_fs();
set_fs(KERNEL_DS);
/* open file to write */
fp = filp_open(path, O_WRONLY|O_CREAT, 0640);
if (IS_ERR(fp)) {
gdc_log(LOG_ERR, "open file error\n");
ret = -1;
}
/* Write buf to file */
w_size = vfs_write(fp, buf, size, &pos);
gdc_log(LOG_INFO, "write w_size = %u, size = %u\n", w_size, size);
vfs_fsync(fp, 0);
filp_close(fp, NULL);
set_fs(old_fs);
return w_size;
}
static long meson_gdc_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
@@ -763,7 +846,12 @@ static long meson_gdc_ioctl(struct file *file, unsigned int cmd,
ion_phys_addr_t addr;
int index, dma_fd;
void __user *argp = (void __user *)arg;
void __iomem *config_virt_addr;
ktime_t start_time, stop_time, diff_time;
int process_time = 0;
int i = 0;
start_time.tv64 = 0;
switch (cmd) {
case GDC_PROCESS:
ret = copy_from_user(&gs, argp, sizeof(gs));
@@ -815,16 +903,53 @@ static long meson_gdc_ioctl(struct file *file, unsigned int cmd,
gdc_cmd->fh = fh;
mutex_lock(&fh->gdev->d_mutext);
if (trace_mode_enable >= 1)
start_time = ktime_get();
ret = gdc_run(gdc_cmd);
if (ret < 0)
gdc_log(LOG_ERR, "gdc process ret = %ld\n", ret);
ret = wait_for_completion_timeout(&fh->gdev->d_com,
msecs_to_jiffies(40));
msecs_to_jiffies(WAIT_THRESHOLD));
if (ret == 0)
gdc_log(LOG_ERR, "gdc timeout\n");
if (ret == 0) {
gdc_log(LOG_ERR, "gdc timeout, status = 0x%x\n",
gdc_status_read());
if (trace_mode_enable >= 2) {
/* dump regs */
for (i = 0; i <= 0xFF; i += 4)
gdc_log(LOG_ERR, "reg[0x%x] = 0x%x\n",
i, system_gdc_read_32(i));
/* dump config buffer */
config_virt_addr =
map_virt_from_phys(gc->config_addr,
PAGE_ALIGN(gc->config_size * 4));
ret = write_buf_to_file(config_out_file,
config_virt_addr,
(gc->config_size * 4));
if (ret <= 0)
gdc_log(LOG_ERR,
"Failed to read_file_to_buf\n");
unmap_virt_from_phys(config_virt_addr);
}
}
gdc_stop(gdc_cmd);
if (trace_mode_enable >= 1) {
stop_time = ktime_get();
diff_time = ktime_sub(stop_time, start_time);
process_time = ktime_to_ms(diff_time);
if (process_time > 50)
gdc_log(LOG_ERR, "gdc process time = %d\n",
process_time);
}
mutex_unlock(&fh->gdev->d_mutext);
break;
case GDC_RUN:
@@ -854,16 +979,52 @@ static long meson_gdc_ioctl(struct file *file, unsigned int cmd,
fh->i_paddr, fh->i_len);
meson_gdc_dma_flush(&fh->gdev->pdev->dev,
fh->c_paddr, fh->c_len);
if (trace_mode_enable >= 1)
start_time = ktime_get();
ret = gdc_run(gdc_cmd);
if (ret < 0)
gdc_log(LOG_ERR, "gdc process failed ret = %ld\n", ret);
ret = wait_for_completion_timeout(&fh->gdev->d_com,
msecs_to_jiffies(40));
msecs_to_jiffies(WAIT_THRESHOLD));
if (ret == 0)
gdc_log(LOG_ERR, "gdc timeout\n");
if (ret == 0) {
gdc_log(LOG_ERR, "gdc timeout, status = 0x%x\n",
gdc_status_read());
if (trace_mode_enable >= 2) {
/* dump regs */
for (i = 0; i <= 0xFF; i += 4)
gdc_log(LOG_ERR, "reg[0x%x] = 0x%x\n",
i, system_gdc_read_32(i));
/* dump config buffer */
config_virt_addr =
map_virt_from_phys(gc->config_addr,
PAGE_ALIGN(gc->config_size * 4));
ret = write_buf_to_file(config_out_file,
config_virt_addr,
(gc->config_size * 4));
if (ret <= 0)
gdc_log(LOG_ERR,
"Failed to read_file_to_buf\n");
unmap_virt_from_phys(config_virt_addr);
}
}
gdc_stop(gdc_cmd);
if (trace_mode_enable >= 1) {
stop_time = ktime_get();
diff_time = ktime_sub(stop_time, start_time);
process_time = ktime_to_ms(diff_time);
if (process_time > 50)
gdc_log(LOG_ERR, "gdc process time = %d\n",
process_time);
}
meson_gdc_cache_flush(&fh->gdev->pdev->dev,
fh->o_paddr, fh->o_len);
mutex_unlock(&fh->gdev->d_mutext);
@@ -893,16 +1054,54 @@ static long meson_gdc_ioctl(struct file *file, unsigned int cmd,
}
meson_gdc_dma_flush(&fh->gdev->pdev->dev,
fh->c_paddr, fh->c_len);
if (trace_mode_enable >= 1)
start_time = ktime_get();
ret = gdc_run(gdc_cmd);
if (ret < 0)
gdc_log(LOG_ERR, "gdc process failed ret = %ld\n", ret);
ret = wait_for_completion_timeout(&fh->gdev->d_com,
msecs_to_jiffies(40));
msecs_to_jiffies(WAIT_THRESHOLD));
if (ret == 0)
gdc_log(LOG_ERR, "gdc timeout\n");
if (ret == 0) {
gdc_log(LOG_ERR, "gdc timeout, status = 0x%x\n",
gdc_status_read());
if (trace_mode_enable >= 2) {
/* dump regs */
for (i = 0; i <= 0xFF; i += 4)
gdc_log(LOG_ERR, "reg[0x%x] = 0x%x\n",
i, system_gdc_read_32(i));
/* dump config buffer */
config_virt_addr =
map_virt_from_phys(gc->config_addr,
PAGE_ALIGN(gc->config_size * 4));
ret = write_buf_to_file(config_out_file,
config_virt_addr,
(gc->config_size * 4));
if (ret <= 0)
gdc_log(LOG_ERR,
"Failed to read_file_to_buf\n");
unmap_virt_from_phys(config_virt_addr);
}
}
gdc_stop(gdc_cmd);
if (trace_mode_enable >= 1) {
stop_time = ktime_get();
diff_time = ktime_sub(stop_time, start_time);
process_time = ktime_to_ms(diff_time);
if (process_time > 50)
gdc_log(LOG_ERR, "gdc process time = %d\n",
process_time);
}
meson_gdc_cache_flush(&fh->gdev->pdev->dev,
fh->o_paddr, fh->o_len);
meson_gdc_deinit_dma_addr(fh);
@@ -1122,6 +1321,60 @@ static ssize_t loglevel_store(struct device *dev,
static DEVICE_ATTR(loglevel, 0664, loglevel_show, loglevel_store);
static ssize_t trace_mode_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
len += sprintf(buf+len, "trace_mode_enable: %d\n",
trace_mode_enable);
return len;
}
static ssize_t trace_mode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
int res = 0;
int ret = 0;
ret = kstrtoint(buf, 0, &res);
pr_info("trace_mode: %d->%d\n", trace_mode_enable, res);
trace_mode_enable = res;
return len;
}
static DEVICE_ATTR(trace_mode, 0664, trace_mode_show, trace_mode_store);
static ssize_t config_out_path_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t len = 0;
if (config_out_path_defined)
len += sprintf(buf+len, "config out path: %s\n",
config_out_file);
else
len += sprintf(buf+len, "config out path is not set\n");
return len;
}
static ssize_t config_out_path_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t len)
{
if (strlen(buf) >= sizeof(config_out_file)) {
pr_info("err: path too long\n");
} else {
strncpy(config_out_file, buf, CONFIG_PATH_LENG - 1);
config_out_path_defined = 1;
pr_info("set config out path: %s\n", config_out_file);
}
return len;
}
static DEVICE_ATTR(config_out_path, 0664, config_out_path_show,
config_out_path_store);
irqreturn_t gdc_interrupt_handler(int irq, void *param)
{
struct meson_gdc_dev_t *gdc_dev = param;
@@ -1155,6 +1408,13 @@ static int gdc_platform_probe(struct platform_device *pdev)
of_reserved_mem_device_init(&(pdev->dev));
/* alloc mem to store config out path*/
config_out_file = kzalloc(CONFIG_PATH_LENG, GFP_KERNEL);
if (config_out_file == NULL) {
gdc_log(LOG_ERR, "config out alloc failed\n");
return -ENOMEM;
}
gdc_dev = devm_kzalloc(&pdev->dev, sizeof(*gdc_dev),
GFP_KERNEL);
@@ -1215,6 +1475,10 @@ static int gdc_platform_probe(struct platform_device *pdev)
&dev_attr_firmware1);
device_create_file(gdc_dev->misc_dev.this_device,
&dev_attr_loglevel);
device_create_file(gdc_dev->misc_dev.this_device,
&dev_attr_trace_mode);
device_create_file(gdc_dev->misc_dev.this_device,
&dev_attr_config_out_path);
platform_set_drvdata(pdev, gdc_dev);
return rc;
@@ -1229,10 +1493,17 @@ static int gdc_platform_remove(struct platform_device *pdev)
&dev_attr_firmware1);
device_remove_file(meson_gdc_dev.this_device,
&dev_attr_loglevel);
device_remove_file(meson_gdc_dev.this_device,
&dev_attr_trace_mode);
device_remove_file(meson_gdc_dev.this_device,
&dev_attr_config_out_path);
gdc_dma_buffer_destroy(gdc_manager.buffer);
gdc_manager.gdc_dev = NULL;
kfree(config_out_file);
config_out_file = NULL;
misc_deregister(&meson_gdc_dev);
return 0;
}