rdma: add rdma multi reg trace function [1/1]

PD#SWPL-11388

Problem:
rdma not support multi reg trace

Solution:
add rdma multi reg trace function

Verify:
verify by g12b w400

Change-Id: I74496e11f85af5f2e9aa99108dfc5842eb98d9fc
Signed-off-by: Pengcheng Chen <pengcheng.chen@amlogic.com>

drivers/amlogic/media/common/rdma/rdma_mgr.c

@@ -68,10 +68,14 @@ static int rdma_watchdog = 20;
 static int reset_count;
 static int rdma_watchdog_count;
 static int rdma_force_reset = -1;
-static u16 trace_reg;
 
 #define RDMA_NUM 8
 #define RDMA_TABLE_SIZE (8 * (PAGE_SIZE))
+#define MAX_TRACE_NUM  16
+#define RDMA_MGR_CLASS_NAME  "rdma_mgr"
+static int rdma_trace_num;
+static int rdma_trace_enable;
+static u32 rdma_trace_reg[MAX_TRACE_NUM];
 
 struct rdma_regadr_s {
 	u32 rdma_ahb_start_addr;
@@ -106,6 +110,7 @@ struct rdma_instance_s {
 struct rdma_device_info {
 	const char *device_name;
 	struct platform_device *rdma_dev;
+	struct class *clsp;
 	struct rdma_instance_s rdma_ins[RDMA_NUM];
 };
 
@@ -614,7 +619,7 @@ EXPORT_SYMBOL(rdma_clear);
 
 u32 rdma_read_reg(int handle, u32 adr)
 {
-	int i;
+	int i, j = 0;
 	u32 *write_table;
 	int match = 0;
 	int read_from = 0;
@@ -642,24 +647,29 @@ u32 rdma_read_reg(int handle, u32 adr)
 			}
 		}
 	}
-	if (adr == trace_reg) {
-		if (read_from == 2)
-			pr_info("(%s) handle %d, %04x=0x%08x from write table(%d)\n",
-				__func__,
-				handle, adr,
-				read_val,
-				ins->rdma_write_count);
-		else if (read_from == 1)
-			pr_info("(%s) handle %d, %04x=0x%08x from item table(%d)\n",
-				__func__,
-				handle, adr,
-				read_val,
-				ins->rdma_item_count);
-		else
-			pr_info("(%s) handle %d, %04x=0x%08x from real reg\n",
-				__func__,
-				handle, adr,
-				read_val);
+	if (rdma_trace_enable) {
+		for (j = 0; j < rdma_trace_num; j++) {
+			if (adr == rdma_trace_reg[j]) {
+				if (read_from == 2)
+					pr_info("(%s) handle %d, %04x=0x%08x from write table(%d)\n",
+						__func__,
+						handle, adr,
+						read_val,
+						ins->rdma_write_count);
+				else if (read_from == 1)
+					pr_info("(%s) handle %d, %04x=0x%08x from item table(%d)\n",
+						__func__,
+						handle, adr,
+						read_val,
+						ins->rdma_item_count);
+				else
+					pr_info("(%s) handle %d, %04x=0x%08x from real reg\n",
+						__func__,
+						handle, adr,
+						read_val);
+			}
+
+		}
 	}
 	return read_val;
 }
@@ -698,6 +708,7 @@ int rdma_write_reg(int handle, u32 adr, u32 val)
 {
 	struct rdma_device_info *info = &rdma_info;
 	struct rdma_instance_s *ins = &info->rdma_ins[handle];
+	int j = 0;
 
 	if (ins->rdma_table_size == 0)
 		return -1;
@@ -724,19 +735,24 @@ int rdma_write_reg(int handle, u32 adr, u32 val)
 		ins->reg_buf[(ins->rdma_item_count << 1) + 1] = val;
 		ins->rdma_item_count++;
 	}
