drivers/amlogic/media/frc/frc_dbg.c

// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 Amlogic, Inc. All rights reserved.
 */
#include <linux/types.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_fdt.h>
#include <linux/of_reserved_mem.h>
#include <linux/of_irq.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/errno.h>
#include <linux/uaccess.h>
#include <linux/ioport.h>
#include <linux/ctype.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/pm_runtime.h>

#include <linux/amlogic/media/frc/frc_reg.h>
#include <linux/amlogic/media/frc/frc_common.h>
#include <linux/amlogic/media/vout/vinfo.h>
#include <linux/amlogic/media/vout/vout_notify.h>
#include <linux/amlogic/power_domain.h>

#include "frc_drv.h"
#include "frc_dbg.h"
#include "frc_buf.h"
#include "frc_hw.h"
#include "frc_proc.h"

static void frc_debug_parse_param(char *buf_orig, char **parm)
{
	char *ps, *token;
	char delim1[3] = " ";
	char delim2[2] = "\n";
	unsigned int n = 0;

	ps = buf_orig;
	strcat(delim1, delim2);
	while (1) {
		token = strsep(&ps, delim1);
		if (!token)
			break;
		if (*token == '\0')
			continue;
		parm[n++] = token;
	}
}

void frc_status(struct frc_dev_s *devp)
{
	struct frc_fw_data_s *fw_data;
	struct vinfo_s *vinfo = get_current_vinfo();

	fw_data = (struct frc_fw_data_s *)devp->fw_data;
	pr_frc(0, "%s\n", FRC_FW_VER);
	pr_frc(0, "%s\n", fw_data->frc_alg_ver);
	pr_frc(0, "probe_ok sts:%d power_on_flag:%d hw_pos:%d (1:after) fw_pause:%d\n",
		devp->probe_ok, devp->power_on_flag, devp->frc_hw_pos, devp->frc_fw_pause);
	pr_frc(0, "frs state:%d (%s) new:%d\n", devp->frc_sts.state,
	       frc_state_ary[devp->frc_sts.state], devp->frc_sts.new_state);
	pr_frc(0, "input in_hsize=%d in_vsize=%d\n", devp->in_sts.in_hsize, devp->in_sts.in_vsize);
	pr_frc(0, "game_mode=%d secure_mode=%d pic_type=%d\n", devp->in_sts.game_mode,
		devp->in_sts.secure_mode, devp->in_sts.pic_type);
	pr_frc(0, "dbg en:%d in_out_ratio=0x%x\n", devp->dbg_force_en, devp->dbg_in_out_ratio);
	pr_frc(0, "dbg hsize=%d vsize=%d\n", devp->dbg_input_hsize, devp->dbg_input_vsize);
	pr_frc(0, "vf_sts:%d, vf_type:0x%x, signal_type=0x%x, source_type=0x%x\n",
	       devp->in_sts.vf_sts,
	       devp->in_sts.vf_type, devp->in_sts.signal_type, devp->in_sts.source_type);
	pr_frc(0, "duration=%d\n", devp->in_sts.duration);
	pr_frc(0, "vout hsize:%d vsize:%d\n", devp->out_sts.vout_width, devp->out_sts.vout_height);
	pr_frc(0, "vout out_framerate:%d\n", devp->out_sts.out_framerate);
	pr_frc(0, "vout sync_duration_num:%d sync_duration_den:%d hz:%d\n",
		vinfo->sync_duration_num, vinfo->sync_duration_den,
		vinfo->sync_duration_num / vinfo->sync_duration_den);
	pr_frc(0, "data_compress_rate:%d, real total size:%d\n",
		FRC_COMPRESS_RATE, devp->buf.real_total_size);
	pr_frc(0, "buf secured:%d\n", devp->buf.secured);
	pr_frc(0, "vpu int vs_duration:%d timestamp:%ld\n",
	       devp->vs_duration, (ulong)devp->vs_timestamp);
	pr_frc(0, "frc in vs_duration:%d timestamp:%ld\n",
	       devp->in_sts.vs_duration, (ulong)devp->in_sts.vs_timestamp);
	pr_frc(0, "frc out vs_duration:%d timestamp:%ld\n",
	       devp->out_sts.vs_duration, (ulong)devp->out_sts.vs_timestamp);
	pr_frc(0, "int in vs_cnt:%d, vs_tsk_cnt:%d, inp_err:0x%x\n",
		devp->in_sts.vs_cnt, devp->in_sts.vs_tsk_cnt,
		devp->ud_dbg.inp_undone_err);
	pr_frc(0, "int out vs_cnt:%d, vs_tsk_cnt:%d\n",
		devp->out_sts.vs_cnt, devp->out_sts.vs_tsk_cnt);
	pr_frc(0, "frc_st vs_cnt:%d vf_repeat_cnt:%d vf_null_cnt:%d\n", devp->frc_sts.vs_cnt,
		devp->in_sts.vf_repeat_cnt, devp->in_sts.vf_null_cnt);
	pr_frc(0, "mc_loss_en = %d me_loss_en = %d\n", fw_data->frc_top_type.mc_loss_en,
		fw_data->frc_top_type.me_loss_en);
	pr_frc(0, "loss_ratio = %d\n", devp->loss_ratio);
	pr_frc(0, "frc_prot_mode = %d\n", devp->prot_mode);
	pr_frc(0, "film_mode = %d\n", devp->film_mode);
	pr_frc(0, "film_mode_det = %d\n", devp->film_mode_det);
	pr_frc(0, "frc in hsize = %d\n", fw_data->frc_top_type.hsize);
	pr_frc(0, "frc in vsize = %d\n", fw_data->frc_top_type.vsize);
	pr_frc(0, "vfb = %d\n", fw_data->frc_top_type.vfb);
	pr_frc(0, "frc_fb_num = %d\n", fw_data->frc_top_type.frc_fb_num);
	pr_frc(0, "frc_ratio_mode = %d\n", fw_data->frc_top_type.frc_ratio_mode);
	pr_frc(0, "film_mode = %d\n", fw_data->frc_top_type.film_mode);
	pr_frc(0, "film_hwfw_sel = %d\n", fw_data->frc_top_type.film_hwfw_sel);
	pr_frc(0, "is_me1mc4 = %d\n", fw_data->frc_top_type.is_me1mc4);
	pr_frc(0, "frc out_hsize = %d\n", fw_data->frc_top_type.out_hsize);
	pr_frc(0, "frc out_vsize = %d\n", fw_data->frc_top_type.out_vsize);
	pr_frc(0, "me_hold_line = %d\n", fw_data->holdline_parm.me_hold_line);
	pr_frc(0, "mc_hold_line = %d\n", fw_data->holdline_parm.mc_hold_line);
	pr_frc(0, "inp_hold_line = %d\n", fw_data->holdline_parm.inp_hold_line);
	pr_frc(0, "reg_post_dly_vofst = %d\n", fw_data->holdline_parm.reg_post_dly_vofst);
	pr_frc(0, "reg_mc_dly_vofst0 = %d\n", fw_data->holdline_parm.reg_mc_dly_vofst0);
	pr_frc(0, "auto_ctrl = %d\n", devp->frc_sts.auto_ctrl);
	pr_frc(0, "force_en = %d, force_hsize = %d, force_vsize = %d\n",
		devp->force_size.force_en, devp->force_size.force_hsize,
		devp->force_size.force_vsize);
	pr_frc(0, "get_video_latency = %d\n", frc_get_video_latency());
	pr_frc(0, "get_frc_adj_me_out_line = %d\n", devp->out_line);

}

