lcd: optimize driver log [2/2]

PD#SWPL-185137

Problem:
need optimize driver log

Solution:
optimize driver log

Verify:
bc302

Change-Id: I472ae14740d8ba37821aa04665591f27e79447c2
Signed-off-by: Evoke Zhang <evoke.zhang@amlogic.com>

arch/arm/boot/dts/amlogic/mesont6d-panel.dtsi

@@ -15,7 +15,6 @@
 		compatible = "amlogic, lcd-t6d";
 		status = "okay";
 		index = <0>;
-		pxp = <0>;
 		mode = "tv";
 		fr_auto_policy = <1>; /* 0=disable, 1=enable */
 		key_valid = <1>;

arch/arm64/boot/dts/amlogic/mesont6d-panel.dtsi

@@ -15,7 +15,6 @@
 		compatible = "amlogic, lcd-t6d";
 		status = "okay";
 		index = <0>;
-		pxp = <0>;
 		mode = "tv";
 		fr_auto_policy = <1>; /* 0=disable, 1=enable */
 		key_valid = <1>;

drivers/media/vout/lcd/ambilight/ambilight_debug.c

@@ -529,7 +529,7 @@ int amblt_debug_file_add(struct amblt_drv_s *amblt_drv)
 		goto err4;
 	}
 
-	AMBLTPR("%s: OK\n", __func__);
+	//AMBLTPR("%s: OK\n", __func__);
 	return 0;
 
 err4:

drivers/media/vout/lcd/ambilight/ambilight_drv.c

@@ -256,8 +256,8 @@ static int amblt_get_config(struct amblt_drv_s *amblt_drv, struct platform_devic
 	amblt_drv->zone_h = para[0];
 	amblt_drv->zone_v = para[1];
 	amblt_drv->zone_size = para[0] * para[1];
-	AMBLTPR("%s: zone h=%d, v=%d, size=%d\n",
-		__func__, amblt_drv->zone_h, amblt_drv->zone_v, amblt_drv->zone_size);
+	//AMBLTPR("%s: zone h=%d, v=%d, size=%d\n",
+	//	__func__, amblt_drv->zone_h, amblt_drv->zone_v, amblt_drv->zone_size);
 	amblt_zone_pixel_init(amblt_drv);
 
 	amblt_drv->res_vs_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "vsync");

drivers/media/vout/lcd/backlight/bl_ldim/ldim_dev_drv.c

@@ -377,7 +377,8 @@ static int ldim_pwm_pinmux_ctrl(struct ldim_dev_driver_s *dev_drv, int status)
 		LDIMERR("set pinmux %s error\n", str);
 		ret = -1;
 	} else {
-		LDIMPR("set pinmux %s: 0x%p\n", str, dev_drv->pin);
+		if (ldim_debug_print)
+			LDIMPR("set pinmux %s: 0x%p\n", str, dev_drv->pin);
 	}
 	dev_drv->pinmux_flag = index;
 
@@ -979,7 +980,8 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 	struct ldim_profile_s *profile;
 	struct ldim_fw_s *fw = aml_ldim_get_fw();
 	struct ldim_fw_custom_s *fw_cus = aml_ldim_get_fw_cus();
-	int i, ret = 0;
+	char dbg_str[256];
+	int i, dbg_str_len = 0, ret = 0;
 
 	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL)
 		LDIMPR("load ldim_dev config from dts\n");
@@ -1011,8 +1013,6 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 		dev_drv->type = LDIM_DEV_TYPE_NORMAL;
 	} else {
 		dev_drv->type = val;
-		if (ldim_debug_print)
-			LDIMPR("type: %d\n", dev_drv->type);
 	}
 	if (dev_drv->type >= LDIM_DEV_TYPE_MAX) {
 		LDIMERR("type num is out of support\n");
@@ -1176,12 +1176,10 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 	}
 
 	ret = of_property_read_string(child, "ldim_pwm_pinmux_sel", &str);
-	if (ret) {
+	if (ret)
 		strcpy(dev_drv->pinmux_name, "invalid");
-	} else {
-		LDIMPR("find customer ldim_pwm_pinmux_sel: %s\n", str);
+	else
 		strcpy(dev_drv->pinmux_name, str);
-	}
 
 	ret = of_property_read_u32_array(child, "en_gpio_on_off", temp, 3);
 	if (ret) {
@@ -1233,6 +1231,12 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 		dev_drv->dim_min = temp[1];
 	}
 
+	ret = of_property_read_u32(child, "chip_count", &val);
+	if (ret)
+		dev_drv->chip_cnt = 1;
+	else
+		dev_drv->chip_cnt = val;
+
 	ret = of_property_read_u32(child, "mcu_header", &val);
 	if (ret)
 		dev_drv->mcu_header = 0;
@@ -1244,8 +1248,6 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 		dev_drv->mcu_dim = 0;
 	else
 		dev_drv->mcu_dim = (unsigned int)val;
-	LDIMPR("mcu_header: 0x%x, mcu_dim: 0x%x\n",
-	dev_drv->mcu_header, dev_drv->mcu_dim);
 
 	ret = of_property_read_u32(child, "spi_line_n", &val);
 	if (ret) {
@@ -1257,7 +1259,15 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 		dev_drv->spi_line_n = (unsigned int)val;
 		ldim_spi_controller_data.use_ctrl_cs = 1;
 	}
-	LDIMPR("spi_sync:%d, spi_line_n: %d\n", dev_drv->spi_sync, dev_drv->spi_line_n);
+
+	dbg_str_len += sprintf(dbg_str + dbg_str_len, "mcu_header=0x%08x, mcu_dim=0x%08x,",
+		dev_drv->mcu_header, dev_drv->mcu_dim);
+	dbg_str_len += sprintf(dbg_str + dbg_str_len, "spi_sync:%d, spi_line_n: %d,",
+		dev_drv->spi_sync, dev_drv->spi_line_n);
+	sprintf(dbg_str + dbg_str_len, "chip_cnt:%d, cus pwm_pinmux_sel:%s",
+		dev_drv->chip_cnt, dev_drv->pinmux_name);
+	LDIMPR("load dts config: %s: type:%d, %s\n",
+		dev_drv->name, dev_drv->type, dbg_str);
 
 	/*boost_conf*/
 	ret = of_property_read_u32_array(child, "boost_conf", temp, 7);
@@ -1279,19 +1289,11 @@ static int ldim_dev_get_config_from_dts(struct ldim_dev_driver_s *dev_drv,
 		dev_drv->boost_conf.kp_l100 = (unsigned char)temp[5];
 		dev_drv->boost_conf.kp_l32 = (unsigned char)temp[6];
 	}
-	LDIMPR("boost_conf: en:%d, mode:%d, imax: %d, i_l100: %d\n"
-		"i_l32:%d, kp_l100:%d, kp_l32:%d\n",
+	LDIMPR("boost_conf: en:%d, mode:%d, imax:%d, i_l100:%d, i_l32:%d, kp_l100:%d, kp_l32:%d\n",
 		dev_drv->boost_conf.en, dev_drv->boost_conf.mode,
 		dev_drv->boost_conf.i_max, dev_drv->boost_conf.i_l100, dev_drv->boost_conf.i_l32,
 		dev_drv->boost_conf.kp_l100, dev_drv->boost_conf.kp_l32);
 
-	ret = of_property_read_u32(child, "chip_count", &val);
-	if (ret)
-		dev_drv->chip_cnt = 1;
-	else
-		dev_drv->chip_cnt = val;
-	LDIMPR("chip_count: %d\n", dev_drv->chip_cnt);
-
 	ret = of_property_read_string(child, "ldim_zone_mapping_path", &str);
 	if (ret == 0) {
 		LDIMPR("find custom ldim_zone_mapping\n");
@@ -1410,16 +1412,13 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 	int key_len, len;
 	const char *str;
 	unsigned int temp, temp_val;
-	struct aml_lcd_unifykey_header_s *ldev_header;
 	struct bl_pwm_config_s *bl_pwm;
 	struct ldim_profile_s *profile;
-	int i, ret = 0;
+	char dbg_str[256];
+	int i, dbg_str_len = 0, ret = 0;
 	struct ldim_fw_s *fw = aml_ldim_get_fw();
 	struct ldim_fw_custom_s *fw_cus = aml_ldim_get_fw_cus();
 
-	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL)
-		LDIMPR("load ldim_dev config from unifykey\n");
-
 	ret = lcd_unifykey_get_size("ldim_dev", &key_len);
 	if (ret)
 		return -1;
@@ -1437,13 +1436,8 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 	}
 
 	/* step 1: check header */
-	ldev_header = (struct aml_lcd_unifykey_header_s *)para;
-	LDIMPR("unifykey version: 0x%04x\n", ldev_header->version);
-	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL) {
-		LDIMPR("unifykey header:\n");
-		LDIMPR("crc32             = 0x%08x\n", ldev_header->crc32);
-		LDIMPR("data_len          = %d\n", ldev_header->data_len);
-	}
+	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL)
+		lcd_unifykey_header_print(para);
 
 	/* step 2: check parameters */
 	len = 65; //10+30+25
@@ -1578,12 +1572,10 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 	}
 
 	str = (const char *)(p + LCD_UKEY_LDIM_DEV_PINMUX_SEL);
-	if (strlen(str) == 0) {
+	if (strlen(str) == 0)
 		strcpy(dev_drv->pinmux_name, "invalid");
-	} else {
+	else
 		strncpy(dev_drv->pinmux_name, str, (LDIM_DEV_NAME_MAX - 1));
-		LDIMPR("find customer ldim_pwm_pinmux_sel: %s\n", str);
-	}
 
 	/* ctrl (271Byte) */
 	temp = *(p + LCD_UKEY_LDIM_DEV_EN_GPIO);
@@ -1610,12 +1602,10 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 	temp = (*(p + LCD_UKEY_LDIM_DEV_ON_DELAY) |
 			((*(p + LCD_UKEY_LDIM_DEV_ON_DELAY + 1)) << 8));
 	dev_drv->hw_on_delay = temp;
-	LDIMPR("hw_on_delay: %d ms\n", dev_drv->hw_on_delay);
 
 	temp = (*(p + LCD_UKEY_LDIM_DEV_OFF_DELAY) |
 			((*(p + LCD_UKEY_LDIM_DEV_OFF_DELAY + 1)) << 8));
 	dev_drv->hw_off_delay = temp;
-	LDIMPR("hw_off_delay: %d ms\n", dev_drv->hw_off_delay);
 
 	dev_drv->write_check = *(p + LCD_UKEY_LDIM_DEV_WRITE_CHECK);
 
@@ -1629,7 +1619,6 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 	dev_drv->chip_cnt =
 		(*(p + LCD_UKEY_LDIM_DEV_CHIP_COUNT) |
 		((*(p + LCD_UKEY_LDIM_DEV_CHIP_COUNT + 1)) << 8));
-	LDIMPR("chip_count: %d\n", dev_drv->chip_cnt);
 
 	dev_drv->mcu_header =
 		(*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_0) |
