rdma: extend multi-channel rdma watchdog [1/1]

PD#SWPL-150712

Problem:
abnormal video display when switching channels multiple times

Solution:
mutual interference among multiple channels
rendering the watchdog functionality ineffective
need to extend multi-channel rdma watchdog

Verify:
s1a-bg201

Change-Id: I09bb7ccbe2c6b3e511fc60f1c896f8a9d9f94b17
Signed-off-by: Jian Cao <jian.cao@amlogic.com>

drivers/media/common/rdma/rdma.c

@@ -57,7 +57,6 @@ static bool first_config[RDMA_NUM];
 static bool rdma_done[RDMA_NUM];
 static u32 cur_vsync_handle_id;
 static int ex_vsync_rdma_enable;
-static u32 rdma_reset;
 static int g_set_threshold[RDMA_NUM];
 static int g_set_threshold2[RDMA_NUM];
 static int g_cur_threshold[RDMA_NUM];
@@ -149,12 +148,6 @@ static void set_rdma_trigger_line(void)
 	aml_write_vcbus(VPP_INT_LINE_NUM, trigger_line);
 }
 
-void set_force_rdma_config(void)
-{
-	rdma_reset = 1;
-}
-EXPORT_SYMBOL(set_force_rdma_config);
-
 /*
  * Description: Determine whether to execute RDMA configuration.
  * Return:
@@ -245,7 +238,7 @@ int _vsync_rdma_config(int rdma_type)
 	int enable_ = cur_enable[rdma_type] & 0xf;
 	unsigned long flags;
 	struct timeval t;
-	int to_config;
+	int to_config, handle;
 
 	if (vsync_rdma_handle[rdma_type] <= 0)
 		return -1;
@@ -282,14 +275,15 @@ int _vsync_rdma_config(int rdma_type)
 	if (force_rdma_config[rdma_type])
 		rdma_done[rdma_type] = true;
 
+	handle = vsync_rdma_handle[rdma_type];
 	if (enable_ == 1) {
 		if (rdma_done[rdma_type])
-			iret = rdma_watchdog_setting(0);
+			iret = rdma_watchdog_setting(0, handle);
 		else
-			iret = rdma_watchdog_setting(1);
+			iret = rdma_watchdog_setting(1, handle);
 	} else {
 		/* not vsync mode */
-		iret = rdma_watchdog_setting(0);
+		iret = rdma_watchdog_setting(0, handle);
 		force_rdma_config[rdma_type] = 1;
 	}
 	rdma_done[rdma_type] = false;
@@ -297,7 +291,8 @@ int _vsync_rdma_config(int rdma_type)
 		force_rdma_config[rdma_type] = 1;
 
 	iret = 0;