ssize_t frc_debug_if_help(struct frc_dev_s *devp, char *buf)
{
	ssize_t len = 0;

	len += sprintf(buf + len, "status:%d\t: (%s)\n", devp->frc_sts.state,
				frc_state_ary[devp->frc_sts.state]);
	len += sprintf(buf + len, "dbg_level=%d\n", frc_dbg_en);//style for tool
	len += sprintf(buf + len, "dbg_mode\t: 0:disable 1:enable 2:bypass\n");
	len += sprintf(buf + len, "dbg_ratio\t: set debug input ratio\n");
	len += sprintf(buf + len, "dbg_force\t: force debug mode\n");
	len += sprintf(buf + len, "test_pattern disable or enable\t:\n");
	len += sprintf(buf + len, "dump_bufcfg\t: dump buf address, size\n");
	len += sprintf(buf + len, "dump_linkbuf\t: dump link buffer data\n");
	len += sprintf(buf + len, "dump_init_reg\t: dump initial table\n");
	len += sprintf(buf + len, "dump_buf_reg\t: dump buffer register\n");
	len += sprintf(buf + len, "dump_buf_reg\t: dump buffer register\n");
	len += sprintf(buf + len, "dump_data addr size\t: dump cma buf data\n");
	len += sprintf(buf + len, "frc_pos 0,1\t: 0:before postblend; 1:after postblend\n");
	len += sprintf(buf + len, "frc_pause 0/1 \t: 0: fw work 1:fw not work\n");
	len += sprintf(buf + len, "monitor_ireg idx reg_addr\t: monitor frc register (max 6)\n");
	len += sprintf(buf + len, "monitor_oreg idx reg_addr\t: monitor frc register (max 6)\n");
	len += sprintf(buf + len, "monitor_dump\n");
	len += sprintf(buf + len, "monitor_vf 1/0\t: monitor current vf on, off\n");
	len += sprintf(buf + len, "crc_read 0/1\t: 0: disable crc read, 1: enable crc read\n");
	len += sprintf(buf + len, "crc_en 0/1 0/1 0/1 0/1\t: mewr/merd/mcwr/vs_print crc enable\n");
	len += sprintf(buf + len, "ratio val\t: 0:112 1:213 2:2-5 3:5-6 6:1-1\n");
	len += sprintf(buf + len, "film_mode val\t: 0:video 1:22 2:32 3:3223 4:2224\n");
	len += sprintf(buf + len, "buf_num val\t: val(1 - 16)\n");
	len += sprintf(buf + len, " \t\t 5:32322 6:44\n");
	len += sprintf(buf + len, "force_mode en(0/1) hize vsize\n");
	len += sprintf(buf + len, "ud_dbg 0/1 0/1 0/1 0/1\t: meud_en,mcud_en,in,out alg time\n");
	len += sprintf(buf + len, "auto_ctrl 0/1 \t: frc auto on off work mode\n");
	len += sprintf(buf + len, "mc_lossy 0/1 \t: 0:off 1:on\n");
	len += sprintf(buf + len, "me_lossy 0/1 \t: 0:off 1:on\n");
	len += sprintf(buf + len, "powerdown : power down memc\n");
	len += sprintf(buf + len, "poweron : power on memc\n");
	len += sprintf(buf + len, "memc_level : memc_dejudder\n");

	return len;
}