@@ -1641,8 +1630,6 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 		((*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_1 + 1)) << 8) |
 		((*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_1 + 2)) << 16) |
 		((*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_1 + 3)) << 24));
-	LDIMPR("mcu_header: 0x%x, mcu_dim: 0x%x\n",
-	dev_drv->mcu_header, dev_drv->mcu_dim);
 
 	temp =	(*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_2) |
 		((*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_2 + 1)) << 8) |
@@ -1657,7 +1644,17 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 		dev_drv->spi_line_n = temp;
 		ldim_spi_controller_data.use_ctrl_cs = 1;
 	}
-	LDIMPR("spi_sync: %d ,spi_line_n: %d\n", dev_drv->spi_sync, dev_drv->spi_line_n);
+
+	dbg_str_len += sprintf(dbg_str + dbg_str_len, "mcu_header=0x%08x, mcu_dim=0x%08x, ",
+		dev_drv->mcu_header, dev_drv->mcu_dim);
+	dbg_str_len += sprintf(dbg_str + dbg_str_len, "spi_sync:%d, spi_line_n: %d, ",
+		dev_drv->spi_sync, dev_drv->spi_line_n);
+	sprintf(dbg_str + dbg_str_len,
+		"chip_cnt:%d, hw_on_delay: %dms, hw_off_delay: %dms, cus pwm_pinmux_sel:%s",
+		dev_drv->chip_cnt, dev_drv->hw_on_delay, dev_drv->hw_off_delay,
+		dev_drv->pinmux_name);
+	LDIMPR("load ukey config: %s: type:%d, %s\n",
+		dev_drv->name, dev_drv->type, dbg_str);
 
 	/* boost_conf (8Byte) */
 	temp =	(*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_3) |
@@ -1680,8 +1677,7 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 		((*(p + LCD_UKEY_LDIM_DEV_CUST_ATTR_5 + 3)) << 24));
 	dev_drv->boost_conf.i_max = temp & 0xffff;
 
-	LDIMPR("boost_conf: en:%d, mode:%d, imax: %d, i_l100: %d\n"
-		"i_l32:%d, kp_l100:%d, kp_l32:%d\n",
+	LDIMPR("boost_conf: en:%d, mode:%d, imax:%d, i_l100:%d, i_l32:%d, kp_l100:%d, kp_l32:%d\n",
 		dev_drv->boost_conf.en, dev_drv->boost_conf.mode,
 		dev_drv->boost_conf.i_max, dev_drv->boost_conf.i_l100, dev_drv->boost_conf.i_l32,
 		dev_drv->boost_conf.kp_l100, dev_drv->boost_conf.kp_l32);
@@ -1691,7 +1687,7 @@ static int ldim_dev_get_config_from_ukey(struct ldim_dev_driver_s *dev_drv,
 		for (i = 0; i < dev_drv->zone_num; i++)
 			dev_drv->bl_mapping[i] = (unsigned short)i;
 	} else {
-		LDIMPR("find custom ldim_zone_mapping\n");
+		LDIMPR("find custom zone_mapping\n");
 		strncpy(dev_drv->bl_mapping_path, str, 255);
 		ret = ldim_dev_zone_mapping_load(dev_drv, str);
 		if (ret) {
@@ -1796,7 +1792,6 @@ static int ldim_dev_get_config(struct ldim_dev_driver_s *dev_drv,
 		val = 0;
 	}
 	dev_drv->key_valid = val;
-	LDIMPR("key_valid: %d\n", dev_drv->key_valid);
 
 	ret = of_property_read_u32(np, "ldim_pwm_config", &pwm_phandle);
 	if (ret) {

drivers/media/vout/lcd/backlight/bl_ldim/ldim_drv.c

@@ -740,8 +740,10 @@ static long ldim_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 	unsigned int *bl_matrix;
 
 	mcd_nr = _IOC_NR(cmd);
-	LDIMPR("%s: cmd_dir = 0x%x, cmd_nr = 0x%x\n",
-	       __func__, _IOC_DIR(cmd), mcd_nr);
+	if (ldim_debug_print) {
+		LDIMPR("%s: cmd_dir = 0x%x, cmd_nr = 0x%x\n",
+			__func__, _IOC_DIR(cmd), mcd_nr);
+	}
 
 	if (bdrv->bconf.method != BL_CTRL_LOCAL_DIMMING) {
 		LDIMERR("%s: bconf.method is not ldim!!\n", __func__);
@@ -1009,8 +1011,6 @@ int aml_ldim_get_config_dts(struct device_node *child)
 	}
 	ldim_config.seg_row = para[0];
 	ldim_config.seg_col = para[1];
-	LDIMPR("get bl_zone row = %d, col = %d\n",
-	       ldim_config.seg_row, ldim_config.seg_col);
 
 aml_ldim_get_config_dts_next:
 	/* get bl_mode from dts */
@@ -1019,7 +1019,8 @@ aml_ldim_get_config_dts_next:
 		LDIMERR("failed to get bl_ldim_mode\n");
 	else
 		ldim_config.bl_mode = (unsigned char)para[0];
-	LDIMPR("get bl_mode = %d\n", ldim_config.bl_mode);
+	LDIMPR("get bl_zone row = %d, col = %d, bl_mode = %d\n",
+		ldim_config.seg_row, ldim_config.seg_col, ldim_config.bl_mode);
 
 	/* get ldim_dev_index from dts */
 	ret = of_property_read_u32(child, "ldim_dev_index", &para[0]);
@@ -1041,12 +1042,11 @@ int aml_ldim_get_config_unifykey(unsigned char *buf)
 	/* get bl_ldim_region_row_col 4byte*/
 	ldim_config.seg_row = *(p + LCD_UKEY_BL_LDIM_ROW);
 	ldim_config.seg_col = *(p + LCD_UKEY_BL_LDIM_COL);
-	LDIMPR("get bl_zone row = %d, col = %d\n",
-	       ldim_config.seg_row, ldim_config.seg_col);
 
 	/* get bl_ldim_mode 1byte*/
 	ldim_config.bl_mode = *(p + LCD_UKEY_BL_LDIM_MODE);
-	LDIMPR("get bl_mode = %d\n", ldim_config.bl_mode);
+	LDIMPR("get bl_zone row = %d, col = %d, bl_mode = %d\n",
+		ldim_config.seg_row, ldim_config.seg_col, ldim_config.bl_mode);
 
 	/* get ldim_dev_index 1byte*/
 	ldim_config.dev_index = *(p + LCD_UKEY_BL_LDIM_DEV_INDEX);
@@ -1377,7 +1377,6 @@ int aml_ldim_probe(struct platform_device *pdev)
 		LDIMERR("ldim_vsync_irq resource error\n");
 		goto err4;
 	}
-	LDIMPR("ldim_vsync_irq: %d\n", ldim_vsync_irq);
 	if (request_irq(ldim_vsync_irq, ldim_vsync_isr, IRQF_SHARED,
 		"ldim_vsync", (void *)"ldim_vsync")) {
 		LDIMERR("can't request ldim_vsync_irq(%d)\n", ldim_vsync_irq);
@@ -1389,11 +1388,11 @@ int aml_ldim_probe(struct platform_device *pdev)
 		LDIMERR("ldim_pwm_vs_irq resource error\n");
 		goto err4;
 	}
-	LDIMPR("ldim_pwm_vs_irq: %d\n", ldim_pwm_vs_irq);
 	if (request_irq(ldim_pwm_vs_irq, ldim_pwm_vs_isr, IRQF_TRIGGER_FALLING,
 		"ldim_pwm_vs", (void *)"ldim_pwm_vs")) {
 		LDIMERR("can't request ldim_pwm_vs_irq(%d)\n", ldim_pwm_vs_irq);
 	}
+	LDIMPR("ldim_vsync_irq: %d, ldim_pwm_vs_irq: %d\n", ldim_vsync_irq, ldim_pwm_vs_irq);
 
 	ldim_driver.valid_flag = 1;
 

drivers/media/vout/lcd/backlight/bl_ldim/mcu_bl.c

@@ -362,12 +362,14 @@ static int blmcu_power_on(struct aml_ldim_driver_s *ldim_drv)
 
 static int blmcu_power_off(struct aml_ldim_driver_s *ldim_drv)
 {
-	LDIMPR("enter %s\n", __func__);
+	if (ldim_debug_print)
+		LDIMPR("enter %s\n", __func__);
 
 	if (!bl_mcu)
 		return -1;
 
-	LDIMPR("enter %s111\n", __func__);
+	if (ldim_debug_print)
+		LDIMPR("enter %s111\n", __func__);
 
 	mutex_lock(&dev_mutex);
 	bl_mcu->dev_on_flag = 0;

drivers/media/vout/lcd/backlight/bl_pwm.c

@@ -807,8 +807,10 @@ int bl_pwm_channel_register(struct device *dev, phandle pwm_phandle,
 		}
 		bl_pwm->pwm_data.meson = to_meson_pwm(bl_pwm->pwm_data.pwm->chip);
 		pwm_init_state(bl_pwm->pwm_data.pwm, &bl_pwm->pwm_data.state);
-		BLPR("register %s(%d) 0x%px\n",
-		     pwm_str, bl_pwm->pwm_data.meson_index, bl_pwm->pwm_data.pwm);
+		if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL) {
+			BLPR("register %s(%d) 0x%px\n",
+				pwm_str, bl_pwm->pwm_data.meson_index, bl_pwm->pwm_data.pwm);
+		}
 	}
 
 	return ret;

drivers/media/vout/lcd/backlight/lcd_bl.c

@@ -372,7 +372,7 @@ static void bl_pwm_ctrl_status_set(struct aml_bl_drv_s *bdrv, int status)
 		bl_pwm_ctrl(bconf->bl_pwm_combo1, status);
 		break;
 	default:
-		BLPR("invalid pwm control method\n");
+		break;
 	}
 
 	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL)
@@ -908,10 +908,6 @@ static void bl_config_print(struct aml_bl_drv_s *bdrv)
 		return;
 	}
 
-	BLPR("[%d]: name = %s, method = %s(%d)\n",
-	     bdrv->index, bconf->name,
-	     bl_method_type_to_str(bconf->method), bconf->method);
-
 	if ((lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL) == 0)
 		return;
 
@@ -1028,7 +1024,8 @@ static int bl_config_load_from_dts(struct aml_bl_drv_s *bdrv)
 	struct device_node *child;
 	struct bl_pwm_config_s *bl_pwm;
 	struct bl_pwm_config_s *pwm_combo0, *pwm_combo1;
-	int val;
+	char str_info[128];
+	int val, str_info_len = 0;
 	int ret = 0;
 
 	/* select backlight by index */
@@ -1038,7 +1035,6 @@ static int bl_config_load_from_dts(struct aml_bl_drv_s *bdrv)
 		return -1;
 	}
 	sprintf(bl_propname, "backlight_%d", bconf->index);