-	if (adr == trace_reg)
-		pr_info("(%s) handle %d, %04x=0x%08x (%d)\n",
-			__func__,
-			handle, adr,
-			val,
-			ins->rdma_item_count);
+	if (rdma_trace_enable) {
+		for (j = 0; j < rdma_trace_num; j++) {
+			if (adr == rdma_trace_reg[j]) {
+				pr_info("(%s) handle %d, %04x=0x%08x (%d)\n",
+					__func__,
+					handle, adr,
+					val,
+					ins->rdma_item_count);
+			}
+		}
+	}
 	return 0;
 }
 EXPORT_SYMBOL(rdma_write_reg);
 
 int rdma_write_reg_bits(int handle, u32 adr, u32 val, u32 start, u32 len)
 {
-	int i;
+	int i, j = 0;
 	u32 *write_table;
 	int match = 0;
 	int read_from = 0;
@@ -771,27 +787,31 @@ int rdma_write_reg_bits(int handle, u32 adr, u32 val, u32 start, u32 len)
 	write_val = (read_val & ~(((1L<<(len))-1)<<(start)))
 		|((unsigned int)(val) << (start));
 
-	if (adr == trace_reg) {
-		if (read_from == 2)
-			pr_info("(%s) handle %d, %04x=0x%08x->0x%08x from write table(%d)\n",
-				__func__,
-				handle, adr,
-				read_val,
-				write_val,
-				ins->rdma_write_count);
-		else if (read_from == 1)
-			pr_info("(%s) handle %d, %04x=0x%08x->0x%08x from item table(%d)\n",
-				__func__,
-				handle, adr,
-				read_val,
-				write_val,
-				ins->rdma_item_count);
-		else
-			pr_info("(%s) handle %d, %04x=0x%08x->0x%08x from real reg\n",
-				__func__,
-				handle, adr,
-				read_val,
-				write_val);
+	if (rdma_trace_enable) {
+		for (j = 0; j < rdma_trace_num; j++) {
+			if (adr == rdma_trace_reg[j]) {
+				if (read_from == 2)
+					pr_info("(%s) handle %d, %04x=0x%08x->0x%08x from write table(%d)\n",
+						__func__,
+						handle, adr,
+						read_val,
+						write_val,
+						ins->rdma_write_count);
+				else if (read_from == 1)
+					pr_info("(%s) handle %d, %04x=0x%08x->0x%08x from item table(%d)\n",
+						__func__,
+						handle, adr,
+						read_val,
+						write_val,
+						ins->rdma_item_count);
+				else
+					pr_info("(%s) handle %d, %04x=0x%08x->0x%08x from real reg\n",
+						__func__,
+						handle, adr,
+						read_val,
+						write_val);
+			}
+		}
 	}
 	if (match) {
 		ins->reg_buf[(i << 1) + 1] = write_val;
@@ -821,9 +841,6 @@ module_param(ctrl_ahb_rd_burst_size, uint, 0664);
 MODULE_PARM_DESC(ctrl_ahb_wr_burst_size, "\n ctrl_ahb_wr_burst_size\n");
 module_param(ctrl_ahb_wr_burst_size, uint, 0664);
 
-MODULE_PARM_DESC(trace_reg, "\n trace_addr\n");
-module_param(trace_reg, ushort, 0664);
-
 static struct rdma_device_data_s rdma_meson = {
 	.cpu_type = CPU_NORMAL,
 	.rdma_ver = RDMA_VER_1,
@@ -858,6 +875,112 @@ static const struct of_device_id rdma_dt_match[] = {
 	{},
 };
 
+static int parse_para(const char *para, int para_num, int *result)
+{
+	char *token = NULL;
+	char *params, *params_base;
+	int *out = result;
+	int len = 0, count = 0;
+	int res = 0;
+	int ret = 0;
+
+	if (!para)
+		return 0;
+
+	params = kstrdup(para, GFP_KERNEL);
+	params_base = params;
+	token = params;
+	if (!token)
+		return 0;
+	len = strlen(token);
+	do {
+		token = strsep(&params, " ");
+		while (token && (isspace(*token)
+				|| !isgraph(*token)) && len) {
+			token++;
+			len--;
+		}
+		if ((len == 0) || (!token))
+			break;
+		ret = kstrtoint(token, 0, &res);
+		if (ret < 0)
+			break;
+		len = strlen(token);
+		*out++ = res;
+		count++;
+	} while ((token) && (count < para_num) && (len > 0));
+
+	kfree(params_base);
+	return count;
+}
+
+static ssize_t rdma_mgr_trace_enable_show(struct class *cla,
+		struct class_attribute *attr, char *buf)
+{
+	return snprintf(buf, PAGE_SIZE, "%x\n", rdma_trace_enable);
+}
+
+static ssize_t rdma_mgr_trace_enable_stroe(struct class *cla,
+		struct class_attribute *attr,
+		const char *buf, size_t count)
+{
+	int ret = 0;
+
+	ret = kstrtoint(buf, 0, &rdma_trace_enable);
+	if (ret < 0)
+		return -EINVAL;
+	return count;
+}
+
+static ssize_t rdma_mgr_trace_reg_show(struct class *cla,
+		struct class_attribute *attr, char *buf)
+{
+	int i;
+	char reg_info[16];
+	char *trace_info = NULL;
+
+	trace_info = kmalloc(rdma_trace_num * 16 + 1, GFP_KERNEL);
+	if (!trace_info)
+		return 0;
+	for (i = 0; i < rdma_trace_num; i++) {
+		sprintf(reg_info, "0x%x", rdma_trace_reg[i]);
+		strcat(trace_info, reg_info);
+		strcat(trace_info, " ");
+	}
+	i = snprintf(buf, PAGE_SIZE, "%s\n", trace_info);
+	kfree(trace_info);
+	trace_info = NULL;
+	return i;
+}
+
+static ssize_t rdma_mgr_trace_reg_stroe(struct class *cla,
+		struct class_attribute *attr,
+		const char *buf, size_t count)
+{
+	int parsed[MAX_TRACE_NUM];
+	int i = 0, num = 0;
+
+	for (i	= 0; i < MAX_TRACE_NUM; i++)
+		rdma_trace_reg[i] = 0;
+	num = parse_para(buf, MAX_TRACE_NUM, parsed);
+	if (num <= MAX_TRACE_NUM) {
+		rdma_trace_num = num;
+		for (i  = 0; i < num; i++) {
+			rdma_trace_reg[i] = parsed[i];
+			pr_info("trace reg:0x%x\n", rdma_trace_reg[i]);
+		}
+	}
+	return count;
+}
+
+static struct class_attribute rdma_attrs[] = {
+	__ATTR(trace_enable, 0664,
+		rdma_mgr_trace_enable_show, rdma_mgr_trace_enable_stroe),
+	__ATTR(trace_reg, 0664,
+		rdma_mgr_trace_reg_show, rdma_mgr_trace_reg_stroe),
+
+};
+
 u32 is_meson_g12b_revb(void)
 {
 	if (rdma_meson_dev.cpu_type == CPU_G12B &&
@@ -870,7 +993,7 @@ u32 is_meson_g12b_revb(void)
 /* static int __devinit rdma_probe(struct platform_device *pdev) */
 static int rdma_probe(struct platform_device *pdev)
 {
-	int i;
+	int i, ret = 0;
 	u32 data32;
 	int int_rdma;
 	int handle;
@@ -911,7 +1034,6 @@ static int rdma_probe(struct platform_device *pdev)
 	WRITE_VCBUS_REG(VPU_VPUARB2_ASYNC_HOLD_CTRL, 0x18101810);
 
 	rdma_mgr_irq_request = 0;
-	trace_reg = 0;
 
 	for (i = 0; i < RDMA_NUM; i++) {
 		info->rdma_ins[i].rdma_table_size = 0;
@@ -965,15 +1087,49 @@ static int rdma_probe(struct platform_device *pdev)
 			NULL, RDMA_TABLE_SIZE);
 		set_rdma_handle(LINE_N_INT_RDMA, handle);
 	}
+	info->clsp = class_create(THIS_MODULE,
+		RDMA_MGR_CLASS_NAME);
+	if (IS_ERR(info->clsp)) {
+		ret = PTR_ERR(info->clsp);
+		pr_err("fail to create class\n");
+		goto fail_create_class;
+	}
+	pr_info("classs created ok\n");
+	for (i = 0; i < ARRAY_SIZE(rdma_attrs); i++) {
+		if (class_create_file
+			(info->clsp,
+			&rdma_attrs[i]) < 0) {
+		pr_err("fail to class_create_file\n");
+		goto fail_class_create_file;
+		}
+	}
+	pr_info("classs file created ok\n");
 	return 0;
-
+fail_class_create_file:
+	for (i = 0; i < ARRAY_SIZE(rdma_attrs); i++)
+		class_remove_file(
+		info->clsp, &rdma_attrs[i]);
+	class_destroy(info->clsp);
+	info->clsp = NULL;
+	rdma_trace_num = 0;
+	rdma_trace_enable = 0;
+fail_create_class:
+	return ret;
 }
 
 /* static int __devexit rdma_remove(struct platform_device *pdev) */
 static int rdma_remove(struct platform_device *pdev)
 {
+	int i;
+	struct rdma_device_info *info = &rdma_info;
+
 	pr_error("RDMA driver removed.\n");
 	switch_vpu_mem_pd_vmod(VPU_RDMA, VPU_MEM_POWER_DOWN);
+	for (i = 0; i < ARRAY_SIZE(rdma_attrs); i++)
+		class_remove_file(
+		info->clsp, &rdma_attrs[i]);
+	class_destroy(info->clsp);
+	info->clsp = NULL;
 	return 0;
 }
 

drivers/amlogic/media/osd/osd.h

@@ -111,9 +111,10 @@ enum color_index_e {
 #define KEYCOLOR_FLAG_ONHOLD  2
 #define KEYCOLOR_FLAG_CURRENT 4
 
-#define HW_OSD_COUNT 4
+#define HW_OSD_COUNT     4
 #define OSD_BLEND_LAYERS 4
-#define VIU_COUNT     2
+#define VIU_COUNT        2
+#define MAX_TRACE_NUM    16
 
 /* OSD block definition */
 #define HW_OSD_BLOCK_COUNT 4
@@ -772,6 +773,9 @@ struct hw_para_s {
 	u32 afbc_err_cnt;
 	u32 viu_type;
 	u32 line_n_rdma;
+	u32 rdma_trace_enable;
+	u32 rdma_trace_num;
+	u32 rdma_trace_reg[MAX_TRACE_NUM];
 	struct hw_debug_s osd_debug;
 	int out_fence_fd[VIU_COUNT];
 	int in_fd[HW_OSD_COUNT];

drivers/amlogic/media/osd/osd_fb.c

@@ -2966,6 +2966,8 @@ static ssize_t store_osd_reg(struct device *device,
 		reg_val = val;
 		osd_reg_write(reg_addr, reg_val);
 	}
+	kfree(buf_orig);
+	buf_orig = NULL;
 	return count;
 }
 
@@ -3374,6 +3376,68 @@ static ssize_t store_osd_blend_bypass(
 	return count;
 }
 
+static ssize_t show_rdma_trace_enable(
+	struct device *device, struct device_attribute *attr,
+	char *buf)
+{
+	return snprintf(buf, PAGE_SIZE, "%x\n", osd_hw.rdma_trace_enable);
+}
+
+static ssize_t store_rdma_trace_enable(
+	struct device *device, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int trace_enable;
+	int ret = 0;
+
+	ret = kstrtoint(buf, 0, &trace_enable);
+	if (ret < 0)
+		return -EINVAL;
+	osd_hw.rdma_trace_enable = trace_enable;
+	return count;
+}
+
+static ssize_t show_rdma_trace_reg(
+	struct device *device, struct device_attribute *attr,
+	char *buf)
+{
+	int i;
+	char reg_info[16];
+	char *trace_info = NULL;
+
+	trace_info = kmalloc(osd_hw.rdma_trace_num * 16 + 1, GFP_KERNEL);
+	if (!trace_info)
+		return 0;
+	for (i = 0; i < osd_hw.rdma_trace_num; i++) {
+		sprintf(reg_info, "0x%x", osd_hw.rdma_trace_reg[i]);
+		strcat(trace_info, reg_info);
+		strcat(trace_info, " ");
+	}
+	i = snprintf(buf, PAGE_SIZE, "%s\n", trace_info);
+	kfree(trace_info);
+	trace_info = NULL;
+	return i;
+}
+
+static ssize_t store_rdma_trace_reg(
+	struct device *device, struct device_attribute *attr,
+	const char *buf, size_t count)
+{
+	int parsed[MAX_TRACE_NUM];
+	int i = 0, num = 0;
+
+	for (i  = 0; i < MAX_TRACE_NUM; i++)
+		osd_hw.rdma_trace_reg[i] = 0;
+	num = parse_para(buf, MAX_TRACE_NUM, parsed);
+	if (num <= MAX_TRACE_NUM) {
+		osd_hw.rdma_trace_num = num;
+		for (i  = 0; i < num; i++) {
+			osd_hw.rdma_trace_reg[i] = parsed[i];
+			pr_info("trace reg:0x%x\n", osd_hw.rdma_trace_reg[i]);
+		}
+	}
+	return count;
+}
 
 static inline  int str2lower(char *str)
 {
@@ -3591,6 +3655,10 @@ static struct device_attribute osd_attrs[] = {
 			show_osd_hold_line, store_osd_hold_line),
 	__ATTR(osd_blend_bypass, 0644,
 			show_osd_blend_bypass, store_osd_blend_bypass),
+	__ATTR(trace_enable, 0644,
+			show_rdma_trace_enable, store_rdma_trace_enable),
+	__ATTR(trace_reg, 0644,
+			show_rdma_trace_reg, store_rdma_trace_reg),
 };
 
 static struct device_attribute osd_attrs_viu2[] = {

drivers/amlogic/media/osd/osd_rdma.c

@@ -123,7 +123,7 @@ static inline void reset_rdma_table(void)
 	unsigned long flags;
 	u32 old_count;
 	u32 end_addr;
-	int i, j = 0;
+	int i, j = 0, k = 0, trace_num = 0;
 	struct rdma_table_item reset_item[2] = {
 		{
 			.addr = OSD_RDMA_FLAG_REG,
@@ -135,6 +135,10 @@ static inline void reset_rdma_table(void)
 		}
 	};
 
+	if (osd_hw.rdma_trace_enable)
+		trace_num = osd_hw.rdma_trace_num;
+	else
+		trace_num = 0;
 	spin_lock_irqsave(&rdma_lock, flags);
 	if (!OSD_RDMA_STATUS_IS_REJECT) {
 		u32 val, mask;
@@ -178,10 +182,14 @@ static inline void reset_rdma_table(void)
 				osd_rdma_mem_cpy(
 					&rdma_temp_tbl[j], &request_item, 8);
 				j++;
-				pr_debug(
-					"recovery -- 0x%04x:0x%08x, mask:0x%08x\n",
-					rdma_table[i].addr,
-					val, mask);
+
+				for (k = 0; k < trace_num; k++) {
+					if (osd_hw.rdma_trace_reg[k] & 0x10000)
+						pr_info(
+							"recovery -- 0x%04x:0x%08x, mask:0x%08x\n",
+							rdma_table[i].addr,
+							val, mask);
+				}
 				rdma_recovery_count++;
 			} else if ((iret < 0) && (i >= old_count)) {
 				request_item.addr =
@@ -191,14 +199,19 @@ static inline void reset_rdma_table(void)
 				osd_rdma_mem_cpy(
 					&rdma_temp_tbl[j], &request_item, 8);
 				j++;
-				pr_debug(
-					"recovery -- 0x%04x:0x%08x, mask:0x%08x\n",
-					rdma_table[i].addr,
-					rdma_table[i].val,
-					mask);
-				pr_debug(
-					"recovery -- i:%d, item_count:%d, old_count:%d\n",
-					i, item_count, old_count);
+				for (k = 0; k < trace_num; k++) {
+					if (osd_hw.rdma_trace_reg[k] & 0x10000)
+						pr_info(
+							"recovery -- 0x%04x:0x%08x, mask:0x%08x\n",
+							rdma_table[i].addr,
+							rdma_table[i].val,
+							mask);
+						pr_info(
+							"recovery -- i:%d,item_count:%d,old_count:%d\n",
+							i,
+							item_count,
+							old_count);
+				}
 				rdma_recovery_count++;
 			}
 		}
@@ -470,8 +483,8 @@ EXPORT_SYMBOL(VSYNCOSD_RD_MPEG_REG);
 
 int VSYNCOSD_WR_MPEG_REG(u32 addr, u32 val)
 {
-	int ret = 0;
-	u32 rdma_en = 0;
+	int ret = 0, k = 0;
+	u32 rdma_en = 0, trace_num = 0;
 
 	if (!is_rdma_reg(addr))
 		rdma_en = 0;
@@ -482,16 +495,27 @@ int VSYNCOSD_WR_MPEG_REG(u32 addr, u32 val)
 		ret = update_table_item(addr, val, 0);
 	else
 		osd_reg_write(addr, val);
+	if (osd_hw.rdma_trace_enable)
+		trace_num = osd_hw.rdma_trace_num;
+	else
+		trace_num = 0;
+	for (k = 0; k < trace_num; k++) {
+		if (addr == (osd_hw.rdma_trace_reg[k] & 0xffff))
+			pr_info("(%s), %04x=0x%08x, rdma_en=%d, ret=%d\n",
+				__func__,
+				addr, val,
+				rdma_en, ret);
+	}
 	return ret;
 }
 EXPORT_SYMBOL(VSYNCOSD_WR_MPEG_REG);
 
 int VSYNCOSD_WR_MPEG_REG_BITS(u32 addr, u32 val, u32 start, u32 len)
 {
-	unsigned long read_val;
-	unsigned long write_val;
-	int ret = 0;
-	u32 rdma_en = 0;
+	u32 read_val;
+	u32 write_val;
+	int ret = 0, k = 0;
+	u32 rdma_en = 0, trace_num = 0;
 
 	if (!is_rdma_reg(addr))
 		rdma_en = 0;
@@ -505,16 +529,27 @@ int VSYNCOSD_WR_MPEG_REG_BITS(u32 addr, u32 val, u32 start, u32 len)
 		ret = update_table_item(addr, write_val, 0);
 	} else
 		osd_reg_set_bits(addr, val, start, len);
+	if (osd_hw.rdma_trace_enable)
+		trace_num = osd_hw.rdma_trace_num;
+	else
+		trace_num = 0;
+	for (k = 0; k < trace_num; k++) {
+		if (addr == (osd_hw.rdma_trace_reg[k] & 0xffff))
+			pr_info("(%s), %04x=0x%08x, rdma_en=%d, ret=%d\n",
+				__func__,
+				addr, val,
+				rdma_en, ret);
+	}
 	return ret;
 }
 EXPORT_SYMBOL(VSYNCOSD_WR_MPEG_REG_BITS);
 
 int VSYNCOSD_SET_MPEG_REG_MASK(u32 addr, u32 _mask)
 {
-	unsigned long read_val;
-	unsigned long write_val;
-	int ret = 0;
-	u32 rdma_en = 0;
+	u32 read_val = 0;
+	u32 write_val = 0;
+	int ret = 0, k = 0;
+	u32 rdma_en = 0, trace_num = 0;
 
 	if (!is_rdma_reg(addr))
 		rdma_en = 0;
@@ -527,16 +562,27 @@ int VSYNCOSD_SET_MPEG_REG_MASK(u32 addr, u32 _mask)
 		ret = update_table_item(addr, write_val, 0);
 	} else
 		osd_reg_set_mask(addr, _mask);
+	if (osd_hw.rdma_trace_enable)
+		trace_num = osd_hw.rdma_trace_num;
+	else
+		trace_num = 0;
+	for (k = 0; k < trace_num; k++) {
+		if (addr == (osd_hw.rdma_trace_reg[k] & 0xffff))
+		pr_info("(%s) %04x=0x%08x->0x%08x, mask=0x%08x, rdma_en=%d, ret=%d\n",
+			__func__,
+			addr, read_val, write_val,
+			_mask, rdma_en, ret);
+	}
 	return ret;
 }
 EXPORT_SYMBOL(VSYNCOSD_SET_MPEG_REG_MASK);
 
 int VSYNCOSD_CLR_MPEG_REG_MASK(u32 addr, u32 _mask)
 {
-	unsigned long read_val;
-	unsigned long write_val;
-	int ret = 0;
-	u32 rdma_en = 0;
+	u32 read_val = 0;
+	u32 write_val = 0;
+	int ret = 0, k = 0;
+	u32 rdma_en = 0, trace_num = 0;
 
 	if (!is_rdma_reg(addr))
 		rdma_en = 0;
@@ -549,14 +595,25 @@ int VSYNCOSD_CLR_MPEG_REG_MASK(u32 addr, u32 _mask)
 		ret = update_table_item(addr, write_val, 0);
 	} else
 		osd_reg_clr_mask(addr, _mask);
+	if (osd_hw.rdma_trace_enable)
+		trace_num = osd_hw.rdma_trace_num;
+	else
+		trace_num = 0;
+	for (k = 0; k < trace_num; k++) {
+		if (addr == (osd_hw.rdma_trace_reg[k] & 0xffff))
+		pr_info("(%s) %04x=0x%08x->0x%08x, mask=0x%08x, rdma_en=%d, ret=%d\n",
+			__func__,
+			addr, read_val, write_val,
+			_mask, rdma_en, ret);
+	}
 	return ret;
 }
 EXPORT_SYMBOL(VSYNCOSD_CLR_MPEG_REG_MASK);
 
 int VSYNCOSD_IRQ_WR_MPEG_REG(u32 addr, u32 val)
 {
-	int ret = 0;
-	u32 rdma_en = 0;
+	int ret = 0, k = 0;
+	u32 rdma_en = 0, trace_num = 0;
 
 	if (!is_rdma_reg(addr))
 		rdma_en = 0;
@@ -567,6 +624,17 @@ int VSYNCOSD_IRQ_WR_MPEG_REG(u32 addr, u32 val)
 		ret = update_table_item(addr, val, 1);
 	else
 		osd_reg_write(addr, val);
+	if (osd_hw.rdma_trace_enable)
+		trace_num = osd_hw.rdma_trace_num;
+	else
+		trace_num = 0;
+	for (k = 0; k < trace_num; k++) {
+		if (addr == (osd_hw.rdma_trace_reg[k] & 0xffff))
+		pr_info("(%s), %04x=0x%08x, rdma_en=%d, ret=%d\n",
+			__func__,
+			addr, val,
+			rdma_en, ret);
+	}
 	return ret;
 }
 EXPORT_SYMBOL(VSYNCOSD_IRQ_WR_MPEG_REG);