void frc_debug_if(struct frc_dev_s *devp, const char *buf, size_t count)
{
	char *buf_orig, *parm[47] = {NULL};
	int val1;
	int val2;
	struct frc_fw_data_s *fw_data;

	if (!devp)
		return;

	if (!buf)
		return;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	if (!buf_orig)
		return;

	fw_data = (struct frc_fw_data_s *)devp->fw_data;

	frc_debug_parse_param(buf_orig, (char **)&parm);

	if (!strcmp(parm[0], "status")) {
		frc_status(devp);
	} else if (!strcmp(parm[0], "dbg_level")) {
		if (kstrtoint(parm[1], 10, &val1) == 0)
			frc_dbg_en = (int)val1;
		pr_frc(0, "frc_dbg_en=%d\n", frc_dbg_en);
	} else if (!strcmp(parm[0], "dump_bufcfg")) {
		frc_buf_dump_memory_size_info(devp);
		frc_buf_dump_memory_addr_info(devp);
	} else if (!strcmp(parm[0], "dump_linkbuf")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			if (val1 < 4)
				frc_buf_dump_link_tab(devp, (u32)val1);
		}
	} else if (!strcmp(parm[0], "dbg_mode")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			if (val1 < FRC_STATE_NULL) {
				frc_set_mode((u32)val1);
			}
		}
	} else if (!strcmp(parm[0], "dbg_size")) {
		if (!parm[1] || !parm[2])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->dbg_input_hsize = (u32)val1;

		if (kstrtoint(parm[2], 10, &val2) == 0)
			devp->dbg_input_vsize = (u32)val2;
	} else if (!strcmp(parm[0], "dbg_ratio")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->dbg_in_out_ratio = val1;
		pr_frc(0, "dbg_in_out_ratio:0x%x\n", devp->dbg_in_out_ratio);
	} else if (!strcmp(parm[0], "dbg_force")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->dbg_force_en = (u32)val1;
	} else if (!strcmp(parm[0], "test_pattern")) {
		if (!parm[1])
			goto exit;

		if (!strcmp(parm[1], "enable"))
			devp->frc_test_ptn = 1;
		else if (!strcmp(parm[1], "disable"))
			devp->frc_test_ptn = 0;
		frc_pattern_on(devp->frc_test_ptn);
	} else if (!strcmp(parm[0], "dump_init_reg")) {
		frc_dump_reg_tab();
	} else if (!strcmp(parm[0], "dump_fixed_reg")) {
		frc_dump_fixed_table();
	} else if (!strcmp(parm[0], "dump_buf_reg")) {
		frc_dump_buf_reg();
	} else if (!strcmp(parm[0], "dump_data")) {
		if (kstrtoint(parm[1], 16, &val1))
			goto exit;
		if (kstrtoint(parm[2], 16, &val2))
			goto exit;
		frc_dump_buf_data(devp, (u32)val1, (u32)val2);
	} else if (!strcmp(parm[0], "frc_pos")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->frc_hw_pos = (u32)val1;
		frc_init_config(devp);
		pr_frc(0, "frc_hw_pos:0x%x (0:before 1:after)\n", devp->frc_hw_pos);
	} else if (!strcmp(parm[0], "frc_pause")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->frc_fw_pause = (u32)val1;
	} else if (!strcmp(parm[0], "monitor_ireg")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			if (val1 < MONITOR_REG_MAX) {
				if (kstrtoint(parm[2], 16, &val2) == 0) {
					if (val1 < 0x3fff) {
						devp->dbg_in_reg[val1] = val2;
						devp->dbg_reg_monitor_i = 1;
					}
				}
			} else {
				devp->dbg_reg_monitor_i = 0;
			}
		}
	} else if (!strcmp(parm[0], "monitor_oreg")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			if (val1 < MONITOR_REG_MAX) {
				if (kstrtoint(parm[2], 16, &val2) == 0) {
					if (val1 < 0x3fff) {
						devp->dbg_out_reg[val1] = val2;
						devp->dbg_reg_monitor_o = 1;
					}
				}
			} else {
				devp->dbg_reg_monitor_o = 0;
			}
		}
	} else if (!strcmp(parm[0], "monitor_vf")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			devp->dbg_vf_monitor = val1;
			devp->dbg_buf_len = 0;
		}
	} else if (!strcmp(parm[0], "monitor_dump")) {
		frc_dump_monitor_data(devp);
	} else if (!strcmp(parm[0], "crc_read")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->frc_crc_data.frc_crc_read = val1;
	} else if (!strcmp(parm[0], "crc_en")) {
		if (!parm[4])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->frc_crc_data.me_wr_crc.crc_en = val1;
		if (kstrtoint(parm[2], 10, &val1) == 0)
			devp->frc_crc_data.me_rd_crc.crc_en = val1;
		if (kstrtoint(parm[3], 10, &val1) == 0)
			devp->frc_crc_data.mc_wr_crc.crc_en = val1;
		if (kstrtoint(parm[4], 10, &val1) == 0)
			devp->frc_crc_data.frc_crc_pr = val1;
		frc_crc_enable(devp);
	} else if (!strcmp(parm[0], "ratio")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->in_out_ratio = val1;
	} else if (!strcmp(parm[0], "film_mode")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->film_mode = val1;
	} else if (!strcmp(parm[0], "buf_num")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			frc_set_buf_num((u32)val1);
	} else if (!strcmp(parm[0], "force_mode")) {
		if (!parm[3])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->force_size.force_en = val1;
		if (kstrtoint(parm[2], 10, &val1) == 0)
			devp->force_size.force_hsize = val1;
		if (kstrtoint(parm[3], 10, &val1) == 0)
			devp->force_size.force_vsize = val1;
	} else if (!strcmp(parm[0], "ud_dbg")) {
		if (!parm[4]) {
			pr_frc(0, "err:input parameters error!\n");
			goto exit;
		}
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->ud_dbg.inpud_dbg_en = val1;
		if (kstrtoint(parm[2], 10, &val1) == 0) {
			devp->ud_dbg.meud_dbg_en = val1;
			devp->ud_dbg.mcud_dbg_en = val1;
			devp->ud_dbg.vpud_dbg_en = val1;
		}
		if (kstrtoint(parm[3], 10, &val1) == 0)
			devp->ud_dbg.inud_time_en = val1;
		if (kstrtoint(parm[4], 10, &val1) == 0)
			devp->ud_dbg.outud_time_en = val1;
	} else if (!strcmp(parm[0], "auto_ctrl")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->frc_sts.auto_ctrl = val1;
	} else if (!strcmp(parm[0], "osdbit_fcolr")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			frc_osdbit_setfalsecolor(val1);
	} else if (!strcmp(parm[0], "me_lossy")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			fw_data->frc_top_type.me_loss_en  = val1;
			cfg_me_loss(fw_data->frc_top_type.me_loss_en);
		}
	} else if (!strcmp(parm[0], "mc_lossy")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			fw_data->frc_top_type.mc_loss_en  = val1;
			cfg_me_loss(fw_data->frc_top_type.mc_loss_en);
		}
	} else if (!strcmp(parm[0], "secure_on")) {
		if (!parm[1] || !parm[2])
			goto exit;
		if (kstrtoint(parm[1], 16, &val1) == 0) {
			if (kstrtoint(parm[2], 16, &val2) == 0)
				frc_test_mm_secure_set_on(devp, val1, val2);
		}
	} else if (!strcmp(parm[0], "secure_off")) {
		frc_test_mm_secure_set_off(devp);
	} else if (!strcmp(parm[0], "prot_mode")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->prot_mode = val1;
	} else if (!strcmp(parm[0], "powerdown")) {
		frc_power_domain_ctrl(devp, 0);
	} else if (!strcmp(parm[0], "poweron")) {
		frc_power_domain_ctrl(devp, 1);
	} else if (!strcmp(parm[0], "memc_level")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			frc_memc_set_level((u8)val1);
	} else if (!strcmp(parm[0], "set_seg")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			frc_set_seg_display((u8)val1, 8, 8, 8);
	} else if (!strcmp(parm[0], "set_demo")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			frc_memc_set_demo((u8)val1);
	} else if (!strcmp(parm[0], "out_line")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0) {
			devp->out_line = (u32)val1;
			pr_frc(2, "set frc adj me out line is %d\n",
				devp->out_line);
		}
	} else if (!strcmp(parm[0], "chk_motion")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->ud_dbg.res0_dbg_en = val1;
	} else if (!strcmp(parm[0], "chk_vd")) {
		if (!parm[1])
			goto exit;
		if (kstrtoint(parm[1], 10, &val1) == 0)
			devp->ud_dbg.res1_dbg_en = val1;
	}