-	BLPR("[%d]: load: %s\n", bdrv->index, bl_propname);
 	child = of_get_child_by_name(bdrv->dev->of_node, bl_propname);
 	if (!child) {
 		BLERR("[%d]: failed to get %s\n", bdrv->index, bl_propname);
@@ -1063,16 +1059,8 @@ static int bl_config_load_from_dts(struct aml_bl_drv_s *bdrv)
 
 		bdrv->brightness_bypass = ((para[1] >> BL_POLICY_BRIGHTNESS_BYPASS_BIT) &
 					   BL_POLICY_BRIGHTNESS_BYPASS_MASK);
-		if (bdrv->brightness_bypass) {
-			BLPR("[%d]: 0x%x: enable brightness_bypass\n",
-			     bdrv->index, para[1]);
-		}
 		bdrv->step_on_flag = ((para[1] >> BL_POLICY_POWER_ON_BIT) &
 				      BL_POLICY_POWER_ON_MASK);
-		if (bdrv->step_on_flag) {
-			BLPR("[%d]: 0x%x: bl_step_on_flag: %d\n",
-			     bdrv->index, para[1], bdrv->step_on_flag);
-		}
 	}
 
 	ret = of_property_read_u32_array(child, "bl_level_attr", &para[0], 4);
@@ -1096,6 +1084,7 @@ static int bl_config_load_from_dts(struct aml_bl_drv_s *bdrv)
 	} else {
 		bconf->method = (val >= BL_CTRL_MAX) ? BL_CTRL_MAX : val;
 	}
+
 	ret = of_property_read_u32_array(child, "bl_power_attr", &para[0], 5);
 	if (ret) {
 		BLERR("[%d]: failed to get bl_power_attr\n", bdrv->index);
@@ -1117,25 +1106,35 @@ static int bl_config_load_from_dts(struct aml_bl_drv_s *bdrv)
 		bconf->power_off_delay = para[4];
 	}
 	ret = of_property_read_u32(child, "en_sequence_reverse", &val);
-	if (ret) {
+	if (ret)
 		bconf->en_sequence_reverse = 0;
-	} else {
+	else
 		bconf->en_sequence_reverse = val;
-		BLPR("[%d]: find en_sequence_reverse: %d\n", bdrv->index, val);
-	}
 
 	ret = of_property_read_u32(child, "bl_ldim_region_row_col", &para[0]);
 	if (ret) {
 		ret = of_property_read_u32(child, "bl_ldim_zone_row_col", &para[0]);
-		if (ret == 0) {
+		if (ret == 0)
 			bconf->ldim_flag = 1;
-			BLPR("[%d]: ldim_flag: %d\n", bdrv->index, bconf->ldim_flag);
-		}
 	} else {
 		bconf->ldim_flag = 1;
-		BLPR("[%d]: ldim_flag: %d\n", bdrv->index, bconf->ldim_flag);
 	}
 
+	str_info_len += sprintf(str_info + str_info_len, "bri_bypass:%d, ",
+			bdrv->brightness_bypass);
+	str_info_len += sprintf(str_info + str_info_len, "step_on_flag:%d, ",
+			bdrv->step_on_flag);
+	str_info_len += sprintf(str_info + str_info_len, "en_seq_rev:%d",
+			bconf->en_sequence_reverse);
+	if (bconf->ldim_flag) {
+		sprintf(str_info + str_info_len, ", ldim_flag:%d (%dx%d)",
+			bconf->ldim_flag, para[0], para[1]);
+	}
+	BLPR("[%d]: config from dts: %s: %s, method: %s(%d), %s\n",
+		bdrv->index, bl_propname, bconf->name,
+		bl_method_type_to_str(bconf->method),
+		bconf->method, str_info);
+
 	switch (bconf->method) {
 	case BL_CTRL_PWM:
 		bconf->bl_pwm = kzalloc(sizeof(*bconf->bl_pwm), GFP_KERNEL);
@@ -1387,7 +1386,8 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 	struct bl_pwm_config_s *bl_pwm;
 	struct bl_pwm_config_s *pwm_combo0, *pwm_combo1;
 	unsigned int level, tempfreq;
-	int ret;
+	char str_info[128];
+	int str_info_len = 0, ret;
 
 	if (!key_name)
 		return -1;
@@ -1408,12 +1408,8 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 
 	/* step 1: check header */
 	bl_header = (struct aml_lcd_unifykey_header_s *)para;
-	BLPR("[%d]: unifykey version: 0x%04x\n", bdrv->index, bl_header->version);
-	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL) {
-		BLPR("unifykey header:\n");
-		BLPR("crc32             = 0x%08x\n", bl_header->crc32);
-		BLPR("data_len          = %d\n", bl_header->data_len);
-	}
+	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL)
+		lcd_unifykey_header_print(para);
 
 	/* step 2: check backlight parameters */
 	switch (bl_header->version) {
@@ -1426,7 +1422,7 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 	}
 	ret = lcd_unifykey_len_check(key_len, len);
 	if (ret < 0) {
-		BLERR("[%d]: unifykey length is incorrect\n", bdrv->index);
+		BLERR("[%d]: ukey length is incorrect\n", bdrv->index);
 		kfree(para);
 		return -1;
 	}
@@ -1455,16 +1451,7 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 	bdrv->brightness_bypass =
 		((level >> BL_POLICY_BRIGHTNESS_BYPASS_BIT) &
 		 BL_POLICY_BRIGHTNESS_BYPASS_MASK);
-	if (bdrv->brightness_bypass) {
-		BLPR("[%d]: 0x%x: enable brightness_bypass\n",
-		     bdrv->index, level);
-	}
-	bdrv->step_on_flag = ((level >> BL_POLICY_POWER_ON_BIT) &
-			      BL_POLICY_POWER_ON_MASK);
-	if (bdrv->step_on_flag) {
-		BLPR("[%d]: 0x%x: bl_step_on_flag: %d\n",
-		     bdrv->index, level, bdrv->step_on_flag);
-	}
+	bdrv->step_on_flag = ((level >> BL_POLICY_POWER_ON_BIT) & BL_POLICY_POWER_ON_MASK);
 
 	/* method: 8byte */
 	temp = *(p + LCD_UKEY_BL_METHOD);
@@ -1487,11 +1474,8 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 		bconf->en_sequence_reverse = (*(p + LCD_UKEY_BL_CUST_VAL_0) |
 				((*(p + LCD_UKEY_BL_CUST_VAL_0 + 1)) << 8));
 		/* check ldim_flag */
-		BLPR("row: %d col: %d\n", *(p + LCD_UKEY_BL_LDIM_ROW), *(p + LCD_UKEY_BL_LDIM_COL));
-		if ((*(p + LCD_UKEY_BL_LDIM_ROW) > 0) && (*(p + LCD_UKEY_BL_LDIM_COL) > 0)) {
+		if ((*(p + LCD_UKEY_BL_LDIM_ROW) > 0) && (*(p + LCD_UKEY_BL_LDIM_COL) > 0))
 			bconf->ldim_flag = 1;
-			BLPR("[%d]: ldim_flag: %d\n", bdrv->index, bconf->ldim_flag);
-		}
 
 		/* load switch info */
 		bconf->bl_pwm_switch_port = *(p + LCD_UKEY_BL_CUST_VAL_1);
@@ -1503,6 +1487,21 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 		bconf->en_sequence_reverse = 0;
 	}
 
+	str_info_len += sprintf(str_info + str_info_len, "bri_bypass:%d, ",
+			bdrv->brightness_bypass);
+	str_info_len += sprintf(str_info + str_info_len, "step_on_flag:%d, ",
+			bdrv->step_on_flag);
+	str_info_len += sprintf(str_info + str_info_len, "en_seq_rev:%d",
+			bconf->en_sequence_reverse);
+	if (bconf->ldim_flag) {
+		sprintf(str_info + str_info_len, ", ldim_flag:%d (%dx%d)",
+			bconf->ldim_flag,
+			*(p + LCD_UKEY_BL_LDIM_ROW), *(p + LCD_UKEY_BL_LDIM_COL));
+	}
+	BLPR("[%d]: config from ukey: %s, method: %s(%d), %s\n",
+		bdrv->index, bconf->name, bl_method_type_to_str(bconf->method), bconf->method,
+		str_info);
+
 	/* pwm: 24byte */
 	switch (bconf->method) {
 	case BL_CTRL_PWM:
@@ -1674,18 +1673,13 @@ static int bl_config_load_from_unifykey(struct aml_bl_drv_s *bdrv, char *key_nam
 		bconf->bl_pwm_switch->pwm_freq = bconf->bl_pwm_switch_freq;
 		bl_pwm_config_init(bconf->bl_pwm_switch);
 
-		if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL) {
-			BLPR("bl_pwm_default_port: %d\n", bconf->bl_pwm_default->pwm_port);
-			BLPR("bl_pwm_default_freq: %d\n", bconf->bl_pwm_default->pwm_freq);
-			BLPR("[%d]: bl_pwm_switch_port: %s(0x%x)\n",
-					bdrv->index, bl_pwm_num_to_str(bconf->bl_pwm_switch_port),
-					bconf->bl_pwm_switch_port);
-			BLPR("[%d]: bl_pwm_switch_freq: %d\n",
-				bdrv->index, bconf->bl_pwm_switch_freq);
-		}
+		BLPR("[%d]: pwm_switch port_freq: dft: %s(0x%x),%d, switch: %s(0x%x),%d\n",
+			bdrv->index, bl_pwm_num_to_str(bconf->bl_pwm_default->pwm_port),
+			bconf->bl_pwm_default->pwm_port, bconf->bl_pwm_default->pwm_freq,
+			bl_pwm_num_to_str(bconf->bl_pwm_switch_port),
+			bconf->bl_pwm_switch_port, bconf->bl_pwm_switch_freq);
 	} else {
 		bconf->bl_pwm_switch = NULL;
-		BLPR("no switch pwm port\n");
 	}
 
 	kfree(para);
@@ -1707,7 +1701,6 @@ static int bl_config_load(struct aml_bl_drv_s *bdrv, struct platform_device *pde
 		if (ret < 0)
 			return -1;
 
-		BLPR("[%d]: %s from unifykey\n", bdrv->index, __func__);
 		bdrv->config_load = 1;
 		ret = bl_config_load_from_unifykey(bdrv, ukey_name);
 	} else {
@@ -4375,7 +4368,7 @@ static void aml_bl_config_probe_work(struct work_struct *p_work)
 					LCD_UNIFYKEY_RETRY_INTERVAL);
 				return;
 			}
-			BLERR("[%d]: key_init_flag=%d\n", bdrv->index, is_init);
+			BLERR("[%d]: key_init_flag=%d, timeout\n", bdrv->index, is_init);
 			goto err;
 		}
 		load_id = 1;
@@ -4441,7 +4434,8 @@ static void aml_bl_config_probe_work(struct work_struct *p_work)
 	bl_vsync_irq_init(bdrv);
 	bl_debug_file_creat(bdrv);
 