-	if (to_config || force_rdma_config[rdma_type] || rdma_reset) {
+	if (to_config || force_rdma_config[rdma_type] ||
+	    rdma_reset_trigger_flag[handle]) {
 		if (enable_ == 1) {
 			if (has_multi_vpp) {
 				if (rdma_type == VSYNC_RDMA) {
@@ -379,8 +374,8 @@ int _vsync_rdma_config(int rdma_type)
 		} else {
 			force_rdma_config[rdma_type] = 0;
 			iret = 0;
-			if (rdma_reset) {
-				rdma_reset = 0;
+			if (rdma_reset_trigger_flag[handle]) {
+				rdma_reset_trigger_flag[handle] = 0;
 				iret = 1;
 			}
 		}
@@ -1363,17 +1358,17 @@ static ssize_t store_force_rdma_config(struct class *class,
 				       struct class_attribute *attr,
 				       const char *buf, size_t count)
 {
-	int i = 0;
-	int channel = 0;
+	int rdma_type = VSYNC_RDMA;
 	int parsed[2];
 
 	if (likely(parse_para(buf, 2, parsed) == 2)) {
-		channel = parsed[0];
-		if (channel < RDMA_NUM) {
-			force_rdma_config[channel] = parsed[1];
-			pr_info("force_rdma_config[%d]: %d\n", i, force_rdma_config[i]);
+		rdma_type = parsed[0];
+		if (rdma_type < RDMA_NUM) {
+			force_rdma_config[rdma_type] = parsed[1];
+			pr_info("force_rdma_config[%d]: %d\n",
+				rdma_type, force_rdma_config[rdma_type]);
 		} else {
-			pr_info("error please input: rdma_channel, force_rdma_config\n");
+			pr_info("error please input: rdma_type, force_rdma_config\n");
 		}
 	} else {
 		pr_info("error please input: rdma_channel, force_rdma_config\n");

drivers/media/common/rdma/rdma.h

@@ -19,6 +19,7 @@ extern int has_multi_vpp;
 extern ulong rdma_done_us[];
 extern ulong rdma_vsync_us[];
 extern ulong rdma_config_us[];
+extern int rdma_reset_trigger_flag[];
 
 void vpp1_vsync_rdma_register(void);
 void vpp2_vsync_rdma_register(void);
@@ -39,7 +40,7 @@ bool is_pre_vsync_rdma_enable(void);
 void start_rdma(void);
 void enable_rdma_log(int flag);
 void enable_rdma(int enable_flag);
-int rdma_watchdog_setting(int flag);
+int rdma_watchdog_setting(int flag, int handle);
 int rdma_init2(void);
 struct rdma_op_s *get_rdma_ops(int rdma_type);
 void set_rdma_handle(int rdma_type, int handle);
@@ -50,7 +51,7 @@ int rdma_init(void);
 void rdma_exit(void);
 int get_ex_vsync_rdma_enable(void);
 void set_ex_vsync_rdma_enable(int enable);
-void set_force_rdma_config(void);
+void set_force_rdma_config(int handle);
 int is_in_vsync_isr(void);
 int is_in_pre_vsync_isr(void);
 int is_in_vsync_isr_viu2(void);

drivers/media/common/rdma/rdma_mgr.c

@@ -52,9 +52,10 @@
 #define rdma_io_write(addr, val) writel((val), addr)
 
 /* #define SKIP_OSD_CHANNEL */
+#define RDMA_NUM        16
 int has_multi_vpp;
 int rdma_mgr_irq_request;
-int rdma_reset_trigger_flag;
+int rdma_reset_trigger_flag[RDMA_NUM];
 
 struct reset_control *rdma_rst;
 static int debug_flag;
@@ -63,10 +64,9 @@ static int ctrl_ahb_rd_burst_size = 3;
 static int ctrl_ahb_wr_burst_size = 3;
 static int rdma_watchdog = 20;
 static int reset_count;
-static int rdma_watchdog_count;
+static int rdma_watchdog_count[RDMA_NUM];
 static int rdma_force_reset = -1;
 
-#define RDMA_NUM        16
 #define RDMA_TABLE_SIZE (8 * (PAGE_SIZE))
 #define MAX_TRACE_NUM  16
 #define RDMA_MGR_CLASS_NAME  "rdma_mgr"
@@ -1189,31 +1189,41 @@ int rdma_buffer_unlock(int handle)
 }
 EXPORT_SYMBOL(rdma_buffer_unlock);
 
-int rdma_watchdog_setting(int flag)
+int rdma_watchdog_setting(int flag, int handle)
 {
 	int ret = 0;
 
+	if (handle < 0 || handle >= RDMA_NUM) {
+		pr_info("%s, flag:%d handle:%d out of range[0, %d)\n",
+			__func__, flag, handle, RDMA_NUM);
+		return 0;
+	}
+
 	if (flag == 0)
-		rdma_watchdog_count = 0;
+		rdma_watchdog_count[handle] = 0;
 	else
-		rdma_watchdog_count++;
+		rdma_watchdog_count[handle]++;
 
 	if (debug_flag & 8) {
 		rdma_force_reset = 1;
 		debug_flag = 0;
 	}
+	if (debug_flag & 0x40)
+		pr_info("%s, flag:%d handle:%d rdma_watchdog_count:%d\n",
+			__func__, flag, handle, rdma_watchdog_count[handle]);
+
 	if ((rdma_watchdog > 0 &&
-	     rdma_watchdog_count > rdma_watchdog) ||
+	     rdma_watchdog_count[handle] > rdma_watchdog) ||
 	     rdma_force_reset > 0) {
-		pr_info("%s rdma reset: %d, force flag:%d\n",
+		pr_info("%s rdma reset: %d, force flag:%d handle:%d\n",
 			__func__,
-			rdma_watchdog_count,
-			rdma_force_reset);
-		rdma_watchdog_count = 0;
+			rdma_watchdog_count[handle],
+			rdma_force_reset,
+			handle);
+		rdma_watchdog_count[handle] = 0;
 		rdma_force_reset = 0;
 		rdma_reset(1);
-		rdma_reset_trigger_flag = 1;
-		set_force_rdma_config();
+		rdma_reset_trigger_flag[handle] = 1;
 		ret = 1;
 	}
 	return ret;
@@ -1336,7 +1346,7 @@ int rdma_write_reg(int handle, u32 adr, u32 val)
 		int i;
 
 			pr_info("%s(%d, %x, %x ,%d) buf overflow, ins->rdma_item_count=%d\n",
-				__func__, rdma_watchdog_count,
+				__func__, rdma_watchdog_count[handle],
 				handle, adr, val,
 				ins->rdma_item_count);
 		for (i = 0; i < ins->rdma_item_count; i++)

drivers/media/osd/osd_rdma.c

@@ -594,9 +594,10 @@ static int update_table_item(u32 vpp_index, u32 addr, u32 val, u8 irq_mode)
 	int reject1 = 0, reject2 = 0, ret = 0;
 	ulong paddr;
 	static int pace_logging[VPP_NUM];
+	int handle = osd_rdma_handle[vpp_index];
 
 #ifdef CONFIG_AMLOGIC_MEDIA_RDMA
-	if (item_count[vpp_index] > 500 || rdma_reset_trigger_flag) {
+	if (item_count[vpp_index] > 500 || rdma_reset_trigger_flag[handle]) {
 //#else
 //	if (item_count[vpp_index] > 500) {
 #endif
@@ -1863,6 +1864,8 @@ void enable_vsync_rdma(u32 vpp_index)
 
 void osd_rdma_interrupt_done_clear(u32 vpp_index)
 {
+	int handle = osd_rdma_handle[vpp_index];
+
 	vsync_irq_count[vpp_index]++;
 
 #ifdef CONFIG_AMLOGIC_MEDIA_RDMA
@@ -1874,7 +1877,7 @@ void osd_rdma_interrupt_done_clear(u32 vpp_index)
 	osd_rdma_done[vpp_index] = false;
 
 #ifdef CONFIG_AMLOGIC_MEDIA_RDMA
-	if (rdma_reset_trigger_flag) {
+	if (rdma_reset_trigger_flag[handle]) {
 		u32 rdma_status;
 
 		rdma_status =
@@ -1883,7 +1886,7 @@ void osd_rdma_interrupt_done_clear(u32 vpp_index)
 			rdma_status);
 		osd_rdma_enable(vpp_index, 0);
 		osd_rdma_enable(vpp_index, 2);
-		rdma_reset_trigger_flag = 0;
+		rdma_reset_trigger_flag[handle] = 0;
 	}
 #endif
 }

drivers/media/osd/osd_rdma.h

@@ -10,7 +10,7 @@
 #include "osd_io.h"
 #include "osd_reg.h"
 
-extern int rdma_reset_trigger_flag;
+extern int rdma_reset_trigger_flag[];
 extern int rdma_mgr_irq_request;
 extern u32 osd_rdma_flag_reg[];
 extern u32 rdma_detect_reg;