exit:
	kfree(buf_orig);
}

void frc_reg_io(const char *buf)
{
	char *buf_orig, *parm[8] = {NULL};
	ulong val;
	unsigned int reg;
	unsigned int regvalue;
	unsigned int len;
	int i;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	if (!buf_orig)
		return;
	frc_debug_parse_param(buf_orig, (char **)&parm);

	if (!strcmp(parm[0], "r")) {
		if (!parm[1])
			goto free_buf;
		if (kstrtoul(parm[1], 16, &val) < 0)
			goto free_buf;
		reg = val;
		regvalue = READ_FRC_REG(reg);
		pr_frc(0, "[0x%x] = 0x%x\n", reg, regvalue);
	} else if (!strcmp(parm[0], "w")) {
		if (!parm[1] || !parm[2])
			goto free_buf;
		if (kstrtoul(parm[1], 16, &val) < 0)
			goto free_buf;
		reg = val;
		if (kstrtoul(parm[2], 16, &val) < 0)
			goto free_buf;
		regvalue = val;
		WRITE_FRC_REG(reg, regvalue);
		pr_frc(0, "[0x%x] = 0x%x\n", reg, regvalue);
	} else if (!strcmp(parm[0], "d")) {
		if (!parm[1] || !parm[2])
			goto free_buf;
		if (kstrtoul(parm[1], 16, &val) < 0)
			goto free_buf;
		reg = val;
		if (kstrtoul(parm[2], 16, &val) < 0)
			goto free_buf;
		len = val;
		for (i = 0; i < len; i++) {
			regvalue = READ_FRC_REG(reg + i);
			pr_frc(0, "[0x%x] = 0x%x\n", reg + i, regvalue);
		}
	}

free_buf:
	kfree(buf_orig);
}