-	BLPR("[%d]: %s: ok\n", index, __func__);
+	if (lcd_debug_print_flag & LCD_DBG_PR_BL_NORMAL)
+		BLPR("[%d]: %s: ok\n", index, __func__);
 	return;
 
 err:
@@ -4481,7 +4475,6 @@ static void bl_base_config_init(struct aml_bl_drv_s *bdrv)
 		temp = 0;
 	}
 	bdrv->key_valid = temp;
-	BLPR("[%d]: key_valid: %d\n", bdrv->index, bdrv->key_valid);
 }
 
 int aml_bl_index_add(int drv_index, int conf_index)

drivers/media/vout/lcd/lcd_clk/lcd_clk_c3.c

@@ -54,7 +54,7 @@ set_pll_retry_c3:
 	lcd_ana_write(ANACTRL_GP0PLL_CTRL2, 0x00023001);
 	lcd_delay_us(20);
 
-	ret = lcd_pll_wait_lock(ANACTRL_GP0PLL_STS, 31);
+	ret = lcd_pll_wait_lock(cconf->pll_id, ANACTRL_GP0PLL_STS, 31);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_c3;

drivers/media/vout/lcd/lcd_clk/lcd_clk_if.c

@@ -117,7 +117,8 @@ static void lcd_bit_rate_match_phy(struct aml_lcd_drv_s *pdrv)
 		LCDPR("%s act_phy[%d], clk:%d\n", __func__, i, phy_cfg->act_phy->phy_clk);
 		return;
 	}
-	LCDPR("no phy_clk matched, use default(phy[0])\n");
+	if (phy_cfg->phys[0]->phy_clk)
+		LCDPR("no phy_clk matched, use default(phy[0])\n");
 }
 
 static void lcd_phy_match_ss(struct aml_lcd_drv_s *pdrv)
@@ -628,7 +629,8 @@ void lcd_clk_gate_switch(struct aml_lcd_drv_s *pdrv, int status)
 		return;
 
 	if (cconf->clktree.clk_gate_state == status) {
-		LCDPR("[%d]: clk gate is already %s\n", pdrv->index, status ? "on" : "off");
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+			LCDPR("[%d]: gate is already %s\n", pdrv->index, status ? "on" : "off");
 		return;
 	}
 

drivers/media/vout/lcd/lcd_clk/lcd_clk_s6.c

@@ -170,7 +170,7 @@ set_pll_retry:
 	lcd_ana_write(ANACTRL_DSIPLL_CTRL3, 0x20008010);
 	lcd_delay_us(20);
 
-	ret = lcd_pll_wait_lock(ANACTRL_DSIPLL_CTRL0, 31);
+	ret = lcd_pll_wait_lock(cconf->pll_id, ANACTRL_DSIPLL_CTRL0, 31);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry;

drivers/media/vout/lcd/lcd_clk/lcd_clk_t3x.c

@@ -283,7 +283,7 @@ set_pll_retry:
 	udelay(10);
 	lcd_ana_write(reg_ctrl2, 0x0000300c);
 
-	ret = lcd_pll_wait_lock(pll_stts, LCD_PLL_LOCK_T7);
+	ret = lcd_pll_wait_lock(cconf->pll_id, pll_stts, LCD_PLL_LOCK_T7);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry;

drivers/media/vout/lcd/lcd_clk/lcd_clk_t5_t5d.c

@@ -238,7 +238,7 @@ set_pll_retry_tl1:
 	usleep_range(10, 15);
 	lcd_ana_write(HHI_TCON_PLL_CNTL2, 0x0000300c);
 
-	ret = lcd_pll_wait_lock(HHI_TCON_PLL_CNTL0, LCD_PLL_LOCK_TL1);
+	ret = lcd_pll_wait_lock(cconf->pll_id, HHI_TCON_PLL_CNTL0, LCD_PLL_LOCK_TL1);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_tl1;

drivers/media/vout/lcd/lcd_clk/lcd_clk_t5w.c

@@ -209,7 +209,7 @@ set_pll_retry_tl1:
 	udelay(10);
 	lcd_ana_write(HHI_TCON_PLL_CNTL2, 0x0000300c);
 
-	ret = lcd_pll_wait_lock(HHI_TCON_PLL_CNTL0, LCD_PLL_LOCK_TL1);
+	ret = lcd_pll_wait_lock(cconf->pll_id, HHI_TCON_PLL_CNTL0, LCD_PLL_LOCK_TL1);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_tl1;

drivers/media/vout/lcd/lcd_clk/lcd_clk_t6d.c

@@ -194,7 +194,7 @@ static void lcd_set_pll_t6d(struct aml_lcd_drv_s *pdrv)
 		lcd_ana_setb(ANACTRL_TCON_PLL0_CNTL0, 0, 18, 1);
 		lcd_ana_setb(ANACTRL_TCON_PLL0_CNTL0, 3, 29, 2);
 
-		ret = lcd_pll_wait_lock(ANACTRL_TCON_PLL0_STS, 31);
+		ret = lcd_pll_wait_lock(cconf->pll_id, ANACTRL_TCON_PLL0_STS, 31);
 	} while (ret && ++cnt < PLL_RETRY_MAX);
 
 	if (ret)

drivers/media/vout/lcd/lcd_clk/lcd_clk_t7_t3_t5m.c

@@ -251,7 +251,7 @@ set_pll_retry_t7:
 	usleep_range(10, 11);
 	lcd_ana_write(ANACTRL_TCON_PLL0_CNTL2 + offset, 0x0000300c);
 
-	ret = lcd_pll_wait_lock(pll_stts, LCD_PLL_LOCK_T7);
+	ret = lcd_pll_wait_lock(cconf->pll_id, pll_stts, LCD_PLL_LOCK_T7);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_t7;
@@ -628,7 +628,7 @@ set_pll_retry_t3:
 	usleep_range(10, 11);
 	lcd_ana_write(ANACTRL_TCON_PLL0_CNTL2 + offset, 0x0000300c);
 
-	ret = lcd_pll_wait_lock(pll_stts, LCD_PLL_LOCK_T7);
+	ret = lcd_pll_wait_lock(cconf->pll_id, pll_stts, LCD_PLL_LOCK_T7);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_t3;

drivers/media/vout/lcd/lcd_clk/lcd_clk_tl1_tm2.c

@@ -238,7 +238,7 @@ set_pll_retry_tl1:
 	usleep_range(10, 15);
 	lcd_hiu_write(HHI_TCON_PLL_CNTL2, 0x0000300c);
 
-	ret = lcd_pll_wait_lock(HHI_TCON_PLL_CNTL0, LCD_PLL_LOCK_TL1);
+	ret = lcd_pll_wait_lock(cconf->pll_id, HHI_TCON_PLL_CNTL0, LCD_PLL_LOCK_TL1);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_tl1;

drivers/media/vout/lcd/lcd_clk/lcd_clk_txhd2.c

@@ -201,7 +201,7 @@ set_pll_retry_txhd2:
 	lcd_ana_setb(HHI_TCON_PLL_CNTL0, 1, 15, 1);
 	lcd_ana_write(HHI_TCON_PLL_CNTL6, 0x50440000);
 
-	ret = lcd_pll_wait_lock(HHI_TCON_PLL_STS, 31);
+	ret = lcd_pll_wait_lock(cconf->pll_id, HHI_TCON_PLL_STS, 31);
 	if (ret) {
 		if (cnt++ < PLL_RETRY_MAX)
 			goto set_pll_retry_txhd2;

drivers/media/vout/lcd/lcd_clk/lcd_clk_utils.c

@@ -130,7 +130,7 @@ int lcd_pll_ss_level_generate(struct lcd_clk_config_s *cconf)
 	return 0;
 }
 
-int lcd_pll_wait_lock(unsigned int reg, unsigned int lock_bit)
+int lcd_pll_wait_lock(int id, unsigned int reg, unsigned int lock_bit)
 {
 	unsigned int pll_lock;
 	int wait_loop = PLL_WAIT_LOCK_CNT; /* 200 */
@@ -143,8 +143,8 @@ int lcd_pll_wait_lock(unsigned int reg, unsigned int lock_bit)
 	} while ((pll_lock == 0) && (wait_loop > 0));
 	if (pll_lock == 0)
 		ret = -1;
-	LCDPR("%s: pll_lock=%d, wait_loop=%d\n",
-	      __func__, pll_lock, (PLL_WAIT_LOCK_CNT - wait_loop));
+	LCDPR("%s: [%d]: lock=%d, wait_loop=%d\n",
+	      __func__, id, pll_lock, (PLL_WAIT_LOCK_CNT - wait_loop));
 
 	return ret;
 }
@@ -162,7 +162,7 @@ int lcd_pll_wait_lock_hiu(unsigned int reg, unsigned int lock_bit)
 	} while ((pll_lock == 0) && (wait_loop > 0));
 	if (pll_lock == 0)
 		ret = -1;
-	LCDPR("%s: pll_lock=%d, wait_loop=%d\n",
+	LCDPR("%s: lock=%d, wait_loop=%d\n",
 	      __func__, pll_lock, (PLL_WAIT_LOCK_CNT - wait_loop));
 
 	return ret;
@@ -1796,7 +1796,10 @@ void lcd_clktree_bind(struct aml_lcd_drv_s *pdrv, unsigned char status)
 		}
 		cnt += snprintf(clk_names + cnt, 120 - cnt, " %s", clktree_list[clk_type].name);
 	}
-	LCDPR("[%d]: clktree %s:%s done\n", pdrv->index, status ? "probe" : "remove", clk_names);
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
+		LCDPR("[%d]: clktree %s:%s done\n",
+			pdrv->index, status ? "probe" : "remove", clk_names);
+	}
 }
 
 void lcd_clktree_gate_switch(struct aml_lcd_drv_s *pdrv, unsigned char status)
@@ -1832,5 +1835,8 @@ void lcd_clktree_gate_switch(struct aml_lcd_drv_s *pdrv, unsigned char status)
 
 		cnt += snprintf(clk_names + cnt, 120 - cnt, " %s", clktree_list[clk_type].name);
 	}
-	LCDPR("[%d]: %s %s:%s done\n", pdrv->index, __func__, status ? "on" : "off", clk_names);
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
+		LCDPR("[%d]: %s %s:%s done\n",
+			pdrv->index, __func__, status ? "on" : "off", clk_names);
+	}
 }

drivers/media/vout/lcd/lcd_clk/lcd_clk_utils.h

@@ -18,7 +18,7 @@
 #define PLL_CLK_CHECK_MAX    2000000 /* Hz */
 int lcd_clk_msr_check(struct aml_lcd_drv_s *pdrv);
 int lcd_pll_ss_level_generate(struct lcd_clk_config_s *cconf);
-int lcd_pll_wait_lock(unsigned int reg, unsigned int lock_bit);
+int lcd_pll_wait_lock(int id, unsigned int reg, unsigned int lock_bit);
 int lcd_pll_wait_lock_hiu(unsigned int reg, unsigned int lock_bit);
 
 /* ****************************************************

drivers/media/vout/lcd/lcd_common.c

@@ -368,7 +368,7 @@ static int lcd_cpu_gpio_register(struct aml_lcd_drv_s *pdrv, unsigned int index,
 
 	/* request gpio */
 	cpu_gpio->gpio = devm_gpiod_get_index(pdrv->dev, "lcd_cpu", index, value);
-	if (IS_ERR(cpu_gpio->gpio)) {
+	if (IS_ERR_OR_NULL(cpu_gpio->gpio)) {
 		LCDERR("[%d]: register gpio %s[%d]: %p, err: %d\n",
 		       pdrv->index, cpu_gpio->name, index, cpu_gpio->gpio,
 		       IS_ERR(cpu_gpio->gpio));
@@ -477,7 +477,7 @@ static void lcd_custom_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 	}
 
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, pinmux_str);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("set custom_pinmux %s error\n", pinmux_str);
 	} else {
 		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
@@ -527,7 +527,7 @@ void lcd_rgb_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 
 	/* request pinmux */
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_rgb_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set rgb pinmux %s error\n", pdrv->index, lcd_rgb_pinmux_str[index]);
 		return;
 	}
@@ -576,7 +576,7 @@ void lcd_bt_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 
 	/* request pinmux */
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_bt_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set bt pinmux %s error\n", pdrv->index, lcd_bt_pinmux_str[index]);
 		return;
 	}
@@ -613,7 +613,7 @@ void lcd_vbyone_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 	}
 
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_vbyone_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set vbyone pinmux %s error\n",
 		       pdrv->index, lcd_vbyone_pinmux_str[index]);
 	} else {
@@ -661,7 +661,7 @@ void lcd_mlvds_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 	}
 
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_tcon_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set mlvds pinmux %s error\n",
 		       pdrv->index, lcd_tcon_pinmux_str[index]);
 	} else {
@@ -704,7 +704,7 @@ void lcd_p2p_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 	}
 
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_tcon_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set p2p pinmux %s error\n",
 		       pdrv->index, lcd_tcon_pinmux_str[index]);
 	} else {
@@ -741,7 +741,7 @@ void lcd_edp_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 	}
 
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_edp_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set edp pinmux %s error\n",
 		       pdrv->index, lcd_edp_pinmux_str[index]);
 	} else {
@@ -781,7 +781,7 @@ void lcd_mipi_pinmux_set(struct aml_lcd_drv_s *pdrv, int status)
 	}
 
 	pconf->pin = devm_pinctrl_get_select(pdrv->dev, lcd_mipi_pinmux_str[index]);
-	if (IS_ERR(pconf->pin)) {
+	if (IS_ERR_OR_NULL(pconf->pin)) {
 		LCDERR("[%d]: set mipi pinmux %s error\n",
 		       pdrv->index, lcd_mipi_pinmux_str[index]);
 	} else {
@@ -944,17 +944,12 @@ static void lcd_config_load_print(struct aml_lcd_drv_s *pdrv)
 	if (!ptiming)
 		return;
 
-	LCDPR("[%d]: %s, %s, %dbit, %dx%d\n",
-	      pdrv->index,
-	      pconf->basic.model_name,
-	      lcd_type_type_to_str(pconf->basic.lcd_type),
-	      pconf->basic.lcd_bits,
-	      ptiming->h_active, ptiming->v_active);
-
 	if ((lcd_debug_print_flag & LCD_DBG_PR_NORMAL) == 0)
 		return;
 
-
+	LCDPR("[%d]: %s, %s\n",
+	      pdrv->index, pconf->basic.model_name,
+	      lcd_type_type_to_str(pconf->basic.lcd_type));
 	LCDPR("pll_flag = %d\n", pconf->timing.pll_flag);
 	LCDPR("clk_mode = %d\n", pconf->timing.clk_mode);
 	LCDPR("custom_pinmux = %d\n", pconf->custom_pinmux);
@@ -997,7 +992,7 @@ static void lcd_config_load_print(struct aml_lcd_drv_s *pdrv)
 		LCDPR("bit_swap = %d\n", pctrl->rgb_cfg.bit_swap);
 	} else if ((pconf->basic.lcd_type == LCD_BT656) ||
 		   (pconf->basic.lcd_type == LCD_BT1120)) {
-		LCDPR("clk_phase = %d\n", pctrl->bt_cfg.clk_phase);
+		LCDPR("clk_phase = 0x%x\n", pctrl->bt_cfg.clk_phase);
 		LCDPR("field_type = %d\n", pctrl->bt_cfg.field_type);
 		LCDPR("mode_422 = %d\n", pctrl->bt_cfg.mode_422);
 		LCDPR("yc_swap = %d\n", pctrl->bt_cfg.yc_swap);
@@ -1021,7 +1016,7 @@ static void lcd_config_load_print(struct aml_lcd_drv_s *pdrv)
 		LCDPR("channel_num = %d\n", pctrl->mlvds_cfg.channel_num);
 		LCDPR("channel_sel0 = 0x%x\n", pctrl->mlvds_cfg.channel_sel0);
 		LCDPR("channel_sel1 = 0x%x\n", pctrl->mlvds_cfg.channel_sel1);
-		LCDPR("clk_phase = %d\n", pctrl->mlvds_cfg.clk_phase);
+		LCDPR("clk_phase = 0x%x\n", pctrl->mlvds_cfg.clk_phase);
 		LCDPR("phy_vswing = 0x%x\n", pctrl->mlvds_cfg.phy_vswing);
 		LCDPR("phy_preem = 0x%x\n", pctrl->mlvds_cfg.phy_preem);
 	} else if (pconf->basic.lcd_type == LCD_P2P) {
@@ -1246,9 +1241,10 @@ lcd_config_timing_check_end:
 int lcd_base_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 {
 	const struct device_node *np;
-	const char *str = "none";
+	const char *mode_str, *str;
 	unsigned int val, para[8];
-	int ret = 0;
+	char str_info[128];
+	int str_info_len = 0, ret = 0;
 
 	if (!pdrv->dev->of_node) {
 		LCDERR("dev of_node is null\n");
@@ -1268,12 +1264,12 @@ int lcd_base_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 		pdrv->mode = LCD_MODE_TABLET;
 		break;
 	default:
-		ret = of_property_read_string(np, "mode", &str);
+		ret = of_property_read_string(np, "mode", &mode_str);
 		if (ret) {
 			LCDERR("[%d]: failed to get mode\n", pdrv->index);
 			return -1;
 		}
-		pdrv->mode = lcd_mode_str_to_mode(str);
+		pdrv->mode = lcd_mode_str_to_mode(mode_str);
 		break;
 	}
 
@@ -1316,8 +1312,6 @@ int lcd_base_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 		}
 		break;
 	}
-	LCDPR("[%d]: detect mode: %s, fr_auto_policy: %d, key_valid: %d\n",
-	      pdrv->index, str, pdrv->fr_auto_policy, pdrv->key_valid);
 
 	ret = of_property_read_u32(np, "clk_path", &val);
 	if (ret) {
@@ -1338,24 +1332,25 @@ int lcd_base_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 	}
 
 	ret = of_property_read_u32(np, "resume_type", &val);
-	if (ret) {
+	if (ret)
 		pdrv->resume_type = 1; /* default workqueue */
-	} else {
+	else
 		pdrv->resume_type = (unsigned char)val;
-		LCDPR("[%d]: detect resume_type: %d\n",
-		      pdrv->index, pdrv->resume_type);
-	}
 
 	ret = of_property_read_u32(np, "config_check_glb", &val);
-	if (ret) {
+	if (ret)
 		pdrv->config_check_glb = 0;
-	} else {
+	else
 		pdrv->config_check_glb = (unsigned char)val;
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
-			LCDPR("[%d]: detect config_check_glb: %d\n",
-				pdrv->index, pdrv->config_check_glb);
-		}
-	}
+
+	str_info_len += sprintf(str_info + str_info_len, "fr_auto: %d, ",
+			pdrv->fr_auto_policy);
+	str_info_len += sprintf(str_info + str_info_len, "resume_type: 0x%x, ",
+			pdrv->resume_type);
+	sprintf(str_info + str_info_len, "cfg_chk_glb: %d, ", pdrv->config_check_glb);
+	LCDPR("[%d]: drv_ver: %s(%d-%s), lcd_mode: %s, key_valid: %d, %s\n",
+	      pdrv->index, LCD_DRV_VERSION, pdrv->data->chip_type, pdrv->data->chip_name,
+	      mode_str, pdrv->key_valid, str_info);
 
 	ret = of_property_read_u32_array(np, "display_timing_req_min", &para[0], 5);
 	if (ret) {
@@ -1405,9 +1400,6 @@ int lcd_base_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 				pdrv->fr_lock->ki, pdrv->fr_lock->kd,
 				pdrv->fr_lock->line_limit, pdrv->fr_lock->freq_limit);
 		}
-	} else {
-		pdrv->fr_lock_en = 0;
-		LCDPR("no fr_lock\n");
 	}
 
 	return 0;
@@ -1812,7 +1804,8 @@ static int lcd_optical_load_from_unifykey(struct aml_lcd_drv_s *pdrv)
 	ret = lcd_unifykey_get_size(key_str, &key_len);
 	if (ret < 0)
 		return -1;
-	LCDPR("[%d]: %s: find ukey: %s\n", pdrv->index, __func__, key_str);
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+		LCDPR("[%d]: %s: find ukey: %s\n", pdrv->index, __func__, key_str);
 
 	para = kzalloc(key_len, GFP_KERNEL);
 	if (!para)
@@ -1911,7 +1904,8 @@ static int lcd_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 	struct phy_attr_s *phy = NULL;
 	unsigned int para[10], val;
 	const char *str;
-	int i, ret = 0;
+	char str_info[128];
+	int i, str_info_len = 0, ret = 0;
 
 	if (!pdrv->dev->of_node) {
 		LCDERR("[%d]: dev of_node is null\n", pdrv->index);
@@ -1940,15 +1934,10 @@ static int lcd_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 		str = "invalid";
 	}
 	pconf->basic.lcd_type = lcd_type_str_to_type(str);
-	LCDPR("load dts config: %s, lcd_type: %s(%d)\n",
-		pconf->basic.model_name, str, pconf->basic.lcd_type);
 
 	ret = of_property_read_u32(child, "config_check", &val);