void frc_tool_dbg_store(struct frc_dev_s *devp, const char *buf)
{
	char *buf_orig, *parm[8] = {NULL};
	ulong val;
	unsigned int reg;
	unsigned int regvalue;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	if (!buf_orig)
		return;
	frc_debug_parse_param(buf_orig, (char **)&parm);

	if (!strcmp(parm[0], "r")) {
		if (!parm[1])
			goto free_buf;
		if (kstrtoul(parm[1], 16, &val) < 0)
			goto free_buf;
		reg = val;
		devp->tool_dbg.reg_read = reg;
		devp->tool_dbg.reg_read_val = READ_FRC_REG(reg);
	} else if (!strcmp(parm[0], "w")) {
		if (!parm[1] || !parm[2])
			goto free_buf;
		if (kstrtoul(parm[1], 16, &val) < 0)
			goto free_buf;
		reg = val;
		if (kstrtoul(parm[2], 16, &val) < 0)
			goto free_buf;
		regvalue = val;
		WRITE_FRC_REG(reg, regvalue);
	}

free_buf:
	kfree(buf_orig);
}

ssize_t frc_bbd_final_line_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data;
	ssize_t len = 0;
	fw_data = (struct frc_fw_data_s *)devp->fw_data;
	len =  fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_BBD_FINAL_LINE, buf);
	return len;
}