-	if (ret == 0) {
+	if (ret == 0)
 		pconf->basic.config_check = val ? 0x3 : 0x2;
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			LCDPR("[%d]: find config_check: %d\n", pdrv->index, val);
-	}
 
 	ret = of_property_read_u32_array(child, "basic_setting", &para[0], 7);
 	if (ret) {
@@ -2065,45 +2054,49 @@ static int lcd_config_load_from_dts(struct aml_lcd_drv_s *pdrv)
 
 	ret = of_property_read_u32(child, "custom_pinmux", &val);
 	if (ret) {
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			LCDPR("[%d]: failed to get custom_pinmux\n", pdrv->index);
 		ret = of_property_read_u32(child, "customer_pinmux", &val);
-		if (ret) {
+		if (ret)
 			pconf->custom_pinmux = 0;
-			if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-				LCDPR("[%d]: failed to get customer_pinmux\n", pdrv->index);
-		} else {
+		else
 			pconf->custom_pinmux = val;
-			LCDPR("[%d]: find custom_pinmux: %d\n",
-				pdrv->index, pconf->custom_pinmux);
-		}
 	} else {
 		pconf->custom_pinmux = val;
-		LCDPR("[%d]: find custom_pinmux: %d\n",
-			pdrv->index, pconf->custom_pinmux);
 	}
 
 	ret = of_property_read_u32(child, "fr_auto_disable", &val);
 	if (ret) {
 		ret = of_property_read_u32(child, "fr_auto_custom", &val);
-		if (ret) {
+		if (ret)
 			pconf->fr_auto_cus = 0;
-			if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-				LCDPR("[%d]: failed to get fr_auto_custom\n", pdrv->index);
-		} else {
+		else
 			pconf->fr_auto_cus = val;
-			LCDPR("[%d]: find fr_auto_custom: 0x%x\n",
-				pdrv->index, pconf->fr_auto_cus);
-		}
 	} else {
 		if (val)
 			pconf->fr_auto_cus = 0xff;
 		else
 			pconf->fr_auto_cus = 0;
-		LCDPR("[%d]: find fr_auto_disable: %d, fr_auto_cus: 0x%x\n",
-			pdrv->index, val, pconf->fr_auto_cus);
 	}
 
+	str_info_len += sprintf(str_info + str_info_len, "ppc:%d, ",
+			pconf->timing.ppc);
+	str_info_len += sprintf(str_info + str_info_len, "clk_mode:%d, ",
+			pconf->timing.clk_mode);
+	if (pconf->timing.pre_de_h || pconf->timing.pre_de_v) {
+		str_info_len += sprintf(str_info + str_info_len, "pre_de:%d,%d, ",
+				pconf->timing.pre_de_h, pconf->timing.pre_de_v);
+	}
+	str_info_len += sprintf(str_info + str_info_len, "cfg_chk:0x%x, ",
+			pconf->basic.config_check);
+	str_info_len += sprintf(str_info + str_info_len, "cus_pinmux:%d, ",
+			pconf->custom_pinmux);
+	sprintf(str_info + str_info_len, "afr_cus:0x%x", pconf->fr_auto_cus);
+
+	LCDPR("[%d]: load dts config: %s, %s, %dbit, %dx%d, %s\n",
+	      pdrv->index, pconf->basic.model_name,
+	      lcd_type_type_to_str(pconf->basic.lcd_type),
+	      pconf->basic.lcd_bits, ptiming->h_active, ptiming->v_active,
+	      str_info);
+
 	switch (pconf->basic.lcd_type) {
 	case LCD_RGB:
 		ret = of_property_read_u32_array(child, "rgb_attr", &para[0], 6);
@@ -2599,7 +2592,8 @@ static int lcd_config_load_from_unifykey(struct aml_lcd_drv_s *pdrv, char *key_s
 	struct phy_attr_s *phy = NULL;
 	union lcd_ctrl_config_u *pctrl = &pdrv->config.control;
 	unsigned int temp;
-	int ret = 0;
+	char str_info[128];
+	int str_info_len = 0, ret;
 
 	ret = lcd_unifykey_get_size(key_str, &key_len);
 	if (ret)
@@ -2617,8 +2611,6 @@ static int lcd_config_load_from_unifykey(struct aml_lcd_drv_s *pdrv, char *key_s
 
 	/* step 1: check header size */
 	lcd_header = (struct aml_lcd_unifykey_header_s *)para;
-	LCDPR("[%d]: unifykey version: 0x%04x\n",
-	      pdrv->index, lcd_header->version);
 	len = LCD_UKEY_DATA_LEN_V1; /*10+36+18+31+20*/
 	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
 		lcd_unifykey_header_print(para);
@@ -2648,10 +2640,6 @@ static int lcd_config_load_from_unifykey(struct aml_lcd_drv_s *pdrv, char *key_s
 		((*(p + LCD_UKEY_SCREEN_WIDTH + 1)) << 8));
 	pconf->basic.screen_height = (*(p + LCD_UKEY_SCREEN_HEIGHT) |
 		((*(p + LCD_UKEY_SCREEN_HEIGHT + 1)) << 8));
-	LCDPR("load ukey config: %s, lcd_type: %s(%d)\n",
-		pconf->basic.model_name,
-		lcd_type_type_to_str(pconf->basic.lcd_type),
-		pconf->basic.lcd_type);
 
 	/* timing: 18byte */
 	ptiming = lcd_timing_alloc(pdrv);
@@ -2732,6 +2720,26 @@ static int lcd_config_load_from_unifykey(struct aml_lcd_drv_s *pdrv, char *key_s
 	lcd_config_timing_check(pdrv, ptiming);
 	lcd_default_to_basic_timing_init_config(pdrv);
 
+	str_info_len += sprintf(str_info + str_info_len, "ppc:%d, ",
+			pconf->timing.ppc);
+	str_info_len += sprintf(str_info + str_info_len, "clk_mode:%d, ",
+			pconf->timing.clk_mode);
+	if (pconf->timing.pre_de_h || pconf->timing.pre_de_v) {
+		str_info_len += sprintf(str_info + str_info_len, "pre_de:%d,%d, ",
+				pconf->timing.pre_de_h, pconf->timing.pre_de_v);
+	}
+	str_info_len += sprintf(str_info + str_info_len, "cfg_chk:0x%x, ",
+			pconf->basic.config_check);
+	str_info_len += sprintf(str_info + str_info_len, "cus_pinmux:%d, ",
+			pconf->custom_pinmux);
+	sprintf(str_info + str_info_len, "afr_cus:0x%x", pconf->fr_auto_cus);
+
+	LCDPR("[%d]: load ukey config: %s, %s, %dbit, %dx%d, %s\n",
+	      pdrv->index, pconf->basic.model_name,
+	      lcd_type_type_to_str(pconf->basic.lcd_type),
+	      pconf->basic.lcd_bits, ptiming->h_active, ptiming->v_active,
+	      str_info);
+
 	/* interface: 20byte */
 	switch (pconf->basic.lcd_type) {
 	case LCD_LVDS:
@@ -2941,15 +2949,11 @@ int lcd_get_config(struct aml_lcd_drv_s *pdrv)
 			load_id = 1;
 		}
 	}
-	if (load_id) {
-		LCDPR("[%d]: %s from unifykey\n", pdrv->index, __func__);
-		pdrv->config_load = 1;
+	pdrv->config_load = load_id;
+	if (load_id)
 		ret = lcd_config_load_from_unifykey(pdrv, key_str);
-	} else {
-		LCDPR("[%d]: %s from dts\n", pdrv->index, __func__);
-		pdrv->config_load = 0;
+	else
 		ret = lcd_config_load_from_dts(pdrv);
-	}
 	if (ret)
 		return -1;
 
@@ -3266,8 +3270,6 @@ void lcd_clk_frame_rate_init(struct lcd_detail_timing_s *ptiming)
 
 	if (ptiming->pixel_clk == 0) /* default 0 for 60hz */
 		ptiming->pixel_clk = 60;
-	else
-		LCDPR("init pclk: %dHz\n", ptiming->pixel_clk);
 
 	h_period = ptiming->h_period;
 	v_period = ptiming->v_period;

drivers/media/vout/lcd/lcd_extern/lcd_extern.c

@@ -450,23 +450,14 @@ static int lcd_extern_get_config_dts(struct device_node *np,
 		return -1;
 	}
 	econf->index = (unsigned char)val;
-	if (econf->index == LCD_EXTERN_INDEX_INVALID) {
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			EXTPR("[%d]: dev_index %d is invalid\n", edrv->index, econf->index);
-		return -1;
-	}
 
 	ret = of_property_read_string(child, "status", &str);
 	if (ret) {
 		EXTERR("[%d]: get index %d status failed\n", edrv->index, econf->index);
 		return -1;
 	}
-	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-		EXTPR("[%d]: index %d status = %s\n", edrv->index, econf->index, str);
 	if (strncmp(str, "okay", 2) == 0)
 		econf->status = 1;
-	else
-		return -1;
 
 	ret = of_property_read_string(child, "extern_name", &str);
 	if (ret) {
@@ -475,7 +466,6 @@ static int lcd_extern_get_config_dts(struct device_node *np,
 	} else {
 		strncpy(econf->name, str, (LCD_EXTERN_NAME_LEN_MAX - 1));
 	}
-	EXTPR("[%d]: load config: %s[%d]\n", edrv->index, econf->name, econf->index);
 
 	ret = of_property_read_u32(child, "type", &econf->type);
 	if (ret) {
@@ -484,6 +474,14 @@ static int lcd_extern_get_config_dts(struct device_node *np,
 		return -1;
 	}
 
+	if (econf->status == 0 || econf->index == LCD_EXTERN_INDEX_INVALID) {
+		EXTERR("[%d]: %s[%d] status %d is disabled, or index %d is invalid\n",
+		       edrv->index, econf->name, edev->dev_index, econf->status, econf->index);
+		return -1;
+	}
+	EXTPR("[%d]: config from dts: %s[%d], index: %d, type: %d\n",
+		edrv->index, econf->name, edev->dev_index, econf->index, econf->type);
+
 	switch (econf->type) {
 	case LCD_EXTERN_I2C:
 		ret = of_property_read_u32(child, "i2c_address", &val);
@@ -958,7 +956,6 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 					  struct lcd_extern_dev_s *edev)
 {
 	struct lcd_extern_config_s *econf;
-	struct aml_lcd_unifykey_header_s *ext_header;
 	unsigned char *para, *p;
 	int key_len, len;
 	const char *str;
@@ -977,25 +974,22 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 		return -1;
 
 	ret = lcd_unifykey_get(edrv->ukey_name, para, key_len);
-	if (ret)
-		goto lcd_ext_get_config_ukey_error;
+	if (ret) {
+		kfree(para);
+		return -1;
+	}
 
 	/* check lcd_extern unifykey length */
 	len = 10 + 33 + 10;
 	ret = lcd_unifykey_len_check(key_len, len);
 	if (ret) {
-		EXTERR("unifykey length is not correct\n");
-		goto lcd_ext_get_config_ukey_error;
+		EXTERR("[%d]: ukey %s length is incorrect\n", edrv->index, edrv->ukey_name);
+		kfree(para);
+		return -1;
 	}
 
-	/* header: 10byte */
-	ext_header = (struct aml_lcd_unifykey_header_s *)para;
-	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
-		EXTPR("unifykey header:\n");
-		EXTPR("crc32             = 0x%08x\n", ext_header->crc32);
-		EXTPR("data_len          = %d\n", ext_header->data_len);
-		EXTPR("version           = 0x%04x\n", ext_header->version);
-	}
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+		lcd_unifykey_header_print(para);
 
 	/* basic: 33byte */
 	p = para;
@@ -1004,13 +998,19 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 	econf->index = *(p + LCD_UKEY_EXT_INDEX);
 	econf->type = *(p + LCD_UKEY_EXT_TYPE);
 	econf->status = *(p + LCD_UKEY_EXT_STATUS);
-
-	if (econf->index == LCD_EXTERN_INDEX_INVALID) {
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			EXTPR("index %d is invalid\n", econf->index);
-		goto lcd_ext_get_config_ukey_error;
+	if (econf->status == 0 || econf->index == LCD_EXTERN_INDEX_INVALID) {
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
+			EXTERR("[%d]: %s[%d] status %d is disabled, or index %d is invalid\n",
+				edrv->index, econf->name, edev->dev_index,
+				econf->status, econf->index);
+		}
+		kfree(para);
+		return 1;
 	}
 
+	EXTPR("[%d]: config from ukey: %s[%d], index: %d, type: %d\n",
+		edrv->index, econf->name, edev->dev_index, econf->index, econf->type);
+
 	/* type: 10byte */
 	switch (econf->type) {
 	case LCD_EXTERN_I2C:
@@ -1032,8 +1032,6 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 			econf->i2c_addr4 = LCD_EXT_I2C_ADDR_INVALID;
 
 		econf->cmd_size = *(p + LCD_UKEY_EXT_TYPE_VAL_3);
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			EXTPR("%s: cmd_size = %d\n", econf->name, econf->cmd_size);
 
 		/* init */
 		if (econf->cmd_size == 0)
@@ -1063,8 +1061,6 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 			((*(p + LCD_UKEY_EXT_TYPE_VAL_4)) << 8));
 		econf->spi_clk_pol = *(p + LCD_UKEY_EXT_TYPE_VAL_5);
 		econf->cmd_size = *(p + LCD_UKEY_EXT_TYPE_VAL_6);
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			EXTPR("%s: cmd_size = %d\n", econf->name, econf->cmd_size);
 
 		/* init */
 		if (econf->cmd_size == 0)
@@ -1085,8 +1081,6 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 		break;
 	case LCD_EXTERN_MIPI:
 		econf->cmd_size = *(p + LCD_UKEY_EXT_TYPE_VAL_9);
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			EXTPR("%s: cmd_size = %d\n", econf->name, econf->cmd_size);
 		if (econf->cmd_size != LCD_EXT_CMD_SIZE_DYNAMIC)
 			break;
 		ret = lcd_extern_init_dynamic_ukey(edrv, econf, p, key_len, len, 1);
@@ -1098,8 +1092,6 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 		break;
 	case LCD_EXTERN_SIMPLE:
 		econf->cmd_size = *(p + LCD_UKEY_EXT_TYPE_VAL_9);
-		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-			EXTPR("%s: cmd_size = %d\n", econf->name, econf->cmd_size);
 
 		/* init */
 		if (econf->cmd_size == 0)
@@ -1119,13 +1111,13 @@ static int lcd_extern_get_config_unifykey(struct lcd_extern_driver_s *edrv,
 			econf->table_init_loaded = 1;
 		break;
 	default:
-		break;
+		goto lcd_ext_get_config_ukey_end;
 	}
 
-	kfree(para);
-	return 0;
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+		EXTPR("[%d]: %s: cmd_size = %d\n", edrv->index, econf->name, econf->cmd_size);
 
-lcd_ext_get_config_ukey_error:
+lcd_ext_get_config_ukey_end:
 	kfree(para);
 	return 0;
 }
@@ -1289,6 +1281,9 @@ static void lcd_extern_config_update_fixed_size(struct lcd_extern_driver_s *edrv
 static void lcd_extern_config_update(struct lcd_extern_driver_s *edrv,
 				     struct lcd_extern_dev_s *edev)
 {
+	if (edev->config.cmd_size == 0)
+		return;
+
 	if (edev->config.cmd_size == LCD_EXT_CMD_SIZE_DYNAMIC) {
 		lcd_extern_config_update_dynamic_size(edrv, edev, 1);
 		lcd_extern_config_update_dynamic_size(edrv, edev, 0);
@@ -1344,13 +1339,6 @@ static int lcd_extern_add_dev(struct lcd_extern_driver_s *edrv,
 	struct aml_lcd_drv_s *pdrv;
 	int ret = -1;
 
-	if (edev->config.status == 0) {
-		EXTERR("[%d]: %s: %s[%d] status is disabled\n",
-		       edrv->index, __func__,
-		       edev->config.name, edev->dev_index);
-		return -1;
-	}
-
 	if (strcmp(edev->config.name, "ext_default") == 0) {
 		if (edev->config.type == LCD_EXTERN_MIPI)
 			ret = lcd_extern_mipi_default_probe(edrv, edev);
@@ -1396,19 +1384,48 @@ static int lcd_extern_add_dev(struct lcd_extern_driver_s *edrv,
 	return 0;
 }
 
+static int lcd_extern_dev_probe_unifykey(struct lcd_extern_driver_s *edrv)
+{
+	int dev_index, ret;
+
+	dev_index = 0;
+	edrv->dev[edrv->dev_cnt] = lcd_extern_dev_malloc(dev_index);
+	ret = lcd_extern_get_config_unifykey(edrv, edrv->dev[edrv->dev_cnt]);
+	if (ret < 0)
+		goto lcd_ext_dev_probe_ukey_err;
+	if (ret > 0) {
+		lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
+		edrv->dev[edrv->dev_cnt] = NULL;
+		return -1;
+	}
+
+	lcd_extern_config_update(edrv, edrv->dev[edrv->dev_cnt]);
+	ret = lcd_extern_add_dev(edrv, edrv->dev[edrv->dev_cnt]);
+	if (ret)
+		goto lcd_ext_dev_probe_ukey_err;
+
+	edrv->dev_cnt++;
+	lcd_resource_ready(edrv->index, LCD_RES_EXTERN, dev_index);
+
+	return 0;
+
+lcd_ext_dev_probe_ukey_err:
+	EXTPR("[%d]: %s: failed\n", edrv->index, __func__);
+	lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
+	edrv->dev[edrv->dev_cnt] = NULL;
+	return -1;
+}
+
 static void lcd_extern_dev_probe_work(struct work_struct *p_work)
 {
 	struct delayed_work *d_work;
 	struct lcd_extern_driver_s *edrv;
 	bool is_init;
-	int index, dev_index;
 	int ret;
 
 	d_work = container_of(p_work, struct delayed_work, work);
 	edrv = container_of(d_work, struct lcd_extern_driver_s, dev_probe_dly_work);
 
-	index = edrv->index;
-
 	is_init = lcd_unifykey_init_get();
 	if (!is_init) {
 		if (edrv->retry_cnt++ < LCD_UNIFYKEY_WAIT_TIMEOUT) {
@@ -1416,40 +1433,15 @@ static void lcd_extern_dev_probe_work(struct work_struct *p_work)
 				LCD_UNIFYKEY_RETRY_INTERVAL);
 			return;
 		}
-		EXTERR("[%d]: %s: key_init_flag=%d, exit\n", edrv->index, __func__, is_init);
-		goto lcd_ext_dev_probe_work_err;
+		EXTERR("[%d]: %s: key_init_flag=%d, timeout\n",
+			edrv->index, __func__, is_init);
 	}
 
 	ret = lcd_unifykey_check(edrv->ukey_name);
 	if (ret)
-		goto lcd_ext_dev_probe_work_err;
+		return;
 
-	dev_index = 0;
-
-	edrv->dev[edrv->dev_cnt] = lcd_extern_dev_malloc(dev_index);
-	EXTPR("[%d]: %s: from unifykey\n", edrv->index, __func__);
-	ret = lcd_extern_get_config_unifykey(edrv, edrv->dev[edrv->dev_cnt]);
-	if (ret) {
-		lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
-		edrv->dev[edrv->dev_cnt] = NULL;
-		goto lcd_ext_dev_probe_work_err;
-	}
-
-	lcd_extern_config_update(edrv, edrv->dev[edrv->dev_cnt]);
-	ret = lcd_extern_add_dev(edrv, edrv->dev[edrv->dev_cnt]);
-	if (ret) {
-		lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
-		edrv->dev[edrv->dev_cnt] = NULL;
-		goto lcd_ext_dev_probe_work_err;
-	} else {
-		edrv->dev_cnt++;
-	}
-
-	lcd_resource_ready(edrv->index, LCD_RES_EXTERN, dev_index);
-	return;
-
-lcd_ext_dev_probe_work_err:
-	EXTPR("[%d]: %s: failed\n", index, __func__);
+	lcd_extern_dev_probe_unifykey(edrv);
 }
 
 static int lcd_extern_config_load(struct lcd_extern_driver_s *edrv)
@@ -1487,40 +1479,20 @@ static int lcd_extern_config_load(struct lcd_extern_driver_s *edrv)
 	} else {
 		edrv->key_valid = (unsigned char)para[0];
 	}
-	EXTPR("[%d]: key_valid: %d\n", edrv->index, edrv->key_valid);
+
 	if (edrv->index == 0)
 		sprintf(edrv->ukey_name, "lcd_extern");
 	else
 		sprintf(edrv->ukey_name, "lcd%d_extern", edrv->index);
 
-	if (edrv->key_valid && !lcd_unifykey_init_get()) {
+	if (edrv->key_valid) {
 		edrv->config_load = 1;
-		lcd_queue_delayed_work(&edrv->dev_probe_dly_work, 0);
-	} else if (edrv->key_valid && lcd_unifykey_init_get()) {
-		dev_index = 0;
-
-		edrv->dev[edrv->dev_cnt] = lcd_extern_dev_malloc(dev_index);
-		EXTPR("[%d]: %s: from panel ini\n", edrv->index, __func__);
-		ret = lcd_extern_get_config_unifykey(edrv, edrv->dev[edrv->dev_cnt]);
-		if (ret) {
-			lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
-			edrv->dev[edrv->dev_cnt] = NULL;
-			lcd_resource_ready(edrv->index, LCD_RES_EXTERN, dev_index);
-			return -1;
-		}
-		lcd_extern_config_update(edrv, edrv->dev[edrv->dev_cnt]);
-		ret = lcd_extern_add_dev(edrv, edrv->dev[edrv->dev_cnt]);
-		if (ret) {
-			lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
-			edrv->dev[edrv->dev_cnt] = NULL;
-		} else {
-			edrv->dev_cnt++;
-		}
-		lcd_resource_ready(edrv->index, LCD_RES_EXTERN, dev_index);
-		return ret;
+		if (lcd_unifykey_init_get())
+			lcd_extern_dev_probe_unifykey(edrv);
+		else
+			lcd_queue_delayed_work(&edrv->dev_probe_dly_work, 0);
 	} else {
 		edrv->config_load = 0;
-		EXTPR("[%d]: %s from dts\n", edrv->index, __func__);
 		for (i = 0; i < lcd_ext_dev_cnt[edrv->index]; i++) {
 			dev_index = lcd_ext_index_lut[edrv->index][i];
 			if (dev_index == LCD_EXTERN_INDEX_INVALID) {
@@ -1543,10 +1515,9 @@ static int lcd_extern_config_load(struct lcd_extern_driver_s *edrv)
 			if (ret) {
 				lcd_extern_dev_free(edrv->dev[edrv->dev_cnt]);
 				edrv->dev[edrv->dev_cnt] = NULL;
-			} else {
-				edrv->dev_cnt++;
+				return -1;
 			}
-
+			edrv->dev_cnt++;
 			lcd_resource_ready(edrv->index, LCD_RES_EXTERN, dev_index);
 		}
 	}

drivers/media/vout/lcd/lcd_resman/lcd_memory.c

@@ -37,7 +37,7 @@
 #include <linux/page-flags.h>
 #include <linux/mm.h>
 #include <linux/amlogic/tee.h>
-
+#include <linux/amlogic/media/vout/lcd/lcd_vout.h>
 #include <linux/amlogic/media/vout/lcd/lcd_resman.h>
 
 /*
@@ -120,7 +120,7 @@ void lrm_resource_device_prepare(char *name)
 	list_add_tail(&res->list, &lrm_resource_device_list);
 	spin_unlock(&lrm_res_dev_lock);
 
-	if (lcd_debug_print_flag)
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
 		LRMPR("lrm device %s add ok\n", name);
 }
 
@@ -136,7 +136,7 @@ void lrm_resource_device_finish(char *name)
 		if (strncmp(res->name, name, 32) == 0) {
 			list_del(&res->list);
 			kfree(res);
-			if (lcd_debug_print_flag)
+			if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
 				LRMPR("lrm device %s finish\n", name);
 		}
 	}
@@ -261,7 +261,7 @@ void *lrm_phys_to_virt(phys_addr_t paddr, u32 size)
 
 	if (lrm->no_map) {
 		vaddr = memremap(paddr, size, MEMREMAP_WC);
-		if (lcd_debug_print_flag)
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
 			LRMPR("%s memremap pa:0x%llx\n", __func__, (u64)paddr);
 	} else if (PageHighMem(phys_to_page(paddr))) {
 		nr_page = DIV_ROUND_UP(size, PAGE_SIZE);
@@ -270,7 +270,7 @@ void *lrm_phys_to_virt(phys_addr_t paddr, u32 size)
 			pages[i] = phys_to_page(paddr + i * PAGE_SIZE);
 
 		vaddr = vmap(pages, nr_page, VM_MAP, PAGE_KERNEL);
-		if (lcd_debug_print_flag)
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
 			LRMPR("%s vmap pa;0x%llx %d pages\n", __func__, (u64)paddr, nr_page);
 	} else {
 		vaddr = phys_to_virt(paddr);
@@ -763,7 +763,7 @@ int lrm_update_bootloader(struct lcd_rsvd_mem_s *lrm)
 		}
 		memcpy(&mem->info, p, sizeof(mem->info));
 		list_add_tail(&mem->list, &lrm->mem_list);
-		if (lcd_debug_print_flag)
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
 			LRMPR("lcd rsvd mem used by bootloader: pa:0x%llx, size:0x%x, name:%s",
 				 lrm->pstart + mem->info.offset, mem->info.size, mem->info.name);
 		lrm->allocated_num++;

drivers/media/vout/lcd/lcd_resman/lcd_panel.c

@@ -37,6 +37,7 @@
 #include <linux/page-flags.h>
 #include <linux/mm.h>
 #include <linux/amlogic/tee.h>
+#include <linux/amlogic/media/vout/lcd/lcd_vout.h>
 #include <linux/amlogic/media/vout/lcd/lcd_resman.h>
 #include <linux/amlogic/media/vout/lcd/lcd_math.h>
 
@@ -120,7 +121,7 @@ int lcd_panel_file_pre_proc(void)
 
 	LRMPR("%s panel_param_mem: size:0x%x, key_cnt:%d, ukey_exist:%d\n",
 		__func__, head->size, head->key_cnt, head->ukey_exist);
-	if (lcd_debug_print_flag) {
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
 		for (i = 0; i < head->key_cnt; i++) {
 			key = &panel_param_mem.keys[i];
 			LRMPR("[%d]: size;0x%x, mem_ofst:0x%x, name:%s\n",

drivers/media/vout/lcd/lcd_tablet/lcd_tablet.c

@@ -581,6 +581,8 @@ static int lcd_set_current_vmode(enum vmode_e mode, void *data)
 	if (!pdrv)
 		return -1;
 
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+		LCDPR("[%d]: %s: mode=0x%x\n", pdrv->index, __func__, mode);
 	if (lcd_vout_serve_bypass) {
 		LCDPR("[%d]: vout_serve bypass\n", pdrv->index);
 		return 0;

drivers/media/vout/lcd/lcd_tcon.c

@@ -2590,8 +2590,8 @@ static int lcd_tcon_mem_config(void)
 	if (lcd_tcon_conf->axi_tbl_len && lcd_tcon_conf->axi_mem_cfg_tbl) {
 		for (i = 0; i < lcd_tcon_conf->axi_tbl_len; i++) {
 			axi_cfg = &lcd_tcon_conf->axi_mem_cfg_tbl[i];
-			LCDPR("axi mem type=%d, size=%#x, reg=%#x, valid=%d\n",
-				axi_cfg->mem_type, axi_cfg->mem_size,
+			LCDPR("axi[%d] mem type=%d, size=%#x, reg=%#x, valid=%d\n",
+				i, axi_cfg->mem_type, axi_cfg->mem_size,
 				axi_cfg->axi_reg, axi_cfg->mem_valid);
 			switch (axi_cfg->mem_type) {
 			case TCON_AXI_MEM_TYPE_OD:

drivers/media/vout/lcd/lcd_tcon_hw.c

@@ -324,7 +324,9 @@ void lcd_tcon_core_reg_set(struct aml_lcd_drv_s *pdrv,
 				lcd_tcon_write(pdrv, i, table8[i]);
 		}
 	}
-	LCDPR("%s\n", __func__);
+
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+		LCDPR("%s finish\n", __func__);
 }
 
 static void lcd_tcon_data_init_set(struct aml_lcd_drv_s *pdrv, unsigned char *data_buf)

drivers/media/vout/lcd/lcd_tcon_rdma.c

@@ -354,7 +354,8 @@ int lcd_tcon_rdma_init(struct aml_lcd_drv_s *pdrv)
 	}
 
 	if (!rdma_chip) {
-		LCDERR("not support tcon rdma\n");
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+			LCDPR("not support tcon rdma\n");
 		goto __tcon_rdma_init_exit;
 	}
 

drivers/media/vout/lcd/lcd_tv/lcd_tv.c

@@ -596,6 +596,8 @@ static int lcd_set_current_vmode(enum vmode_e mode, void *data)
 	if (!pdrv)
 		return -1;
 
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+		LCDPR("[%d]: %s: mode=0x%x\n", pdrv->index, __func__, mode);
 	if (lcd_vout_serve_bypass) {
 		LCDPR("[%d]: vout_serve bypass\n", pdrv->index);
 		return 0;

drivers/media/vout/lcd/lcd_unifykey.c

@@ -27,7 +27,8 @@
 bool lcd_unifykey_init_get(void)
 {
 	if (is_ukey_in_param_mem()) {
-		LCDUKEY("ukey in panel param mem, init ok\n");
+		if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
+			LCDUKEY("ukey in panel param mem, init ok\n");
 		return true;
 	}
 
@@ -406,6 +407,7 @@ void lcd_unifykey_header_print(unsigned char *buf)
 		return;
 	header = (struct aml_lcd_unifykey_header_s *)buf;
 	LCDUKEY("unifykey v%d header:\n", header->version);
+	LCDUKEY("version           = 0x%04x\n", header->version);
 	LCDUKEY("crc32             = 0x%08x\n", header->crc32);
 	LCDUKEY("data_len          = %d\n", header->data_len);
 	LCDUKEY("block_next_flag   = %d\n", header->block_next_flag);

drivers/media/vout/lcd/lcd_vout.c

@@ -663,8 +663,6 @@ static int lcd_driver_active(struct aml_lcd_drv_s *pdrv)
 		return -1;
 	lcd_set_venc(pdrv);
 
-	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-		LCDPR("[%d]: %s finished\n", pdrv->index, __func__);
 	return 0;
 }
 
@@ -674,8 +672,6 @@ static int lcd_driver_dummy(struct aml_lcd_drv_s *pdrv)
 		return -1;
 	lcd_venc_set_dummy(pdrv);
 
-	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL)
-		LCDPR("[%d]: %s finished\n", pdrv->index, __func__);
 	return 0;
 }
 
@@ -2229,7 +2225,10 @@ static void lcd_config_probe_work(struct work_struct *p_work)
 		LCDERR("[%d]: %s: key_init_flag=%d, exit\n", pdrv->index, __func__, is_init);
 		goto lcd_config_probe_work_failed;
 	}
-	LCDPR("[%d]: key_init_flag=%d, retry_cnt=%d\n", pdrv->index, is_init, pdrv->retry_cnt);
+	if (lcd_debug_print_flag & LCD_DBG_PR_NORMAL) {
+		LCDPR("[%d]: key_init_flag=%d, retry_cnt=%d\n",
+			pdrv->index, is_init, pdrv->retry_cnt);
+	}
 
 	ret = lcd_mode_probe(pdrv);
 	sprintf(lrm_dev_name, "lcd%d", pdrv->index);
@@ -2279,7 +2278,7 @@ static void lcd_config_default(struct aml_lcd_drv_s *pdrv)
 	} else {
 		pdrv->status = 0;
 	}
-	LCDPR("[%d]: ppc: %d, clk_mode: %d, base_fr: %d, status: 0x%x, init_flag: %d\n",
+	LCDPR("[%d]: init: ppc: %d, clk_mode: %d, base_fr: %d, status: 0x%x, init_flag: %d\n",
 		pdrv->index, pdrv->config.timing.ppc,
 		pdrv->config.timing.clk_mode,
 		pdrv->config.timing.act_timing.frame_rate,
@@ -2730,8 +2729,6 @@ static int lcd_probe(struct platform_device *pdev)
 
 	lcd_global_init_once(pdata);
 
-	LCDPR("[%d]: driver version: %s(%d-%s)\n",
-	      index, LCD_DRV_VERSION, pdata->chip_type, pdata->chip_name);
 	if (index >= pdata->drv_max) {
 		LCDERR("[%d]: %s: invalid index\n", index, __func__);
 		return -1;

include/linux/amlogic/media/vout/lcd/lcd_resman.h

@@ -6,7 +6,6 @@
 #ifndef _AML_LCD_RESMAN_H
 #define _AML_LCD_RESMAN_H
 
-extern unsigned int lcd_debug_print_flag;
 #define LRMPR(fmt, args...)     pr_info("lcd: " fmt "", ## args)
 #define LRMERR(fmt, args...)    pr_err("lcd: error: " fmt "", ## args)