ssize_t frc_bbd_final_line_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_BBD_FINAL_LINE, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_vp_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_VP_CTRL, buf);
	return len;
}

ssize_t frc_vp_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_VP_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;

}

ssize_t frc_logo_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_LOGO_CTRL, buf);
	return len;
}

ssize_t frc_logo_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_LOGO_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_iplogo_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_IPLOGO_CTRL, buf);
	return len;

}

ssize_t frc_iplogo_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_IPLOGO_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_melogo_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_MELOGO_CTRL, buf);
	return len;
}

ssize_t frc_melogo_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_MELOGO_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_sence_chg_detect_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_SENCE_CHG_DETECT, buf);
	return len;

}

ssize_t frc_sence_chg_detect_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_SENCE_CHG_DETECT, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_fb_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_FB_CTRL, buf);
	return len;
}

ssize_t frc_fb_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_FB_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_me_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_ME_CTRL, buf);
	return len;
}

ssize_t frc_me_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_ME_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_search_rang_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_SEARCH_RANG, buf);
	return len;
}

ssize_t frc_search_rang_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_SEARCH_RANG, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_pixel_lpf_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_PIXEL_LPF, buf);
	return len;
}

ssize_t frc_pixel_lpf_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_PIXEL_LPF, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_me_rule_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;

	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_ME_RULE, buf);
	return len;
}

ssize_t frc_me_rule_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;

	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_ME_RULE, buf_orig, count);
	kfree(buf_orig);
	return count;
}

ssize_t frc_film_ctrl_param_show(struct class *class,
	struct class_attribute *attr,
	char *buf)
{
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	ssize_t len = 0;
	len = fw_data->frc_alg_dbg_show(fw_data, MEMC_DBG_FILM_CTRL, buf);
	return len;
}

ssize_t frc_film_ctrl_param_store(struct class *class,
	struct class_attribute *attr,
	const char *buf,
	size_t count)
{
	char *buf_orig;
	struct frc_dev_s *devp = get_frc_devp();
	struct frc_fw_data_s *fw_data = (struct frc_fw_data_s *)devp->fw_data;
	buf_orig = kstrdup(buf, GFP_KERNEL);
	count = fw_data->frc_alg_dbg_stor(fw_data, MEMC_DBG_FILM_CTRL, buf_orig, count);
	kfree(buf_orig);
	return count;

}