Merge commit '1f0e792e849fe388eb1964d7a6f67dd5697ec6df'

* commit '1f0e792e849fe388eb1964d7a6f67dd5697ec6df': media: rockchip: hdmirx: fix put_user fail on kernel-6.1. ARM: dts: rockchip: rk3506-evb1-v10: Change ubi.mtd id to 5 arm64: dts: rockchip: Support rk3562-toybrick drm/bridge: synopsys: dw-hdmi-qp: Clear ddc write/read bits when ddc transfer failed media: i2c: rk628: rk628_clk_set_rate need after version check access arm64: dts: rockchip: rk3576: Remove prefetchable support from pcie0 drm/rockchip: vop: make vop version code more readable drm/rockchip: vop: add support to assign mcu bypass timing in dts drm/rockchip: vop: add support to read regs from mcu panel drm/rockchip: vop: separate default mcu bypass config by platforms video: rockchip: rga3: modify 'time' debug log video: rockchip: rga3: modify 'msg' debug log video: rockchip: rga3: log adds job/request/mm info video: rockchip: rga3: log adds process info(tgid/pid) video: rockchip: rga3: "load" node supports querying session active status video: rockchip: rga3: fix the wrong reserved memory size in rga_req arm64: dts: rockchip: rk3399-sapphire-excavator-edp: fix wake up after sleep can't display when low brightness Change-Id: Iff362fb79c5c80b49d34ccab911f907b93b3c46c
2026-06-08 03:40:35 +09:00 · 2024-08-30 20:09:02 +08:00
parent 332fcd32a6 1f0e792e84
commit a3fd01cfc8
30 changed files with 1504 additions and 773 deletions
--- a/arch/arm/boot/dts/rk3506-evb1-v10.dtsi
+++ b/arch/arm/boot/dts/rk3506-evb1-v10.dtsi
@@ -12,7 +12,7 @@
 	compatible = "rockchip,rk3506-evb1-v10", "rockchip,rk3506";

 	chosen {
-		bootargs = "earlycon=uart8250,mmio32,0xff0a0000 console=ttyFIQ0 ubi.mtd=4 ubi.block=0,rootfs root=/dev/ubiblock0_0 rootfstype=squashfs rootwait snd_aloop.index=7 snd_aloop.use_raw_jiffies=1";
+		bootargs = "earlycon=uart8250,mmio32,0xff0a0000 console=ttyFIQ0 ubi.mtd=5 ubi.block=0,rootfs root=/dev/ubiblock0_0 rootfstype=squashfs rootwait snd_aloop.index=7 snd_aloop.use_raw_jiffies=1";
 	};

 	acodec_sound: acodec-sound {
--- a/arch/arm64/boot/dts/rockchip/Makefile
+++ b/arch/arm64/boot/dts/rockchip/Makefile
@@ -132,6 +132,8 @@ dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562-iotest-lp3-v10-dsm.dtb
 dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562-rk817-tablet-v10.dtb
 dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562-test1-ddr3-v10.dtb
 dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562-test2-ddr4-v10.dtb
+dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562-toybrick-android.dtb
+dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562-toybrick-linux.dtb
 dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3562j-core-ddr4-v10.dtb
 dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3566-box-demo-v10.dtb
 dtb-$(CONFIG_ARCH_ROCKCHIP) += rk3566-evb-mipitest-v10.dtb
--- a/arch/arm64/boot/dts/rockchip/rk3399-sapphire-excavator-edp.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3399-sapphire-excavator-edp.dtsi
@@ -14,7 +14,7 @@
 	backlight: backlight {
 		compatible = "pwm-backlight";
 		brightness-levels = <
-			  0   1   2   3   4   5   6   7
+			  2   2   2   3   4   5   6   7
 			  8   9  10  11  12  13  14  15
 			 16  17  18  19  20  21  22  23
 			 24  25  26  27  28  29  30  31
@@ -474,4 +474,3 @@
 		};
 	};
 };
-
--- a/arch/arm64/boot/dts/rockchip/rk3562-toybrick-android.dts
+++ b/arch/arm64/boot/dts/rockchip/rk3562-toybrick-android.dts
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
+/*
+ * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
+ *
+ */
+
+#include "rk3562-toybrick.dtsi"
+#include "rk3562-android.dtsi"
+#include "rk3562-rk809.dtsi"
--- a/arch/arm64/boot/dts/rockchip/rk3562-toybrick-linux.dts
+++ b/arch/arm64/boot/dts/rockchip/rk3562-toybrick-linux.dts
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
+/*
+ * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
+ *
+ */
+
+#include "rk3562-toybrick.dtsi"
+#include "rk3562-linux.dtsi"
+#include "rk3562-rk809.dtsi"
--- a/arch/arm64/boot/dts/rockchip/rk3562-toybrick.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3562-toybrick.dtsi
@@ -0,0 +1,506 @@
+// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
+/*
+ * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
+ *
+ */
+
+/dts-v1/;
+
+#include "rk3562.dtsi"
+#include "rk3562-evb.dtsi"
+#include <dt-bindings/gpio/gpio.h>
+#include <dt-bindings/pinctrl/rockchip.h>
+#include <dt-bindings/sensor-dev.h>
+
+/ {
+	model = "Rockchip RK3562 Toybrick Board";
+	compatible = "rockchip,rk3562-toybrick", "rockchip,rk3562";
+
+	adc_keys: adc-keys {
+		status = "okay";
+		compatible = "adc-keys";
+		io-channels = <&saradc0 1>;
+		io-channel-names = "buttons";
+		keyup-threshold-microvolt = <1800000>;
+		poll-interval = <100>;
+
+		vol-up-key {
+			label = "volume up";
+			linux,code = <KEY_VOLUMEUP>;
+			press-threshold-microvolt = <17000>;
+		};
+	};
+
+	dc_12v: dc-12v {
+		compatible = "regulator-fixed";
+		regulator-name = "dc_12v";
+		regulator-always-on;
+		regulator-boot-on;
+		regulator-min-microvolt = <12000000>;
+		regulator-max-microvolt = <12000000>;
+	};
+
+	leds: leds {
+		compatible = "gpio-leds";
+		status = "okay";
+		led@1 {
+			gpios = <&gpio4 RK_PB4 GPIO_ACTIVE_HIGH>;
+			label = "work_led";
+			default-state = "on";
+			linux,default-trigger = "default-on";
+			pinctrl-names = "default";
+			pinctrl-0 = <&work_led>;
+		};
+	};
+
+	rk809_sound: rk809-sound {
+		status = "okay";
+		compatible = "rockchip,multicodecs-card";
+		rockchip,card-name = "rockchip-rk809";
+		hp-det-gpio = <&gpio1 RK_PD0 GPIO_ACTIVE_LOW>;
+		rockchip,format = "i2s";
+		rockchip,mclk-fs = <256>;
+		rockchip,cpu = <&sai0>;
+		rockchip,codec = <&rk809_codec>;
+		pinctrl-names = "default";
+		pinctrl-0 = <&hp_det>;
+	};
+
+	sdio_pwrseq: sdio-pwrseq {
+		compatible = "mmc-pwrseq-simple";
+		clocks = <&rk809 1>;
+		clock-names = "ext_clock";
+		pinctrl-names = "default";
+		pinctrl-0 = <&wifi_enable_h>;
+
+		/*
+		 * On the module itself this is one of these (depending
+		 * on the actual card populated):
+		 * - SDIO_RESET_L_WL_REG_ON
+		 * - PDN (power down when low)
+		 */
+		post-power-on-delay-ms = <200>;
+		reset-gpios = <&gpio0 RK_PB3 GPIO_ACTIVE_LOW>;
+	};
+
+	vcc3v3_pcie20: vcc3v3-pcie20 {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc3v3_pcie20";
+		regulator-min-microvolt = <3300000>;
+		regulator-max-microvolt = <3300000>;
+		enable-active-high;
+		gpios = <&gpio3 RK_PC6 GPIO_ACTIVE_HIGH>;
+		startup-delay-us = <5000>;
+		vin-supply = <&dc_12v>;
+	};
+
+	vcc5v0_sys: vcc5v0-sys {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc5v0_sys";
+		regulator-always-on;
+		regulator-boot-on;
+		regulator-min-microvolt = <5000000>;
+		regulator-max-microvolt = <5000000>;
+		vin-supply = <&dc_12v>;
+	};
+
+	vcc5v0_usb: vcc5v0-usb {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc5v0_usb";
+		regulator-always-on;
+		regulator-boot-on;
+		regulator-min-microvolt = <5000000>;
+		regulator-max-microvolt = <5000000>;
+		vin-supply = <&dc_12v>;
+	};
+
+	vcc5v0_usb_host: vcc5v0-usb-host {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc5v0_usb_host";
+		regulator-boot-on;
+		regulator-always-on;
+		regulator-min-microvolt = <5000000>;
+		regulator-max-microvolt = <5000000>;
+		enable-active-high;
+		gpio = <&gpio0 RK_PC4 GPIO_ACTIVE_HIGH>;
+		vin-supply = <&vcc5v0_usb>;
+		pinctrl-names = "default";
+		pinctrl-0 = <&usb_host_pwren>;
+	};
+
+	vcc5v0_usb_otg: vcc5v0-usb-otg {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc5v0_usb_otg";
+		regulator-min-microvolt = <5000000>;
+		regulator-max-microvolt = <5000000>;
+		enable-active-high;
+		gpio = <&gpio0 RK_PC0 GPIO_ACTIVE_HIGH>;
+		vin-supply = <&vcc5v0_usb>;
+		pinctrl-names = "default";
+		pinctrl-0 = <&usb_otg_pwren>;
+	};
+
+	vcc3v3_clk: vcc3v3-clk {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc3v3_clk";
+		regulator-min-microvolt = <3300000>;
+		regulator-max-microvolt = <3300000>;
+		vin-supply = <&vcc5v0_sys>;
+	};
+
+	vcc3v3_sys: vcc-sys {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc3v3_sys";
+		regulator-always-on;
+		regulator-boot-on;
+		regulator-min-microvolt = <3300000>;
+		regulator-max-microvolt = <3300000>;
+		vin-supply = <&dc_12v>;
+	};
+
+	vcc25_ddr: vcc25-ddr {
+		compatible = "regulator-fixed";
+		regulator-name = "vcc25_ddr";
+		regulator-always-on;
+		regulator-boot-on;
+		regulator-min-microvolt = <2500000>;
+		regulator-max-microvolt = <2500000>;
+		vin-supply = <&vcc3v3_sys>;
+	};
+
+	vdd_npu: vdd-npu {
+		compatible = "pwm-regulator";
+		pwms = <&pwm6 0 5000 1>;
+		regulator-name = "vdd_npu";
+		regulator-min-microvolt = <800000>;
+		regulator-max-microvolt = <1100000>;
+		regulator-init-microvolt = <900000>;
+		regulator-always-on;
+		regulator-boot-on;
+		regulator-settling-time-up-us = <250>;
+		pwm-supply = <&vcc5v0_sys>;
+		status = "okay";
+	};
+
+	vcc_4g: vcc-4g-regulator {
+			compatible = "regulator-fixed";
+			enable-active-high;
+			gpio = <&gpio0 RK_PA0 GPIO_ACTIVE_HIGH>;
+			pinctrl-names = "default";
+			pinctrl-0 = <&vcc_4g_drv>;
+			regulator-name = "vcc_4g";
+			regulator-always-on;
+			regulator-boot-on;
+	};
+
+	wireless-wlan {
+		compatible = "wlan-platdata";
+		rockchip,grf = <&sys_grf>;
+		wifi_chip_type = "ap6275s";
+		pinctrl-names = "default";
+		pinctrl-0 = <&wifi_host_wake_irq>;
+		WIFI,host_wake_irq = <&gpio0 RK_PB4 GPIO_ACTIVE_HIGH>;
+		WIFI,poweren_gpio = <&gpio0 RK_PB3 GPIO_ACTIVE_HIGH>;
+		status = "okay";
+	};
+
+	wireless-bluetooth {
+		compatible = "bluetooth-platdata";
+		clocks = <&rk809 1>;
+		clock-names = "ext_clock";
+		//wifi-bt-power-toggle;
+		uart_rts_gpios = <&gpio1 RK_PD3 GPIO_ACTIVE_LOW>;
+		pinctrl-names = "default", "rts_gpio";
+		pinctrl-0 = <&uart1m0_rtsn>;
+		pinctrl-1 = <&uart1_gpios>;
+		BT,reset_gpio    = <&gpio0 RK_PC5 GPIO_ACTIVE_HIGH>;
+		BT,wake_gpio     = <&gpio0 RK_PC7 GPIO_ACTIVE_HIGH>;
+		BT,wake_host_irq = <&gpio0 RK_PC6 GPIO_ACTIVE_HIGH>;
+		status = "okay";
+	};
+};
+
+&combphy_pu {
+	status = "okay";
+};
+
+&dsi {
+	status = "okay";
+};
+
+&dsi_in_vp0 {
+	status = "okay";
+};
+
+&dsi_panel {
+	power-supply = <&vcc3v3_lcd_n>;
+	reset-gpios = <&gpio0 RK_PA7 GPIO_ACTIVE_LOW>;
+	pinctrl-names = "default";
+	pinctrl-0 = <&lcd_rst_gpio>;
+};
+
+&gmac0 {
+	/* Use rgmii-rxid mode to disable rx delay inside Soc */
+	phy-mode = "rgmii-rxid";
+	clock_in_out = "output";
+
+	snps,reset-gpio = <&gpio4 RK_PB0 GPIO_ACTIVE_LOW>;
+	snps,reset-active-low;
+	/* Reset time is 20ms, 100ms for rtl8211f */
+	snps,reset-delays-us = <0 20000 100000>;
+
+	tx_delay = <0x42>;
+	/* rx_delay = <0x3f>; */
+
+	pinctrl-names = "default";
+	pinctrl-0 = <&rgmiim0_miim
+		     &rgmiim0_tx_bus2
+		     &rgmiim0_rx_bus2
+		     &rgmiim0_rgmii_clk
+		     &rgmiim0_rgmii_bus
+		     &ethm0_pins>;
+
+	phy-handle = <&rgmii_phy>;
+	status = "okay";
+};
+
+&i2c2 {
+	status = "okay";
+
+	gt1x: gt1x@14 {
+		compatible = "goodix,gt1x";
+		reg = <0x14>;
+		pinctrl-names = "default";
+		pinctrl-0 = <&touch_gpio>;
+		goodix,rst-gpio = <&gpio0 RK_PB7 GPIO_ACTIVE_HIGH>;
+		goodix,irq-gpio = <&gpio0 RK_PC3 GPIO_ACTIVE_LOW>;
+		/*
+		 * power-supply should switche to vcc3v3_lcd1_n
+		 * when mipi panel is connected to dsi1.
+		 */
+		power-supply = <&vcc3v3_lcd_n>;
+	};
+
+	hym8563: hym8563@51 {
+		compatible = "haoyu,hym8563";
+		reg = <0x51>;
+		#clock-cells = <0>;
+		clock-frequency = <32768>;
+		clock-output-names = "hym8563";
+		pinctrl-names = "default";
+		pinctrl-0 = <&hym8563_int>;
+		interrupt-parent = <&gpio0>;
+		interrupts = <RK_PA5 IRQ_TYPE_LEVEL_LOW>;
+		wakeup-source;
+	};
+};
+
+&mdio0 {
+	rgmii_phy: phy@1 {
+		compatible = "ethernet-phy-ieee802.3-c22";
+		reg = <0x1>;
+		clocks = <&cru CLK_GMAC_ETH_OUT2IO>;
+		assigned-clocks = <&cru CLK_GMAC_ETH_OUT2IO>;
+		assigned-clock-rates = <25000000>;
+	};
+};
+
+&pcie2x1 {
+	reset-gpios = <&gpio3 RK_PB0 GPIO_ACTIVE_HIGH>;
+	vpcie3v3-supply = <&vcc3v3_pcie20>;
+	status = "okay";
+};
+
+&pinctrl {
+	headphone {
+		hp_det: hp-det {
+			rockchip,pins = <1 RK_PD0 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+	};
+
+	lcd {
+		lcd_rst_gpio: lcd-rst-gpio {
+			rockchip,pins = <0 RK_PA7 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+	};
+
+	led {
+		work_led: work-led {
+			rockchip,pins = <4 RK_PB4 RK_FUNC_GPIO &pcfg_pull_up>;
+		};
+	};
+
+	rtc {
+		hym8563_int: hym8563-int {
+			rockchip,pins = <0 RK_PA5 RK_FUNC_GPIO &pcfg_pull_up>;
+		};
+	};
+
+	touch {
+		touch_gpio: touch-gpio {
+			rockchip,pins =
+				<0 RK_PB7 RK_FUNC_GPIO &pcfg_pull_up>,
+				<0 RK_PC3 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+	};
+
+	sdio-pwrseq {
+		wifi_enable_h: wifi-enable-h {
+			rockchip,pins = <0 RK_PB3 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+	};
+
+	usb {
+		usb_host_pwren: usb-host-pwren {
+			rockchip,pins = <0 RK_PC4 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+
+		usb_otg_pwren: usb-otg-pwren {
+			rockchip,pins = <0 RK_PC0 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+	};
+
+	4g {
+		vcc_4g_drv: vcc-4g-drv {
+			rockchip,pins =
+				<0 RK_PA0 RK_FUNC_GPIO &pcfg_pull_up>, // 4G_PWR_EN
+				<1 RK_PD7 RK_FUNC_GPIO &pcfg_output_low>, // 4G_ENABLE
+				<1 RK_PD6 RK_FUNC_GPIO &pcfg_output_high>; // 4G_RESET
+		};
+	};
+
+	wireless-wlan {
+		wifi_host_wake_irq: wifi-host-wake-irq {
+			rockchip,pins = <0 RK_PB4 RK_FUNC_GPIO &pcfg_pull_down>;
+		};
+	};
+
+	wireless-bluetooth {
+		uart1_gpios: uart1-gpios {
+			rockchip,pins = <1 RK_PD3 RK_FUNC_GPIO &pcfg_pull_none>;
+		};
+	};
+};
+
+&pwm6 {
+	status = "okay";
+};
+
+&route_dsi {
+	status = "okay";
+};
+
+&sai0 {
+	status = "okay";
+	pinctrl-names = "default";
+	pinctrl-0 = <&i2s0m0_lrck
+		     &i2s0m0_sclk
+		     &i2s0m0_sdi0
+		     &i2s0m0_sdo0>;
+};
+
+&sdmmc0 {
+	no-sdio;
+	no-mmc;
+	bus-width = <4>;
+	cap-mmc-highspeed;
+	cap-sd-highspeed;
+	disable-wp;
+	sd-uhs-sdr104;
+	vmmc-supply = <&vcc3v3_sd>;
+	vqmmc-supply = <&vccio_sd>;
+	pinctrl-names = "default";
+	pinctrl-0 = <&sdmmc0_bus4 &sdmmc0_clk &sdmmc0_cmd &sdmmc0_det>;
+	status = "okay";
+};
+
+&sdmmc1 {
+	no-sd;
+	no-mmc;
+	bus-width = <4>;
+	disable-wp;
+	cap-sd-highspeed;
+	cap-sdio-irq;
+	keep-power-in-suspend;
+	mmc-pwrseq = <&sdio_pwrseq>;
+	non-removable;
+	pinctrl-names = "default";
+	pinctrl-0 = <&sdmmc1_bus4 &sdmmc1_cmd &sdmmc1_clk>;
+	sd-uhs-sdr104;
+	status = "okay";
+};
+
+&spdif_8ch {
+	pinctrl-0 = <&spdifm0_pins>;
+	status = "okay";
+};
+
+&u2phy {
+	status = "okay";
+};
+
+&u2phy_host {
+	status = "okay";
+	phy-supply = <&vcc5v0_usb_host>;
+};
+
+&u2phy_otg {
+	status = "okay";
+	vbus-supply = <&vcc5v0_usb_otg>;
+};
+
+&uart1 {
+	status = "okay";
+	pinctrl-names = "default";
+	pinctrl-0 = <&uart1m0_xfer &uart1m0_ctsn>;
+};
+
+&uart4 {
+	status = "okay";
+	pinctrl-names = "default";
+	pinctrl-0 = <&uart4m0_xfer>;
+};
+
+&uart7 {
+	status = "okay";
+	pinctrl-names = "default";
+	pinctrl-0 = <&uart7m0_xfer>;
+};
+
+&spi2 {
+	status = "okay";
+	pinctrl-names = "default";
+	pinctrl-0 = <&spi2m0_csn0 &spi2m0_pins>;
+};
+
+&usb_host0_ehci {
+	status = "okay";
+};
+
+&usb_host0_ohci {
+	status = "okay";
+};
+
+&usbdrd30 {
+	status = "okay";
+};
+
+&usbdrd_dwc3 {
+	status = "okay";
+	dr_mode = "otg";
+	extcon = <&u2phy>;
+	maximum-speed = "high-speed";
+	phys = <&u2phy_otg>;
+	phy-names = "usb2-phy";
+	snps,dis_u2_susphy_quirk;
+	snps,usb2-lpm-disable;
+};
+
+&vcc3v3_lcd_n {
+	gpio = <&gpio0 RK_PB0 GPIO_ACTIVE_HIGH>;
+	enable-active-high;
+};
+
+&video_phy {
+	status = "okay";
+};
--- a/arch/arm64/boot/dts/rockchip/rk3576.dtsi
+++ b/arch/arm64/boot/dts/rockchip/rk3576.dtsi
@@ -3760,7 +3760,7 @@
 		ranges = <0x00000800 0x0 0x20000000 0x0 0x20000000 0x0 0x00100000
 			  0x81000000 0x0 0x20100000 0x0 0x20100000 0x0 0x00100000
 			  0x82000000 0x0 0x20200000 0x0 0x20200000 0x0 0x00e00000
-			  0xc3000000 0x9 0x00000000 0x9 0x00000000 0x0 0x80000000>;
+			  0x83000000 0x9 0x00000000 0x9 0x00000000 0x0 0x80000000>;
 		reg = <0x0 0x2a200000 0x0 0x00010000>,
 		      <0x0 0x22000000 0x0 0x00400000>,
 		      <0x0 0x20000000 0x0 0x00100000>;
--- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-qp.c
+++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi-qp.c
@@ -1082,6 +1082,7 @@ static int dw_hdmi_i2c_read(struct dw_hdmi_qp *hdmi,
 			if (!stat) {
 				dev_err(hdmi->dev, "i2c read time out!\n");
 				hdmi_writel(hdmi, 0x01, I2CM_CONTROL0);
+				hdmi_modb(hdmi, 0, I2CM_WR_MASK, I2CM_INTERFACE_CONTROL0);
 				retry -= 10;
 				continue;
 			}
@@ -1090,6 +1091,7 @@ static int dw_hdmi_i2c_read(struct dw_hdmi_qp *hdmi,
 			if (i2c->stat & I2CM_NACK_RCVD_IRQ) {
 				dev_err(hdmi->dev, "i2c read err!\n");
 				hdmi_writel(hdmi, 0x01, I2CM_CONTROL0);
+				hdmi_modb(hdmi, 0, I2CM_WR_MASK, I2CM_INTERFACE_CONTROL0);
 				retry--;
 				usleep_range(10000, 11000);
 				continue;
@@ -1164,6 +1166,7 @@ static int dw_hdmi_i2c_write(struct dw_hdmi_qp *hdmi,
 			if (!stat) {
 				dev_err(hdmi->dev, "i2c write time out!\n");
 				hdmi_writel(hdmi, 0x01, I2CM_CONTROL0);
+				hdmi_modb(hdmi, 0, I2CM_WR_MASK, I2CM_INTERFACE_CONTROL0);
 				retry -= 10;
 				continue;
 			}
@@ -1172,6 +1175,7 @@ static int dw_hdmi_i2c_write(struct dw_hdmi_qp *hdmi,
 			if (i2c->stat & I2CM_NACK_RCVD_IRQ) {
 				dev_err(hdmi->dev, "i2c write nack!\n");
 				hdmi_writel(hdmi, 0x01, I2CM_CONTROL0);
+				hdmi_modb(hdmi, 0, I2CM_WR_MASK, I2CM_INTERFACE_CONTROL0);
 				retry--;
 				usleep_range(10000, 11000);
 				continue;
--- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.h
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.h
@@ -366,6 +366,11 @@ struct rockchip_mcu_timing {
 	int mcu_hold_mode;
 };

+struct vop_mcu_bypass_cfg {
+	const struct rockchip_mcu_timing timing;
+	unsigned long dclk_rate;
+};
+
 struct loader_cubic_lut {
 	bool enable;
 	u32 offset;
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
@@ -304,6 +304,7 @@ struct vop {
 	struct rockchip_dclk_pll *pll;

 	struct rockchip_mcu_timing mcu_timing;
+	struct rockchip_mcu_timing mcu_bypass_timing;

 	struct vop_win win[];
 };
@@ -867,7 +868,8 @@ static void scl_vop_cal_scl_fac(struct vop *vop, const struct vop_win *win,
 	if (!win->phy->scl)
 		return;

-	if ((adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE) && vop->version == VOP_VERSION(2, 2)) {
+	if ((adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE) &&
+	    vop->version == VOP_VERSION_RK3036) {
 		VOP_SCL_SET(vop, win, scale_yrgb_x, ((src_w << 12) / dst_w));
 		VOP_SCL_SET(vop, win, scale_yrgb_y, ((src_h << 12) / dst_h));
 		if (is_yuv) {
@@ -1682,7 +1684,7 @@ static void vop_initial(struct drm_crtc *crtc)
 	VOP_CTRL_SET(vop, afbdc_en, 0);
 	vop_enable_debug_irq(crtc);

-	if (vop->version == VOP_VERSION(2, 0xd)) {
+	if (vop->version == VOP_VERSION_RK3576_LITE) {
 		VOP_GRF_SET(vop, grf, grf_vopl_sel, 1);
 		VOP_CTRL_SET(vop, enable, 1);
 	}
@@ -1989,8 +1991,7 @@ static void vop_plane_atomic_disable(struct drm_plane *plane,
 	 * vop will access the freed memory lead to iommu pagefault.
 	 * so we add this reset to workaround.
 	 */
-	if (VOP_MAJOR(vop->version) == 2 && VOP_MINOR(vop->version) == 5 &&
-	    win->win_id == 2)
+	if (vop->version == VOP_VERSION_PX30_LITE && win->win_id == 2)
 		VOP_WIN_SET(vop, win, yrgb_mst, 0);

 	spin_unlock(&vop->reg_lock);
@@ -2120,7 +2121,9 @@ static void vop_plane_atomic_update(struct drm_plane *plane,
 			dsp_h = 4;
 		actual_h = dsp_h * actual_h / drm_rect_height(dest);
 	}
-	if ((vop->version == VOP_VERSION(2, 2) || vop->version >= VOP_VERSION(2, 0xd)) &&
+	if ((vop->version == VOP_VERSION_RK3036 ||
+	     vop->version == VOP_VERSION_RK3506 ||
+	     vop->version == VOP_VERSION_RK3576_LITE) &&
 	    (adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE))
 		dsp_h = dsp_h / 2;

@@ -2135,7 +2138,9 @@ static void vop_plane_atomic_update(struct drm_plane *plane,

 	dsp_stx = dest->x1 + mode->crtc_htotal - mode->crtc_hsync_start;
 	dsp_sty = dest->y1 + mode->crtc_vtotal - mode->crtc_vsync_start;
-	if ((vop->version == VOP_VERSION(2, 2) || vop->version >= VOP_VERSION(2, 0xd)) &&
+	if ((vop->version == VOP_VERSION_RK3036 ||
+	     vop->version == VOP_VERSION_RK3506 ||
+	     vop->version == VOP_VERSION_RK3576_LITE) &&
 	    (adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE))
 		dsp_sty = dest->y1 / 2 + mode->crtc_vtotal - mode->crtc_vsync_start;
 	dsp_st = dsp_sty << 16 | (dsp_stx & 0xffff);
@@ -2595,7 +2600,7 @@ static int vop_crtc_enable_vblank(struct drm_crtc *crtc)

 	spin_lock_irqsave(&vop->irq_lock, flags);

-	if (VOP_MAJOR(vop->version) == 3 && VOP_MINOR(vop->version) >= 7) {
+	if (vop->version == VOP_VERSION_RK3228 || vop->version == VOP_VERSION_RK3328) {
 		VOP_INTR_SET_TYPE(vop, clear, FS_FIELD_INTR, 1);
 		VOP_INTR_SET_TYPE(vop, enable, FS_FIELD_INTR, 1);
 	} else {
@@ -2618,7 +2623,7 @@ static void vop_crtc_disable_vblank(struct drm_crtc *crtc)

 	spin_lock_irqsave(&vop->irq_lock, flags);

-	if (VOP_MAJOR(vop->version) == 3 && VOP_MINOR(vop->version) >= 7)
+	if (vop->version == VOP_VERSION_RK3228 || vop->version == VOP_VERSION_RK3328)
 		VOP_INTR_SET_TYPE(vop, enable, FS_FIELD_INTR, 0);
 	else
 		VOP_INTR_SET_TYPE(vop, enable, FS_INTR, 0);
@@ -2927,12 +2932,13 @@ vop_crtc_mode_valid(struct drm_crtc *crtc, const struct drm_display_mode *mode)
 		return MODE_BAD_HVALUE;

 	if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
-	    VOP_MAJOR(vop->version) == 3 &&
-	    VOP_MINOR(vop->version) <= 2)
+	    (vop->version == VOP_VERSION_RK3288 || vop->version == VOP_VERSION_RK3288W ||
+	     vop->version == VOP_VERSION_RK3368))
 		return MODE_BAD;

 	/*
 	 * Dclk need to be double if BT656 interface and vop version >= 2.12.
+	 * That is RV1126/RV1106/RK3576_LITE/RK3506
 	 */
 	if (mode->flags & DRM_MODE_FLAG_DBLCLK ||
 	    (VOP_MAJOR(vop->version) == 2 && VOP_MINOR(vop->version) >= 12 &&
@@ -3126,6 +3132,7 @@ static void vop_set_out_mode(struct vop *vop, u32 mode)
 static void vop_mcu_bypass_mode_setup(struct drm_crtc *crtc)
 {
 	struct vop *vop = to_vop(crtc);
+	const struct rockchip_mcu_timing *mcu_timing = &vop->data->mcu_bypass_cfg->timing;

 	/*
 	 * If mcu_hold_mode is 1, set 1 to mcu_frame_st will
@@ -3137,11 +3144,27 @@ static void vop_mcu_bypass_mode_setup(struct drm_crtc *crtc)
 	VOP_CTRL_SET(vop, mcu_type, 1);

 	VOP_CTRL_SET(vop, mcu_hold_mode, 1);
-	VOP_CTRL_SET(vop, mcu_pix_total, 53);
-	VOP_CTRL_SET(vop, mcu_cs_pst, 6);
-	VOP_CTRL_SET(vop, mcu_cs_pend, 48);
-	VOP_CTRL_SET(vop, mcu_rw_pst, 12);
-	VOP_CTRL_SET(vop, mcu_rw_pend, 30);
+	/*
+	 * Use user-defined mcu bypass timing if mcu-bypass-timing
+	 * node has been found in dts, otherwise setup the default
+	 * timing which can meet the read/write timing requirements
+	 * of most mcu panel.
+	 */
+	if (vop->mcu_bypass_timing.mcu_pix_total) {
+		VOP_CTRL_SET(vop, mcu_pix_total, vop->mcu_bypass_timing.mcu_pix_total);
+		VOP_CTRL_SET(vop, mcu_cs_pst, vop->mcu_bypass_timing.mcu_cs_pst);
+		VOP_CTRL_SET(vop, mcu_cs_pend, vop->mcu_bypass_timing.mcu_cs_pend);
+		VOP_CTRL_SET(vop, mcu_rw_pst, vop->mcu_bypass_timing.mcu_rw_pst);
+		VOP_CTRL_SET(vop, mcu_rw_pend, vop->mcu_bypass_timing.mcu_rw_pend);
+	} else {
+		VOP_CTRL_SET(vop, mcu_pix_total, mcu_timing->mcu_pix_total);
+		VOP_CTRL_SET(vop, mcu_cs_pst, mcu_timing->mcu_cs_pst);
+		VOP_CTRL_SET(vop, mcu_cs_pend, mcu_timing->mcu_cs_pend);
+		VOP_CTRL_SET(vop, mcu_rw_pst, mcu_timing->mcu_rw_pst);
+		VOP_CTRL_SET(vop, mcu_rw_pend, mcu_timing->mcu_rw_pend);
+
+		clk_set_rate(vop->dclk, vop->data->mcu_bypass_cfg->dclk_rate);
+	}
 }

 static void vop_mcu_mode_setup(struct drm_crtc *crtc)
@@ -3165,10 +3188,11 @@ static void vop_mcu_mode_setup(struct drm_crtc *crtc)
 	VOP_CTRL_SET(vop, mcu_rw_pend, vop->mcu_timing.mcu_rw_pend);
 }

-static void vop_crtc_send_mcu_cmd(struct drm_crtc *crtc,  u32 type, u32 value)
+static void vop_crtc_send_mcu_cmd(struct drm_crtc *crtc, u32 type, u32 value)
 {
 	struct drm_display_mode *adjusted_mode;
 	struct vop *vop = NULL;
+	uint32_t val = 0;

 	if (!crtc)
 		return;
@@ -3176,15 +3200,13 @@ static void vop_crtc_send_mcu_cmd(struct drm_crtc *crtc,  u32 type, u32 value)
 	vop = to_vop(crtc);
 	adjusted_mode = &crtc->state->adjusted_mode;

-	if (vop->version >= VOP_VERSION(2, 0xd)) {
+	if (vop->data->mcu_bypass_cfg) {
 		/*
 		 * 1.set mcu bypass mode timing.
 		 * 2.set dclk rate to 150M.
 		 */
-		if ((type == MCU_SETBYPASS) && value) {
+		if ((type == MCU_SETBYPASS) && value)
 			vop_mcu_bypass_mode_setup(crtc);
-			clk_set_rate(vop->dclk, 150000000);
-		}
 	}

 	mutex_lock(&vop->vop_lock);
@@ -3199,6 +3221,11 @@ static void vop_crtc_send_mcu_cmd(struct drm_crtc *crtc,  u32 type, u32 value)
 			VOP_CTRL_SET(vop, mcu_rs, 1);
 			VOP_CTRL_SET(vop, mcu_rw_bypass_port, value);
 			break;
+		case MCU_RDDATA:
+			VOP_CTRL_SET(vop, mcu_rs, 1);
+			val = VOP_CTRL_GET(vop, mcu_rw_bypass_port);
+			DRM_DEBUG_DRIVER("mcu read reg[0x%02x] = 0x%02x", value, val);
+			break;
 		case MCU_SETBYPASS:
 			VOP_CTRL_SET(vop, mcu_bypass, value ? 1 : 0);
 			break;
@@ -3208,7 +3235,7 @@ static void vop_crtc_send_mcu_cmd(struct drm_crtc *crtc,  u32 type, u32 value)
 	}
 	mutex_unlock(&vop->vop_lock);

-	if (vop->version >= VOP_VERSION(2, 0xd)) {
+	if (vop->data->mcu_bypass_cfg) {
 		/*
 		 * 1.restore mcu data mode timing.
 		 * 2.restore dclk rate to crtc_clock.
@@ -3300,6 +3327,7 @@ static bool vop_crtc_mode_fixup(struct drm_crtc *crtc,

 	/*
 	 * Dclk need to be double if BT656 interface and vop version >= 2.12.
+	 * That is RV1126/RV1106/RK3576_LITE/RK3506
 	 */
 	if (mode->flags & DRM_MODE_FLAG_DBLCLK ||
 	    (VOP_MAJOR(vop->version) == 2 && VOP_MINOR(vop->version) >= 12 &&
@@ -3405,6 +3433,9 @@ static void vop_update_csc(struct drm_crtc *crtc)
 	struct vop *vop = to_vop(crtc);
 	u32 val;

+	/*
+	 * When using BT656, set RV1126/RV1106/RK3576_LITE/RK3506 to P8888 mode.
+	 */
 	if ((s->output_mode == ROCKCHIP_OUT_MODE_AAAA &&
 	     !(vop->data->feature & VOP_FEATURE_OUTPUT_10BIT)) ||
 	    (VOP_MAJOR(vop->version) == 2 && VOP_MINOR(vop->version) >= 12 &&
@@ -3421,8 +3452,7 @@ static void vop_update_csc(struct drm_crtc *crtc)
 	 * For RK3576 vopl, rg_swap and rb_swap need to be enabled in
 	 * YUV444 bus_format.
 	 */
-	if ((VOP_MAJOR(vop->version) == 2 && VOP_MINOR(vop->version) == 0xd) &&
-	    s->bus_format == MEDIA_BUS_FMT_YUV8_1X24)
+	if (vop->version == VOP_VERSION_RK3576_LITE && s->bus_format == MEDIA_BUS_FMT_YUV8_1X24)
 		VOP_CTRL_SET(vop, dsp_data_swap, DSP_RG_SWAP | DSP_RB_SWAP);

 	VOP_CTRL_SET(vop, out_mode, s->output_mode);
@@ -3438,13 +3468,13 @@ static void vop_update_csc(struct drm_crtc *crtc)

 	/*
 	 * Background color is 10bit depth if vop version >= 3.5
+	 * That is RK3399/RK3228/RK3328
 	 */
 	if (!is_yuv_output(s->bus_format))
 		val = 0;
-	else if (vop->version == VOP_VERSION(2, 0xd))
+	else if (vop->version == VOP_VERSION_RK3576_LITE)
 		val = 0;
-	else if (VOP_MAJOR(vop->version) == 3 && VOP_MINOR(vop->version) == 8 &&
-		 s->hdr.pre_overlay)
+	else if (vop->version == VOP_VERSION_RK3328 && s->hdr.pre_overlay)
 		val = 0;
 	else if (VOP_MAJOR(vop->version) == 3 && VOP_MINOR(vop->version) >= 5)
 		val = 0x20010200;
@@ -3544,7 +3574,8 @@ static void vop_crtc_atomic_enable(struct drm_crtc *crtc,
 		vop_crtc_load_lut(crtc);

 	if (vop->mcu_timing.mcu_pix_total) {
-		if (vop->version >= VOP_VERSION(2, 0xd))
+		if (vop->version == VOP_VERSION_RK3576_LITE ||
+		    vop->version == VOP_VERSION_RK3506)
 			vop_set_out_mode(vop, s->output_mode);
 		else
 			vop_set_out_mode(vop, ROCKCHIP_OUT_MODE_P888);
@@ -3553,7 +3584,7 @@ static void vop_crtc_atomic_enable(struct drm_crtc *crtc,

 	dclk_inv = (s->bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE) ? 1 : 0;
 	/* For improving signal quality, dclk need to be inverted by default on rv1106. */
-	if ((VOP_MAJOR(vop->version) == 2 && VOP_MINOR(vop->version) == 12))
+	if (vop->version == VOP_VERSION_RV1106)
 		dclk_inv = !dclk_inv;

 	VOP_CTRL_SET(vop, dclk_pol, dclk_inv);
@@ -3613,7 +3644,7 @@ static void vop_crtc_atomic_enable(struct drm_crtc *crtc,
 		 * RK3576 DSI CTRL hsync/vsync polarity is positive and can't update,
 		 * so set VOP hsync/vsync polarity as positive by default.
 		 */
-		if (vop->version == VOP_VERSION(2, 0xd))
+		if (vop->version == VOP_VERSION_RK3576_LITE)
 			val = BIT(HSYNC_POSITIVE) | BIT(VSYNC_POSITIVE);
 		VOP_CTRL_SET(vop, mipi_en, 1);
 		VOP_CTRL_SET(vop, mipi_pin_pol, val);
@@ -3684,8 +3715,7 @@ static void vop_crtc_atomic_enable(struct drm_crtc *crtc,
 		act_end = vact_end;
 	}

-	if (VOP_MAJOR(vop->version) == 3 &&
-	    (VOP_MINOR(vop->version) == 2 || VOP_MINOR(vop->version) == 8))
+	if (vop->version == VOP_VERSION_RK3368 || vop->version == VOP_VERSION_RK3328)
 		for_ddr_freq = 1000;
 	VOP_INTR_SET(vop, line_flag_num[0], act_end);
 	VOP_INTR_SET(vop, line_flag_num[1],
@@ -4179,7 +4209,7 @@ static void vop_tv_config_update(struct drm_crtc *crtc,
 	VOP_CTRL_SET(vop, bcsh_sin_hue, sin_hue);
 	VOP_CTRL_SET(vop, bcsh_cos_hue, cos_hue);
 	VOP_CTRL_SET(vop, bcsh_out_mode, BCSH_OUT_MODE_NORMAL_VIDEO);
-	if (VOP_MAJOR(vop->version) == 3 && VOP_MINOR(vop->version) == 0)
+	if (vop->version == VOP_VERSION_RK3288)
 		VOP_CTRL_SET(vop, auto_gate_en, 0);
 	VOP_CTRL_SET(vop, bcsh_en, s->bcsh_en);
 }
@@ -4226,7 +4256,7 @@ static void vop_cfg_update(struct drm_crtc *crtc,

 static bool vop_fs_irq_is_pending(struct vop *vop)
 {
-	if (VOP_MAJOR(vop->version) == 3 && VOP_MINOR(vop->version) >= 7)
+	if (vop->version == VOP_VERSION_RK3228 || vop->version == VOP_VERSION_RK3328)
 		return VOP_INTR_GET_TYPE(vop, status, FS_FIELD_INTR);
 	else
 		return VOP_INTR_GET_TYPE(vop, status, FS_INTR);
@@ -5382,6 +5412,27 @@ static int vop_bind(struct device *dev, struct device *master, void *data)
 			vop->mcu_timing.mcu_hold_mode = val;
 	}

+	mcu = of_get_child_by_name(dev->of_node, "mcu-bypass-timing");
+	if (!mcu) {
+		dev_dbg(dev, "no mcu-bypass-timing node found in %s\n",
+			dev->of_node->full_name);
+	} else {
+		u32 val;
+
+		if (!of_property_read_u32(mcu, "mcu-pix-total", &val))
+			vop->mcu_bypass_timing.mcu_pix_total = val;
+		if (!of_property_read_u32(mcu, "mcu-cs-pst", &val))
+			vop->mcu_bypass_timing.mcu_cs_pst = val;
+		if (!of_property_read_u32(mcu, "mcu-cs-pend", &val))
+			vop->mcu_bypass_timing.mcu_cs_pend = val;
+		if (!of_property_read_u32(mcu, "mcu-rw-pst", &val))
+			vop->mcu_bypass_timing.mcu_rw_pst = val;
+		if (!of_property_read_u32(mcu, "mcu-rw-pend", &val))
+			vop->mcu_bypass_timing.mcu_rw_pend = val;
+		if (!of_property_read_u32(mcu, "mcu-hold-mode", &val))
+			vop->mcu_bypass_timing.mcu_hold_mode = val;
+	}
+
 	dual_channel_swap = of_property_read_bool(dev->of_node,
 						  "rockchip,dual-channel-swap");
 	vop->dual_channel_swap = dual_channel_swap;
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h
@@ -21,7 +21,24 @@
 #define VOP_MAJOR(version)		((version) >> 8)
 #define VOP_MINOR(version)		((version) & 0xff)

-#define VOP_VERSION_RK3576_LITE		VOP_VERSION(0x2, 0xd)
+#define VOP_VERSION_RK3066		VOP_VERSION(2, 1)
+#define VOP_VERSION_RK3036		VOP_VERSION(2, 2)
+#define VOP_VERSION_RK3126		VOP_VERSION(2, 4)
+#define VOP_VERSION_PX30_LITE		VOP_VERSION(2, 5)
+#define VOP_VERSION_PX30_BIG		VOP_VERSION(2, 6)
+#define VOP_VERSION_RK3308		VOP_VERSION(2, 7)
+#define VOP_VERSION_RV1126		VOP_VERSION(2, 0xb)
+#define VOP_VERSION_RV1106		VOP_VERSION(2, 0xc)
+#define VOP_VERSION_RK3576_LITE		VOP_VERSION(2, 0xd)
+#define VOP_VERSION_RK3506		VOP_VERSION(2, 0xe)
+#define VOP_VERSION_RK3288		VOP_VERSION(3, 0)
+#define VOP_VERSION_RK3288W		VOP_VERSION(3, 1)
+#define VOP_VERSION_RK3368		VOP_VERSION(3, 2)
+#define VOP_VERSION_RK3366		VOP_VERSION(3, 4)
+#define VOP_VERSION_RK3399_BIG		VOP_VERSION(3, 5)
+#define VOP_VERSION_RK3399_LITE		VOP_VERSION(3, 6)
+#define VOP_VERSION_RK3228		VOP_VERSION(3, 7)
+#define VOP_VERSION_RK3328		VOP_VERSION(3, 8)

 #define VOP2_VERSION(major, minor, build)	((major) << 24 | (minor) << 16 | (build))
 #define VOP2_MAJOR(version)		(((version) >> 24) & 0xff)
@@ -694,6 +711,7 @@ enum _vop_rgb2rgb_conv_mode {
 enum _MCU_IOCTL {
 	MCU_WRCMD = 0,
 	MCU_WRDATA,
+	MCU_RDDATA,
 	MCU_SETBYPASS,
 };

@@ -1295,6 +1313,7 @@ struct vop_data {
 	const struct vop_hdr_table *hdr_table;
 	const struct vop_grf_ctrl *grf;
 	const struct vop_grf_ctrl *vo0_grf;
+	const struct vop_mcu_bypass_cfg *mcu_bypass_cfg;
 	unsigned int win_size;
 	uint32_t version;
 	struct vop_rect max_input;
--- a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c
+++ b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c
@@ -2102,6 +2102,17 @@ static const struct vop_grf_ctrl rk3506_grf_ctrl = {
 	.grf_dclk_inv = VOP_REG(RK3506_GRF_SOC_CON2, 0x1, 0),
 };

+static const struct vop_mcu_bypass_cfg rk3506_mcu_bypass_cfg = {
+	.timing = {
+		.mcu_pix_total = 26,
+		.mcu_cs_pst = 3,
+		.mcu_cs_pend = 24,
+		.mcu_rw_pst = 6,
+		.mcu_rw_pend = 15,
+	},
+	.dclk_rate = 120000000,
+};
+
 static const struct vop_data rk3506_vop = {
 	.soc_id = 0x3506,
 	.vop_id = 0,
@@ -2113,6 +2124,7 @@ static const struct vop_data rk3506_vop = {
 	.grf = &rk3506_grf_ctrl,
 	.win = rk3506_vop_win_data,
 	.win_size = ARRAY_SIZE(rk3506_vop_win_data),
+	.mcu_bypass_cfg = &rk3506_mcu_bypass_cfg,
 };

 static const struct vop_ctrl rk3576_lit_ctrl_data = {
@@ -2231,6 +2243,17 @@ static const struct vop_grf_ctrl rk3576_lit_grf_ctrl = {
 	.grf_vopl_sel = VOP_REG(RK3576_IOC_GRF_MISC_CON8, 0x1, 11),
 };

+static const struct vop_mcu_bypass_cfg rk3576_lit_mcu_bypass_cfg = {
+	.timing = {
+		.mcu_pix_total = 53,
+		.mcu_cs_pst = 6,
+		.mcu_cs_pend = 48,
+		.mcu_rw_pst = 12,
+		.mcu_rw_pend = 30,
+	},
+	.dclk_rate = 150000000,
+};
+
 static const struct vop_data rk3576_vop_lit = {
 	.soc_id = 0x3576,
 	.vop_id = 0,
@@ -2243,6 +2266,7 @@ static const struct vop_data rk3576_vop_lit = {
 	.grf = &rk3576_lit_grf_ctrl,
 	.win = rk3576_lit_win_data,
 	.win_size = ARRAY_SIZE(rk3576_lit_win_data),
+	.mcu_bypass_cfg = &rk3576_lit_mcu_bypass_cfg,
 };

 static const struct of_device_id vop_driver_dt_match[] = {
--- a/drivers/media/i2c/rk628/rk628_bt1120_v4l2.c
+++ b/drivers/media/i2c/rk628/rk628_bt1120_v4l2.c
@@ -2015,9 +2015,14 @@ static int rk628_bt1120_probe(struct i2c_client *client,

 	rk628_bt1120_power_on(bt1120);
 	rk628_cru_initialize(rk628);
-	rk628_clk_set_rate(rk628, CGU_CLK_CPLL, CPLL_REF_CLK);

 	rk628_version_parse(rk628);
+	if (rk628->version == RK628_UNKNOWN) {
+		v4l2_err(sd, "can't get rk628 version\n");
+		err = -ENODEV;
+		goto power_off;
+	}
+	rk628_clk_set_rate(rk628, CGU_CLK_CPLL, CPLL_REF_CLK);

 #ifdef CONFIG_VIDEO_V4L2_SUBDEV_API
 	v4l2_i2c_subdev_init(sd, client, &rk628_bt1120_ops);
@@ -2166,6 +2171,7 @@ err_hdl:
 	mutex_destroy(&bt1120->confctl_mutex);
 	media_entity_cleanup(&sd->entity);
 	v4l2_ctrl_handler_free(&bt1120->hdl);
+power_off:
 	rk628_bt1120_power_off(bt1120);
 	return err;
 }
--- a/drivers/media/i2c/rk628/rk628_csi_v4l2.c
+++ b/drivers/media/i2c/rk628/rk628_csi_v4l2.c
@@ -3439,9 +3439,14 @@ static int rk628_csi_probe(struct i2c_client *client,

 	rk628_csi_power_on(csi);
 	rk628_cru_initialize(csi->rk628);
-	rk628_clk_set_rate(rk628, CGU_CLK_CPLL, CPLL_REF_CLK);

 	rk628_version_parse(rk628);
+	if (rk628->version == RK628_UNKNOWN) {
+		v4l2_err(sd, "can't get rk628 version\n");
+		err = -ENODEV;
+		goto power_off;
+	}
+	rk628_clk_set_rate(rk628, CGU_CLK_CPLL, CPLL_REF_CLK);

 	if (rk628->version >= RK628F_VERSION) {
 		err = rk628_csi_get_multi_dev_info(csi);
--- a/drivers/media/platform/rockchip/hdmirx/rk_hdmirx.c
+++ b/drivers/media/platform/rockchip/hdmirx/rk_hdmirx.c
@@ -3050,9 +3050,10 @@ static void hdmirx_add_fence_to_vb_done(struct hdmirx_stream *stream,

 	if (vb_fence) {
 		/*  pass the fence_fd to userspace through timecode.userbits */
-		if (put_user(vb_fence->fence_fd, vb_done->timecode.userbits))
-			v4l2_err(v4l2_dev, "%s: failed to trans fence fd!\n", __func__);
-
+		vb_done->timecode.userbits[0] = vb_fence->fence_fd & 0xff;
+		vb_done->timecode.userbits[1] = (vb_fence->fence_fd & 0xff00) >> 8;
+		vb_done->timecode.userbits[2] = (vb_fence->fence_fd & 0xff0000) >> 16;
+		vb_done->timecode.userbits[3] = (vb_fence->fence_fd & 0xff000000) >> 24;
 		v4l2_dbg(3, debug, v4l2_dev, "%s: fence:%p, fence_fd:%d\n",
 			 __func__, vb_fence->fence, vb_fence->fence_fd);
 	} else {
--- a/drivers/video/rockchip/rga3/include/rga.h
+++ b/drivers/video/rockchip/rga3/include/rga.h
@@ -753,7 +753,7 @@ struct rga_req {

 	struct rga_gauss_config gauss_config;

-	uint8_t reservr[27];
+	uint8_t reservr[24];
 };

 struct rga_alpha_config {
--- a/drivers/video/rockchip/rga3/include/rga_common.h
+++ b/drivers/video/rockchip/rga3/include/rga_common.h
@@ -12,6 +12,39 @@
 #include "rga_drv.h"
 #include "rga_hw_config.h"

+#ifdef pr_fmt
+#undef pr_fmt
+#endif
+
+#define pr_fmt(fmt) "%s: " fmt, "rga"
+
+#define rga_log(fmt, args...) \
+	pr_info("%-6d %-6d: " fmt, get_current()->tgid, get_current()->pid, ##args)
+#define rga_err(fmt, args...) \
+	pr_err("%-6d %-6d: " fmt, get_current()->tgid, get_current()->pid, ##args)
+
+#define rga_dev_log(dev, fmt, args...) \
+	dev_info(dev, "%-6d %-6d: " fmt, current->tgid, current->pid, ##args)
+#define rga_dev_err(dev, fmt, args...) \
+	dev_err(dev, "%-6d %-6d: " fmt, current->tgid, current->pid, ##args)
+
+#define rga_job_log(job, fmt, args...) \
+	pr_info("%-6d %-6d: ID[%d]: " fmt, job->session->tgid, job->pid, job->request_id, ##args)
+#define rga_job_err(job, fmt, args...) \
+	pr_err("%-6d %-6d: ID[%d]: " fmt, job->session->tgid, job->pid, job->request_id, ##args)
+
+#define rga_req_log(request, fmt, args...) \
+	pr_info("%-6d %-6d: ID[%d]: " fmt, \
+	request->session->tgid, request->pid, request->id, ##args)
+#define rga_req_err(request, fmt, args...) \
+	pr_err("%-6d %-6d: ID[%d]: " fmt, request->session->tgid, request->pid, request->id, ##args)
+
+#define rga_buf_log(buf, fmt, args...) \
+	pr_info("%-6d %-6d: handle[%d]: " fmt, \
+	buf->session->tgid, current->pid, buf->handle, ##args)
+#define rga_buf_err(buf, fmt, args...) \
+	pr_err("%-6d %-6d: handle[%d]: " fmt, buf->session->tgid, current->pid, buf->handle, ##args)
+
 #define RGA_GET_PAGE_COUNT(size) (((size) >> PAGE_SHIFT) + (((size) & (~PAGE_MASK)) ? 1 : 0))

 bool rga_is_rgb_format(uint32_t format);
@@ -33,6 +66,8 @@ int rga_get_pixel_stride_from_format(uint32_t format);

 const char *rga_get_format_name(uint32_t format);
 const char *rga_get_render_mode_str(uint8_t mode);
+const char *rga_get_store_mode_str(uint32_t mode);
+const char *rga_get_interp_str(uint8_t interp);
 const char *rga_get_rotate_mode_str(uint8_t mode);
 const char *rga_get_blend_mode_str(enum rga_alpha_blend_mode mode);
 const char *rga_get_memory_type_str(uint8_t type);
@@ -46,5 +81,6 @@ int rga_image_size_cal(int w, int h, int format,
 		       int *yrgb_size, int *uv_size, int *v_size);
 void rga_dump_memory_parm(struct rga_memory_parm *parm);
 void rga_dump_external_buffer(struct rga_external_buffer *buffer);
+void rga_dump_req(struct rga_request *request, struct rga_req *req);

 #endif
--- a/drivers/video/rockchip/rga3/include/rga_debugger.h
+++ b/drivers/video/rockchip/rga3/include/rga_debugger.h
@@ -132,7 +132,6 @@ static inline int rga_procfs_init(void)

 #endif /* #ifdef CONFIG_ROCKCHIP_RGA_DEBUGGER */

-void rga_cmd_print_debug_info(struct rga_req *req);
 void rga_request_task_debug_info(struct seq_file *m, struct rga_req *req);
 #ifdef CONFIG_NO_GKI
 void rga_dump_job_image(struct rga_job *dump_job);
--- a/drivers/video/rockchip/rga3/include/rga_drv.h
+++ b/drivers/video/rockchip/rga3/include/rga_drv.h
@@ -69,6 +69,7 @@

 /* load interval: 1000ms */
 #define RGA_LOAD_INTERVAL_US 1000000
+#define RGA_LOAD_ACTIVE_MAX_US 5000000

 /* timer interval: 1000ms */
 #define RGA_TIMER_INTERVAL_NS 1000000000
@@ -236,6 +237,8 @@ struct rga_session {
 	pid_t tgid;

 	char *pname;
+
+	ktime_t last_active;
 };

 struct rga_job_buffer {
@@ -262,6 +265,17 @@ struct rga_job_buffer {
 	int page_count;
 };

+struct rga_job_timestamp {
+	ktime_t init;
+	ktime_t insert;
+	ktime_t hw_execute;
+	ktime_t hw_done;
+	ktime_t done;
+
+	/* The time only for hrtimer to calculate the load */
+	ktime_t hw_recode;
+};
+
 struct rga_job {
 	struct list_head head;

@@ -284,11 +298,8 @@ struct rga_job {
 	struct mm_struct *mm;

 	/* job time stamp */
-	ktime_t timestamp;
-	/* The time when the job is actually executed on the hardware */
-	ktime_t hw_running_time;
-	/* The time only for hrtimer to calculate the load */
-	ktime_t hw_recoder_time;
+	struct rga_job_timestamp timestamp;
+
 	unsigned int flags;
 	int request_id;
 	int priority;
--- a/drivers/video/rockchip/rga3/rga2_reg_info.c
+++ b/drivers/video/rockchip/rga3/rga2_reg_info.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga2_reg: " fmt
-
 #include "rga2_reg_info.h"
 #include "rga_dma_buf.h"
 #include "rga_iommu.h"
@@ -350,7 +348,7 @@ static void RGA2_set_reg_src_info(u8 *base, struct rga2_req *msg)
 				vsp_scale_mode = 0x0;
 			} else {
 				/* force select bi-linear */
-				pr_err("Horizontal scaling will be forcibly switched to bilinear.\n");
+				rga_err("Horizontal scaling will be forcibly switched to bilinear.\n");
 				vsp_scale_mode = 0x1;
 			}
 			break;
@@ -1355,15 +1353,15 @@ static void RGA2_set_reg_dst_info(u8 *base, struct rga2_req *msg)

 	if (ydither_en) {
 		if (x_mirr && y_mirr) {
-			pr_err("ydither mode do not support rotate x_mirr=%d,y_mirr=%d\n",
+			rga_err("ydither mode do not support rotate x_mirr=%d,y_mirr=%d\n",
 				x_mirr, y_mirr);
 		}

 		if (msg->dst.act_w != msg->src.act_w)
-			pr_err("ydither mode do not support x dir scale\n");
+			rga_err("ydither mode do not support x dir scale\n");

 		if (msg->dst.act_h != msg->src.act_h)
-			pr_err("ydither mode do not support y dir scale\n");
+			rga_err("ydither mode do not support y dir scale\n");
 	}

 	if (dst_fmt_y4_lut_en) {
@@ -1918,20 +1916,20 @@ static int RGA_set_reg_gauss(u8 *base, struct rga2_req *msg)
 	bRGA_GAUSS_COE = (u32 *)(base + RGA2_GAUSS_COE_OFFSET);

 	if (msg->gauss_config.size != 3) {
-		pr_err("Gaussian blur only support 3x3\n");
+		rga_err("Gaussian blur only support 3x3\n");
 		return -EINVAL;
 	}

 	coe = kmalloc(sizeof(uint32_t) * msg->gauss_config.size, GFP_KERNEL);
 	if (coe == NULL) {
-		pr_err("Gaussian blur alloc coe buffer error!\n");
+		rga_err("Gaussian blur alloc coe buffer error!\n");
 		return -ENOMEM;
 	}

 	if (unlikely(copy_from_user(coe,
 				    u64_to_user_ptr(msg->gauss_config.coe_ptr),
 				    sizeof(uint32_t) * msg->gauss_config.size))) {
-		pr_err("Gaussian blur coe copy_from_user failed\n");
+		rga_err("Gaussian blur coe copy_from_user failed\n");

 		kfree(coe);
 		return -EFAULT;
@@ -2319,7 +2317,7 @@ static int rga2_gen_reg_info(struct rga_scheduler_t *scheduler, u8 *base, struct
 		RGA2_set_reg_update_patten_buff(base, msg);
 		break;
 	default:
-		pr_err("ERROR msg render mode %d\n", msg->render_mode);
+		rga_err("ERROR msg render mode %d\n", msg->render_mode);
 		return -EINVAL;
 	}

@@ -2623,52 +2621,54 @@ static void rga2_soft_reset(struct rga_scheduler_t *scheduler)
 	}

 	if (i == RGA_RESET_TIMEOUT)
-		pr_err("RAG2 core[%d] soft reset timeout.\n", scheduler->core);
+		rga_err("%s[%#x] soft reset timeout.\n",
+			rga_get_core_name(scheduler->core), scheduler->core);
 	else
-		pr_info("RGA2 core[%d] soft reset complete.\n", scheduler->core);
-
+		rga_log("%s[%#x] soft reset complete.\n",
+			rga_get_core_name(scheduler->core), scheduler->core);
 }

-static int rga2_check_param(const struct rga_hw_data *data, const struct rga2_req *req)
+static int rga2_check_param(struct rga_job *job,
+			    const struct rga_hw_data *data, const struct rga2_req *req)
 {
 	if (!((req->render_mode == COLOR_FILL_MODE))) {
 		if (unlikely(rga_hw_out_of_range(&data->input_range,
 						 req->src.act_w, req->src.act_h))) {
-			pr_err("invalid src resolution act_w = %d, act_h = %d\n",
+			rga_job_err(job, "invalid src resolution act_w = %d, act_h = %d\n",
 				 req->src.act_w, req->src.act_h);
 			return -EINVAL;
 		}

 		if (unlikely(req->src.vir_w * rga_get_pixel_stride_from_format(req->src.format) >
 			     data->max_byte_stride * 8)) {
-			pr_err("invalid src stride, stride = %d, max_byte_stride = %d\n",
+			rga_job_err(job, "invalid src stride, stride = %d, max_byte_stride = %d\n",
 			       req->src.vir_w, data->max_byte_stride);
 			return -EINVAL;
 		}

 		if (unlikely(req->src.vir_w < req->src.act_w)) {
-			pr_err("invalid src_vir_w act_w = %d, vir_w = %d\n",
+			rga_job_err(job, "invalid src_vir_w act_w = %d, vir_w = %d\n",
 			       req->src.act_w, req->src.vir_w);
 			return -EINVAL;
 		}
 	}

 	if (unlikely(rga_hw_out_of_range(&data->output_range, req->dst.act_w, req->dst.act_h))) {
-		pr_err("invalid dst resolution act_w = %d, act_h = %d\n",
+		rga_job_err(job, "invalid dst resolution act_w = %d, act_h = %d\n",
 		       req->dst.act_w, req->dst.act_h);
 		return -EINVAL;
 	}

 	if (unlikely(req->dst.vir_w * rga_get_pixel_stride_from_format(req->dst.format) >
 		     data->max_byte_stride * 8)) {
-		pr_err("invalid dst stride, stride = %d, max_byte_stride = %d\n",
+		rga_err("invalid dst stride, stride = %d, max_byte_stride = %d\n",
 		       req->dst.vir_w, data->max_byte_stride);
 		return -EINVAL;
 	}

 	if (unlikely(req->dst.vir_w < req->dst.act_w)) {
 		if (req->rotate_mode != 1) {
-			pr_err("invalid dst_vir_w act_h = %d, vir_h = %d\n",
+			rga_err("invalid dst_vir_w act_h = %d, vir_h = %d\n",
 			       req->dst.act_w, req->dst.vir_w);
 			return -EINVAL;
 		}
@@ -2677,83 +2677,83 @@ static int rga2_check_param(const struct rga_hw_data *data, const struct rga2_re
 	return 0;
 }

-static int rga2_align_check(struct rga2_req *req)
+static int rga2_align_check(struct rga_job *job, struct rga2_req *req)
 {
 	if (rga_is_yuv10bit_format(req->src.format))
 		if ((req->src.vir_w % 16) || (req->src.x_offset % 2) ||
 			(req->src.act_w % 2) || (req->src.y_offset % 2) ||
 			(req->src.act_h % 2) || (req->src.vir_h % 2))
-			pr_info("err src wstride, 10bit yuv\n");
+			rga_job_log(job, "err src wstride, 10bit yuv\n");
 	if (rga_is_yuv10bit_format(req->dst.format))
 		if ((req->dst.vir_w % 16) || (req->dst.x_offset % 2) ||
 			(req->dst.act_w % 2) || (req->dst.y_offset % 2) ||
 			(req->dst.act_h % 2) || (req->dst.vir_h % 2))
-			pr_info("err dst wstride, 10bit yuv\n");
+			rga_job_log(job, "err dst wstride, 10bit yuv\n");
 	if (rga_is_yuv8bit_format(req->src.format))
 		if ((req->src.vir_w % 4) || (req->src.x_offset % 2) ||
 			(req->src.act_w % 2) || (req->src.y_offset % 2) ||
 			(req->src.act_h % 2) || (req->src.vir_h % 2))
-			pr_info("err src wstride, 8bit yuv\n");
+			rga_job_log(job, "err src wstride, 8bit yuv\n");
 	if (rga_is_yuv8bit_format(req->dst.format))
 		if ((req->dst.vir_w % 4) || (req->dst.x_offset % 2) ||
 			(req->dst.act_w % 2) || (req->dst.y_offset % 2) ||
 			(req->dst.act_h % 2) || (req->dst.vir_h % 2))
-			pr_info("err dst wstride, 8bit yuv\n");
+			rga_job_log(job, "err dst wstride, 8bit yuv\n");

 	return 0;
 }

-static void print_debug_info(struct rga2_req *req)
+static void print_debug_info(struct rga_job *job, struct rga2_req *req)
 {
-	pr_info("render_mode:%s,bitblit_mode=%d,rotate_mode:%s\n",
+	rga_job_log(job, "render_mode:%s,bitblit_mode=%d,rotate_mode:%s\n",
 		rga_get_render_mode_str(req->render_mode), req->bitblt_mode,
 		rga_get_rotate_mode_str(req->rotate_mode));

-	pr_info("src: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
+	rga_job_log(job, "src: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
 		 (unsigned long)req->src.yrgb_addr,
 		 (unsigned long)req->src.uv_addr,
 		 (unsigned long)req->src.v_addr,
 		 req->src.act_w, req->src.act_h,
 		 req->src.vir_w, req->src.vir_h);
-	pr_info("src: xoff=%d yoff=%d format=%s\n",
+	rga_job_log(job, "src: xoff=%d yoff=%d format=%s\n",
 		req->src.x_offset, req->src.y_offset,
 		 rga_get_format_name(req->src.format));

 	if (req->src1.yrgb_addr != 0 || req->src1.uv_addr != 0
 		|| req->src1.v_addr != 0) {
-		pr_info("src1: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
+		rga_job_log(job, "src1: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
 			 (unsigned long)req->src1.yrgb_addr,
 			 (unsigned long)req->src1.uv_addr,
 			 (unsigned long)req->src1.v_addr,
 			 req->src1.act_w, req->src1.act_h,
 			 req->src1.vir_w, req->src1.vir_h);
-		pr_info("src1: xoff=%d yoff=%d format=%s\n",
+		rga_job_log(job, "src1: xoff=%d yoff=%d format=%s\n",
 			req->src1.x_offset, req->src1.y_offset,
 			 rga_get_format_name(req->src1.format));
 	}

-	pr_info("dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
+	rga_job_log(job, "dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
 		 (unsigned long)req->dst.yrgb_addr,
 		 (unsigned long)req->dst.uv_addr,
 		 (unsigned long)req->dst.v_addr,
 		 req->dst.act_w, req->dst.act_h,
 		 req->dst.vir_w, req->dst.vir_h);
-	pr_info("dst: xoff=%d yoff=%d format=%s\n",
+	rga_job_log(job, "dst: xoff=%d yoff=%d format=%s\n",
 		req->dst.x_offset, req->dst.y_offset,
 		 rga_get_format_name(req->dst.format));

-	pr_info("mmu: src=%.2x src1=%.2x dst=%.2x els=%.2x\n",
+	rga_job_log(job, "mmu: src=%.2x src1=%.2x dst=%.2x els=%.2x\n",
 		req->mmu_info.src0_mmu_flag, req->mmu_info.src1_mmu_flag,
 		req->mmu_info.dst_mmu_flag, req->mmu_info.els_mmu_flag);
-	pr_info("alpha: flag %x mode=%s\n",
+	rga_job_log(job, "alpha: flag %x mode=%s\n",
 		req->alpha_rop_flag, rga_get_blend_mode_str(req->alpha_config.mode));
-	pr_info("alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
+	rga_job_log(job, "alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
 		req->alpha_config.fg_pre_multiplied, req->alpha_config.bg_pre_multiplied,
 		req->alpha_config.fg_pixel_alpha_en, req->alpha_config.bg_pixel_alpha_en,
 		req->alpha_config.fg_global_alpha_en, req->alpha_config.bg_global_alpha_en);
-	pr_info("alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
+	rga_job_log(job, "alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
 		req->alpha_config.fg_global_alpha_value, req->alpha_config.bg_global_alpha_value);
-	pr_info("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
+	rga_job_log(job, "yuv2rgb mode is %x\n", req->yuv2rgb_mode);
 }

 static int rga2_init_reg(struct rga_job *job)
@@ -2765,7 +2765,7 @@ static int rga2_init_reg(struct rga_job *job)

 	scheduler = job->scheduler;
 	if (unlikely(scheduler == NULL)) {
-		pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
+		rga_job_err(job, "failed to get scheduler, %s(%d)\n", __func__, __LINE__);
 		return -EINVAL;
 	}

@@ -2794,33 +2794,33 @@ static int rga2_init_reg(struct rga_job *job)
 	       sizeof(job->pre_intr_info));

 	/* check value if legal */
-	ret = rga2_check_param(scheduler->data, &req);
+	ret = rga2_check_param(job, scheduler->data, &req);
 	if (ret == -EINVAL) {
-		pr_err("req argument is inval\n");
+		rga_job_err(job, "req argument is inval\n");
 		return ret;
 	}

-	rga2_align_check(&req);
+	rga2_align_check(job, &req);

 	/* for debug */
 	if (DEBUGGER_EN(MSG))
-		print_debug_info(&req);
+		print_debug_info(job, &req);

 	/* RGA2 mmu set */
 	if ((req.mmu_info.src0_mmu_flag & 1) || (req.mmu_info.src1_mmu_flag & 1) ||
 	    (req.mmu_info.dst_mmu_flag & 1) || (req.mmu_info.els_mmu_flag & 1)) {
 		if (scheduler->data->mmu != RGA_MMU) {
-			pr_err("core[%d] has no MMU, please use physically contiguous memory.\n",
-			       scheduler->core);
-			pr_err("mmu_flag[src, src1, dst, els] = [0x%x, 0x%x, 0x%x, 0x%x]\n",
-			       req.mmu_info.src0_mmu_flag, req.mmu_info.src1_mmu_flag,
-			       req.mmu_info.dst_mmu_flag, req.mmu_info.els_mmu_flag);
+			rga_job_err(job, "core[%d] has no MMU, please use physically contiguous memory.\n",
+				scheduler->core);
+			rga_job_err(job, "mmu_flag[src, src1, dst, els] = [0x%x, 0x%x, 0x%x, 0x%x]\n",
+				req.mmu_info.src0_mmu_flag, req.mmu_info.src1_mmu_flag,
+				req.mmu_info.dst_mmu_flag, req.mmu_info.els_mmu_flag);
 			return -EINVAL;
 		}

 		ret = rga_set_mmu_base(job, &req);
 		if (ret < 0) {
-			pr_err("%s, [%d] set mmu info error\n", __func__,
+			rga_job_err(job, "%s, [%d] set mmu info error\n", __func__,
 				 __LINE__);
 			return -EFAULT;
 		}
@@ -2832,18 +2832,18 @@ static int rga2_init_reg(struct rga_job *job)

 	ret = rga2_gen_reg_info(scheduler, (uint8_t *)job->cmd_buf->vaddr, &req);
 	if (ret < 0) {
-		pr_err("gen reg info error\n");
+		rga_job_err(job, "gen reg info error\n");
 		return -EINVAL;
 	}

 	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], generate register cost time %lld us\n",
-			job->request_id, ktime_us_delta(ktime_get(), timestamp));
+		rga_job_log(job, "generate register cost time %lld us\n",
+			ktime_us_delta(ktime_get(), timestamp));

 	return ret;
 }

-static void rga2_dump_read_back_sys_reg(struct rga_scheduler_t *scheduler)
+static void rga2_dump_read_back_sys_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	int i;
 	unsigned long flags;
@@ -2856,15 +2856,15 @@ static void rga2_dump_read_back_sys_reg(struct rga_scheduler_t *scheduler)

 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

-	pr_info("SYS_READ_BACK_REG\n");
+	rga_job_log(job, "SYS_READ_BACK_REG\n");
 	for (i = 0; i < 6; i++)
-		pr_info("0x%04x : %.8x %.8x %.8x %.8x\n",
+		rga_job_log(job, "0x%04x : %.8x %.8x %.8x %.8x\n",
 			RGA2_SYS_REG_BASE + i * 0x10,
 			sys_reg[0 + i * 4], sys_reg[1 + i * 4],
 			sys_reg[2 + i * 4], sys_reg[3 + i * 4]);
 }

-static void rga2_dump_read_back_csc_reg(struct rga_scheduler_t *scheduler)
+static void rga2_dump_read_back_csc_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	int i;
 	unsigned long flags;
@@ -2877,15 +2877,15 @@ static void rga2_dump_read_back_csc_reg(struct rga_scheduler_t *scheduler)

 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

-	pr_info("CSC_READ_BACK_REG\n");
+	rga_job_log(job, "CSC_READ_BACK_REG\n");
 	for (i = 0; i < 3; i++)
-		pr_info("0x%04x : %.8x %.8x %.8x %.8x\n",
+		rga_job_log(job, "0x%04x : %.8x %.8x %.8x %.8x\n",
 			RGA2_CSC_REG_BASE + i * 0x10,
 			csc_reg[0 + i * 4], csc_reg[1 + i * 4],
 			csc_reg[2 + i * 4], csc_reg[3 + i * 4]);
 }

-static void rga2_dump_read_back_cmd_reg(struct rga_scheduler_t *scheduler)
+static void rga2_dump_read_back_cmd_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	int i;
 	unsigned long flags;
@@ -2898,19 +2898,19 @@ static void rga2_dump_read_back_cmd_reg(struct rga_scheduler_t *scheduler)

 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

-	pr_info("CMD_READ_BACK_REG\n");
+	rga_job_log(job, "CMD_READ_BACK_REG\n");
 	for (i = 0; i < 8; i++)
-		pr_info("0x%04x : %.8x %.8x %.8x %.8x\n",
+		rga_job_log(job, "0x%04x : %.8x %.8x %.8x %.8x\n",
 			RGA2_CMD_REG_BASE + i * 0x10,
 			cmd_reg[0 + i * 4], cmd_reg[1 + i * 4],
 			cmd_reg[2 + i * 4], cmd_reg[3 + i * 4]);
 }

-static void rga2_dump_read_back_reg(struct rga_scheduler_t *scheduler)
+static void rga2_dump_read_back_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
-	rga2_dump_read_back_sys_reg(scheduler);
-	rga2_dump_read_back_csc_reg(scheduler);
-	rga2_dump_read_back_cmd_reg(scheduler);
+	rga2_dump_read_back_sys_reg(job, scheduler);
+	rga2_dump_read_back_csc_reg(job, scheduler);
+	rga2_dump_read_back_cmd_reg(job, scheduler);
 }

 static void rga2_set_pre_intr_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
@@ -2990,12 +2990,13 @@ static int rga2_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 		master_mode_en = false;

 	if (DEBUGGER_EN(REG)) {
-		rga2_dump_read_back_sys_reg(scheduler);
-		rga2_dump_read_back_csc_reg(scheduler);
+		rga2_dump_read_back_sys_reg(job, scheduler);
+		rga2_dump_read_back_csc_reg(job, scheduler);

-		pr_info("CMD_REG\n");
+		rga_job_log(job, "CMD_REG\n");
 		for (i = 0; i < 8; i++)
-			pr_info("i = %x : %.8x %.8x %.8x %.8x\n", i,
+			rga_job_log(job, "0x%04x : %.8x %.8x %.8x %.8x\n",
+				RGA2_CMD_REG_BASE + i * 0x10,
 				cmd[0 + i * 4], cmd[1 + i * 4],
 				cmd[2 + i * 4], cmd[3 + i * 4]);
 	}
@@ -3052,14 +3053,15 @@ static int rga2_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

 	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], set register cost time %lld us\n",
-			job->request_id, ktime_us_delta(ktime_get(), now));
+		rga_job_log(job, "set register cost time %lld us\n",
+			ktime_us_delta(ktime_get(), now));

-	job->hw_running_time = now;
-	job->hw_recoder_time = now;
+	job->timestamp.hw_execute = now;
+	job->timestamp.hw_recode = now;
+	job->session->last_active = now;

 	if (DEBUGGER_EN(REG))
-		rga2_dump_read_back_reg(scheduler);
+		rga2_dump_read_back_reg(job, scheduler);

 	return 0;
 }
@@ -3070,7 +3072,7 @@ static int rga2_get_version(struct rga_scheduler_t *scheduler)
 	u32 reg_version;

 	if (!scheduler) {
-		pr_err("scheduler is null\n");
+		rga_err("scheduler is null\n");
 		return -EINVAL;
 	}

@@ -3132,7 +3134,7 @@ static int rga2_irq(struct rga_scheduler_t *scheduler)
 	scheduler->ops->read_status(job, scheduler);

 	if (DEBUGGER_EN(INT_FLAG))
-		pr_info("irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
+		rga_job_log(job, "irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
 			job->intr_status, job->hw_status, job->cmd_status,
 			job->work_cycle, job->work_cycle);

@@ -3142,9 +3144,9 @@ static int rga2_irq(struct rga_scheduler_t *scheduler)
 	} else if (job->intr_status & m_RGA2_INT_ERROR_FLAG_MASK) {
 		set_bit(RGA_JOB_STATE_INTR_ERR, &job->state);

-		pr_err("irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
-		       job->intr_status, job->hw_status, job->cmd_status,
-		       job->work_cycle, job->work_cycle);
+		rga_job_err(job, "irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
+			job->intr_status, job->hw_status, job->cmd_status,
+			job->work_cycle, job->work_cycle);

 		scheduler->ops->soft_reset(scheduler);
 	}
@@ -3162,27 +3164,27 @@ static int rga2_irq(struct rga_scheduler_t *scheduler)
 static int rga2_isr_thread(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	if (DEBUGGER_EN(INT_FLAG))
-		pr_info("isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
+		rga_job_log(job, "isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
 			rga_read(RGA2_INT, scheduler),
 			rga_read(RGA2_STATUS2, scheduler),
 			rga_read(RGA2_STATUS1, scheduler));

 	if (test_bit(RGA_JOB_STATE_INTR_ERR, &job->state)) {
 		if (job->hw_status & m_RGA2_STATUS2_RPP_ERROR)
-			pr_err("RGA current status: rpp error!\n");
+			rga_job_err(job, "RGA current status: rpp error!\n");
 		if (job->hw_status & m_RGA2_STATUS2_BUS_ERROR)
-			pr_err("RGA current status: bus error!\n");
+			rga_job_err(job, "RGA current status: bus error!\n");

 		if (job->intr_status & m_RGA2_INT_ERROR_INT_FLAG) {
-			pr_err("RGA bus error intr, please check your configuration and buffer.\n");
+			rga_job_err(job, "RGA bus error intr, please check your configuration and buffer.\n");
 			job->ret = -EFAULT;
 		} else if (job->intr_status & m_RGA2_INT_MMU_INT_FLAG) {
-			pr_err("mmu failed, please check size of the buffer or whether the buffer has been freed.\n");
+			rga_job_err(job, "mmu failed, please check size of the buffer or whether the buffer has been freed.\n");
 			job->ret = -EACCES;
 		}

 		if (job->ret == 0) {
-			pr_err("rga intr error[0x%x]!\n", job->intr_status);
+			rga_job_err(job, "rga intr error[0x%x]!\n", job->intr_status);
 			job->ret = -EFAULT;
 		}
 	}
--- a/drivers/video/rockchip/rga3/rga3_reg_info.c
+++ b/drivers/video/rockchip/rga3/rga3_reg_info.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga3_reg: " fmt
-
 #include "rga3_reg_info.h"
 #include "rga_dma_buf.h"
 #include "rga_iommu.h"
@@ -1338,7 +1336,7 @@ static int rga3_gen_reg_info(u8 *base, struct rga3_req *msg)
 		RGA3_set_reg_wr_info(base, msg);
 		break;
 	default:
-		pr_err("error msg render mode %d\n", msg->render_mode);
+		rga_err("error msg render mode %d\n", msg->render_mode);
 		break;
 	}

@@ -1743,14 +1741,16 @@ static void rga3_soft_reset(struct rga_scheduler_t *scheduler)
 	}

 	if (i == RGA_RESET_TIMEOUT)
-		pr_err("RGA3 core[%d] soft reset timeout. SYS_CTRL[0x%x], RO_SRST[0x%x]\n",
-		       scheduler->core, rga_read(RGA3_SYS_CTRL, scheduler),
-		       rga_read(RGA3_RO_SRST, scheduler));
+		rga_err("%s[%#x] soft reset timeout. SYS_CTRL[0x%x], RO_SRST[0x%x]\n",
+			rga_get_core_name(scheduler->core), scheduler->core,
+			rga_read(RGA3_SYS_CTRL, scheduler),
+			rga_read(RGA3_RO_SRST, scheduler));
 	else
-		pr_info("RGA3 core[%d] soft reset complete.\n", scheduler->core);
+		rga_log("%s[%#x] soft reset complete.\n",
+			rga_get_core_name(scheduler->core), scheduler->core);
 }

-static int rga3_scale_check(const struct rga3_req *req)
+static int rga3_scale_check(struct rga_job *job, const struct rga3_req *req)
 {
 	u32 win0_saw, win0_sah, win0_daw, win0_dah;
 	u32 win1_saw, win1_sah, win1_daw, win1_dah;
@@ -1801,24 +1801,24 @@ static int rga3_scale_check(const struct rga3_req *req)
 	}

 	if (((win0_saw >> 3) > win0_daw) || ((win0_sah >> 3) > win0_dah)) {
-		pr_info("win0 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
+		rga_job_log(job, "win0 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
 			win0_saw, win0_sah, win0_daw, win0_dah);
 		return -EINVAL;
 	}
 	if (((win0_daw >> 3) > win0_saw) || ((win0_dah >> 3) > win0_sah)) {
-		pr_info("win0 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
+		rga_job_log(job, "win0 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
 			win0_saw, win0_sah, win0_daw, win0_dah);
 		return -EINVAL;
 	}

 	if (req->win1.yrgb_addr != 0) {
 		if (((win1_saw >> 3) > win1_daw) || ((win1_sah >> 3) > win1_dah)) {
-			pr_info("win1 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
+			rga_job_log(job, "win1 unsupported to scaling less than 1/8 times. src[%d, %d], dst[%d, %d]\n",
 				win1_saw, win1_sah, win1_daw, win1_dah);
 			return -EINVAL;
 		}
 		if (((win1_daw >> 3) > win1_saw) || ((win1_dah >> 3) > win1_sah)) {
-			pr_info("win1 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
+			rga_job_log(job, "win1 unsupported to scaling more than 8 times. src[%d, %d], dst[%d, %d]\n",
 				win1_saw, win1_sah, win1_daw, win1_dah);
 			return -EINVAL;
 		}
@@ -1827,7 +1827,8 @@ static int rga3_scale_check(const struct rga3_req *req)
 	return 0;
 }

-static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_req *req)
+static int rga3_check_param(struct rga_job *job, const struct rga_hw_data *data,
+			    const struct rga3_req *req)
 {
 	if (unlikely(rga_hw_out_of_range(&(data->input_range),
 					 req->win0.src_act_w, req->win0.src_act_h) ||
@@ -1836,32 +1837,32 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
 		     rga_hw_out_of_range(&(data->input_range),
 					 req->win0.src_act_w + req->win0.x_offset,
 					 req->win0.src_act_h + req->win0.y_offset))) {
-		pr_err("invalid win0, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
-		       req->win0.src_act_w, req->win0.src_act_h,
-		       req->win0.dst_act_w, req->win0.dst_act_h,
-		       req->win0.x_offset, req->win0.y_offset);
+		rga_job_err(job, "invalid win0, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
+			req->win0.src_act_w, req->win0.src_act_h,
+			req->win0.dst_act_w, req->win0.dst_act_h,
+			req->win0.x_offset, req->win0.y_offset);
 		return -EINVAL;
 	}

 	if (unlikely(req->win0.vir_w * rga_get_pixel_stride_from_format(req->win0.format) >
 		     data->max_byte_stride * 8)) {
-		pr_err("invalid win0 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
-		       req->win0.vir_w, rga_get_pixel_stride_from_format(req->win0.format),
-		       data->max_byte_stride);
+		rga_job_err(job, "invalid win0 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
+			req->win0.vir_w, rga_get_pixel_stride_from_format(req->win0.format),
+			data->max_byte_stride);
 		return -EINVAL;
 	}

 	if (unlikely(rga_hw_out_of_range(&(data->output_range),
 					 req->wr.dst_act_w, req->wr.dst_act_h))) {
-		pr_err("invalid wr, [w,h] = [%d, %d]\n", req->wr.dst_act_w, req->wr.dst_act_h);
+		rga_job_err(job, "invalid wr, [w,h] = [%d, %d]\n", req->wr.dst_act_w, req->wr.dst_act_h);
 		return -EINVAL;
 	}

 	if (unlikely(req->wr.vir_w * rga_get_pixel_stride_from_format(req->wr.format) >
 		     data->max_byte_stride * 8)) {
-		pr_err("invalid wr stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
-		       req->wr.vir_w, rga_get_pixel_stride_from_format(req->wr.format),
-		       data->max_byte_stride);
+		rga_job_err(job, "invalid wr stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
+			req->wr.vir_w, rga_get_pixel_stride_from_format(req->wr.format),
+			data->max_byte_stride);
 		return -EINVAL;
 	}

@@ -1873,18 +1874,18 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
 			     rga_hw_out_of_range(&(data->input_range),
 						 req->win1.src_act_w + req->win1.x_offset,
 						 req->win1.src_act_h + req->win1.y_offset))) {
-			pr_err("invalid win1, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
-			       req->win1.src_act_w, req->win1.src_act_h,
-			       req->win1.dst_act_w, req->win1.dst_act_h,
-			       req->win1.x_offset, req->win1.y_offset);
+			rga_job_err(job, "invalid win1, src[w,h] = [%d, %d], dst[w,h] = [%d, %d], off[x,y] = [%d,%d]\n",
+				req->win1.src_act_w, req->win1.src_act_h,
+				req->win1.dst_act_w, req->win1.dst_act_h,
+				req->win1.x_offset, req->win1.y_offset);
 			return -EINVAL;
 		}

 		if (unlikely(req->win1.vir_w * rga_get_pixel_stride_from_format(req->win1.format) >
 			     data->max_byte_stride * 8)) {
-			pr_err("invalid win1 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
-			       req->win1.vir_w, rga_get_pixel_stride_from_format(req->win1.format),
-			       data->max_byte_stride);
+			rga_job_err(job, "invalid win1 stride, stride = %d, pixel_stride = %d, max_byte_stride = %d\n",
+				req->win1.vir_w, rga_get_pixel_stride_from_format(req->win1.format),
+				data->max_byte_stride);
 			return -EINVAL;
 		}

@@ -1893,99 +1894,99 @@ static int rga3_check_param(const struct rga_hw_data *data, const struct rga3_re
 			/* check win0 dst size > win1 dst size */
 			if (unlikely((req->win1.dst_act_w > req->win0.dst_act_w) ||
 				     (req->win1.dst_act_h > req->win0.dst_act_h))) {
-				pr_err("invalid output param win0[w,h] = [%d, %d], win1[w,h] = [%d, %d]\n",
-				       req->win0.dst_act_w, req->win0.dst_act_h,
-				       req->win1.dst_act_w, req->win1.dst_act_h);
+				rga_job_err(job, "invalid output param win0[w,h] = [%d, %d], win1[w,h] = [%d, %d]\n",
+					req->win0.dst_act_w, req->win0.dst_act_h,
+					req->win1.dst_act_w, req->win1.dst_act_h);
 				return -EINVAL;
 			}
 		}
 	}

-	if (rga3_scale_check(req) < 0)
+	if (rga3_scale_check(job, req) < 0)
 		return -EINVAL;

 	return 0;
 }

-static void print_debug_info(struct rga3_req *req)
+static void print_debug_info(struct rga_job *job, struct rga3_req *req)
 {
-	pr_info("render_mode:%s, bitblit_mode=%d, rotate_mode:%x\n",
+	rga_job_log(job, "render_mode:%s, bitblit_mode=%d, rotate_mode:%x\n",
 		rga_get_render_mode_str(req->render_mode), req->bitblt_mode,
 		req->rotate_mode);
-	pr_info("win0: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
-		 req->win0.yrgb_addr, req->win0.uv_addr, req->win0.v_addr,
-		 req->win0.src_act_w, req->win0.src_act_h);
-	pr_info("win0: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
-		 req->win0.vir_w, req->win0.vir_h,
-		 req->win0.x_offset, req->win0.y_offset,
-		 rga_get_format_name(req->win0.format));
-	pr_info("win0: dst_w = %d, dst_h = %d, rd_mode = %d\n",
-		 req->win0.dst_act_w, req->win0.dst_act_h, req->win0.rd_mode);
-	pr_info("win0: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
-		 req->win0.rotate_mode, req->win0.enable,
-		 req->win0.is_10b_compact, req->win0.is_10b_endian);
+	rga_job_log(job, "win0: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
+		req->win0.yrgb_addr, req->win0.uv_addr, req->win0.v_addr,
+		req->win0.src_act_w, req->win0.src_act_h);
+	rga_job_log(job, "win0: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
+		req->win0.vir_w, req->win0.vir_h,
+		req->win0.x_offset, req->win0.y_offset,
+		rga_get_format_name(req->win0.format));
+	rga_job_log(job, "win0: dst_w = %d, dst_h = %d, rd_mode = %d\n",
+		req->win0.dst_act_w, req->win0.dst_act_h, req->win0.rd_mode);
+	rga_job_log(job, "win0: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
+		req->win0.rotate_mode, req->win0.enable,
+		req->win0.is_10b_compact, req->win0.is_10b_endian);

 	if (req->win1.yrgb_addr != 0 || req->win1.uv_addr != 0
 		|| req->win1.v_addr != 0) {
-		pr_info("win1: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
-			 req->win1.yrgb_addr, req->win1.uv_addr,
-			 req->win1.v_addr, req->win1.src_act_w,
-			 req->win1.src_act_h);
-		pr_info("win1: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
-			 req->win1.vir_w, req->win1.vir_h,
-			 req->win1.x_offset, req->win1.y_offset,
-			 rga_get_format_name(req->win1.format));
-		pr_info("win1: dst_w = %d, dst_h = %d, rd_mode = %d\n",
-			 req->win1.dst_act_w, req->win1.dst_act_h,
-			 req->win1.rd_mode);
-		pr_info("win1: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
-			 req->win1.rotate_mode, req->win1.enable,
-			 req->win1.is_10b_compact, req->win1.is_10b_endian);
+		rga_job_log(job, "win1: y = %lx uv = %lx v = %lx src_w = %d src_h = %d\n",
+			req->win1.yrgb_addr, req->win1.uv_addr,
+			req->win1.v_addr, req->win1.src_act_w,
+			req->win1.src_act_h);
+		rga_job_log(job, "win1: vw = %d vh = %d xoff = %d yoff = %d format = %s\n",
+			req->win1.vir_w, req->win1.vir_h,
+			req->win1.x_offset, req->win1.y_offset,
+			rga_get_format_name(req->win1.format));
+		rga_job_log(job, "win1: dst_w = %d, dst_h = %d, rd_mode = %d\n",
+			req->win1.dst_act_w, req->win1.dst_act_h,
+			req->win1.rd_mode);
+		rga_job_log(job, "win1: rot_mode = %d, en = %d, compact = %d, endian = %d\n",
+			req->win1.rotate_mode, req->win1.enable,
+			req->win1.is_10b_compact, req->win1.is_10b_endian);
 	}

-	pr_info("wr: y = %lx uv = %lx v = %lx vw = %d vh = %d\n",
-		 req->wr.yrgb_addr, req->wr.uv_addr, req->wr.v_addr,
-		 req->wr.vir_w, req->wr.vir_h);
-	pr_info("wr: ovlp_xoff = %d ovlp_yoff = %d format = %s rdmode = %d\n",
-		 req->wr.x_offset, req->wr.y_offset,
-		 rga_get_format_name(req->wr.format), req->wr.rd_mode);
+	rga_job_log(job, "wr: y = %lx uv = %lx v = %lx vw = %d vh = %d\n",
+		req->wr.yrgb_addr, req->wr.uv_addr, req->wr.v_addr,
+		req->wr.vir_w, req->wr.vir_h);
+	rga_job_log(job, "wr: ovlp_xoff = %d ovlp_yoff = %d format = %s rdmode = %d\n",
+		req->wr.x_offset, req->wr.y_offset,
+		rga_get_format_name(req->wr.format), req->wr.rd_mode);

-	pr_info("mmu: win0 = %.2x win1 = %.2x wr = %.2x\n",
+	rga_job_log(job, "mmu: win0 = %.2x win1 = %.2x wr = %.2x\n",
 		req->mmu_info.src0_mmu_flag, req->mmu_info.src1_mmu_flag,
 		req->mmu_info.dst_mmu_flag);
-	pr_info("alpha: flag %x mode=%s\n",
+	rga_job_log(job, "alpha: flag %x mode=%s\n",
 		req->alpha_rop_flag, rga_get_blend_mode_str(req->alpha_config.mode));
-	pr_info("alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
+	rga_job_log(job, "alpha: pre_multi=[%d,%d] pixl=[%d,%d] glb=[%d,%d]\n",
 		req->alpha_config.fg_pre_multiplied, req->alpha_config.bg_pre_multiplied,
 		req->alpha_config.fg_pixel_alpha_en, req->alpha_config.bg_pixel_alpha_en,
 		req->alpha_config.fg_global_alpha_en, req->alpha_config.bg_global_alpha_en);
-	pr_info("alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
+	rga_job_log(job, "alpha: fg_global_alpha=%x bg_global_alpha=%x\n",
 		req->alpha_config.fg_global_alpha_value, req->alpha_config.bg_global_alpha_value);
-	pr_info("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
+	rga_job_log(job, "yuv2rgb mode is %x\n", req->yuv2rgb_mode);
 }

-static int rga3_align_check(struct rga3_req *req)
+static int rga3_align_check(struct rga_job *job, struct rga3_req *req)
 {
 	if (rga_is_yuv10bit_format(req->win0.format))
 		if ((req->win0.vir_w % 64) || (req->win0.x_offset % 4) ||
 			(req->win0.src_act_w % 4) || (req->win0.y_offset % 4) ||
 			(req->win0.src_act_h % 4) || (req->win0.vir_h % 2))
-			pr_info("yuv10bit err win0 wstride is not align\n");
+			rga_job_log(job, "yuv10bit err win0 wstride is not align\n");
 	if (rga_is_yuv10bit_format(req->win1.format))
 		if ((req->win1.vir_w % 64) || (req->win1.x_offset % 4) ||
 			(req->win1.src_act_w % 4) || (req->win1.y_offset % 4) ||
 			(req->win1.src_act_h % 4) || (req->win1.vir_h % 2))
-			pr_info("yuv10bit err win1 wstride is not align\n");
+			rga_job_log(job, "yuv10bit err win1 wstride is not align\n");
 	if (rga_is_yuv8bit_format(req->win0.format))
 		if ((req->win0.vir_w % 16) || (req->win0.x_offset % 2) ||
 			(req->win0.src_act_w % 2) || (req->win0.y_offset % 2) ||
 			(req->win0.src_act_h % 2) || (req->win0.vir_h % 2))
-			pr_info("yuv8bit err win0 wstride is not align\n");
+			rga_job_log(job, "yuv8bit err win0 wstride is not align\n");
 	if (rga_is_yuv8bit_format(req->win1.format))
 		if ((req->win1.vir_w % 16) || (req->win1.x_offset % 2) ||
 			(req->win1.src_act_w % 2) || (req->win1.y_offset % 2) ||
 			(req->win1.src_act_h % 2) || (req->win1.vir_h % 2))
-			pr_info("yuv8bit err win1 wstride is not align\n");
+			rga_job_log(job, "yuv8bit err win1 wstride is not align\n");
 	return 0;
 }

@@ -1998,7 +1999,7 @@ static int rga3_init_reg(struct rga_job *job)

 	scheduler = job->scheduler;
 	if (unlikely(scheduler == NULL)) {
-		pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
+		rga_job_err(job, "failed to get scheduler, %s(%d)\n", __func__, __LINE__);
 		return -EINVAL;
 	}

@@ -2007,31 +2008,31 @@ static int rga3_init_reg(struct rga_job *job)
 	rga_cmd_to_rga3_cmd(&job->rga_command_base, &req);

 	/* check value if legal */
-	ret = rga3_check_param(scheduler->data, &req);
+	ret = rga3_check_param(job, scheduler->data, &req);
 	if (ret == -EINVAL) {
-		pr_err("req argument is inval\n");
+		rga_job_err(job, "req argument is inval\n");
 		return ret;
 	}

-	rga3_align_check(&req);
+	rga3_align_check(job, &req);

 	/* for debug */
 	if (DEBUGGER_EN(MSG))
-		print_debug_info(&req);
+		print_debug_info(job, &req);

 	if (rga3_gen_reg_info((uint8_t *) job->cmd_buf->vaddr, &req) == -1) {
-		pr_err("RKA: gen reg info error\n");
+		rga_job_err(job, "RKA: gen reg info error\n");
 		return -EINVAL;
 	}

 	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], generate register cost time %lld us\n",
-			job->request_id, ktime_us_delta(ktime_get(), timestamp));
+		rga_job_log(job, "generate register cost time %lld us\n",
+			ktime_us_delta(ktime_get(), timestamp));

 	return ret;
 }

-static void rga3_dump_read_back_reg(struct rga_scheduler_t *scheduler)
+static void rga3_dump_read_back_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	int i;
 	unsigned long flags;
@@ -2044,9 +2045,9 @@ static void rga3_dump_read_back_reg(struct rga_scheduler_t *scheduler)

 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);

-	pr_info("CMD_READ_BACK_REG\n");
+	rga_job_log(job, "CMD_READ_BACK_REG\n");
 	for (i = 0; i < 12; i++)
-		pr_info("i = %x : %.8x %.8x %.8x %.8x\n", i,
+		rga_job_log(job, "i = %x : %.8x %.8x %.8x %.8x\n", i,
 			cmd_reg[0 + i * 4], cmd_reg[1 + i * 4],
 			cmd_reg[2 + i * 4], cmd_reg[3 + i * 4]);
 }
@@ -2071,9 +2072,9 @@ static int rga3_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 		master_mode_en = false;

 	if (DEBUGGER_EN(REG)) {
-		pr_info("CMD_REG\n");
+		rga_job_log(job, "CMD_REG\n");
 		for (i = 0; i < 12; i++)
-			pr_info("i = %x : %.8x %.8x %.8x %.8x\n", i,
+			rga_job_log(job, "i = %x : %.8x %.8x %.8x %.8x\n", i,
 				cmd[0 + i * 4], cmd[1 + i * 4],
 				cmd[2 + i * 4], cmd[3 + i * 4]);
 	}
@@ -2100,25 +2101,26 @@ static int rga3_set_reg(struct rga_job *job, struct rga_scheduler_t *scheduler)
 	}

 	if (DEBUGGER_EN(REG)) {
-		pr_info("sys_ctrl = 0x%x, int_en = 0x%x, int_raw = 0x%x\n",
+		rga_job_log(job, "sys_ctrl = 0x%x, int_en = 0x%x, int_raw = 0x%x\n",
 			rga_read(RGA3_SYS_CTRL, scheduler),
 			rga_read(RGA3_INT_EN, scheduler),
 			rga_read(RGA3_INT_RAW, scheduler));

-		pr_info("hw_status = 0x%x, cmd_status = 0x%x\n",
+		rga_job_log(job, "hw_status = 0x%x, cmd_status = 0x%x\n",
 			rga_read(RGA3_STATUS0, scheduler),
 			rga_read(RGA3_CMD_STATE, scheduler));
 	}

 	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], set register cost time %lld us\n",
-			job->request_id, ktime_us_delta(now, job->timestamp));
+		rga_job_log(job, "set register cost time %lld us\n",
+			ktime_us_delta(ktime_get(), now));

-	job->hw_running_time = now;
-	job->hw_recoder_time = now;
+	job->timestamp.hw_execute = now;
+	job->timestamp.hw_recode = now;
+	job->session->last_active = now;

 	if (DEBUGGER_EN(REG))
-		rga3_dump_read_back_reg(scheduler);
+		rga3_dump_read_back_reg(job, scheduler);

 	return 0;
 }
@@ -2129,7 +2131,7 @@ static int rga3_get_version(struct rga_scheduler_t *scheduler)
 	u32 reg_version;

 	if (!scheduler) {
-		pr_err("scheduler is null\n");
+		rga_err("scheduler is null\n");
 		return -EINVAL;
 	}

@@ -2164,7 +2166,7 @@ static int rga3_irq(struct rga_scheduler_t *scheduler)
 	job->cmd_status = rga_read(RGA3_CMD_STATE, scheduler);

 	if (DEBUGGER_EN(INT_FLAG))
-		pr_info("irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
+		rga_job_log(job, "irq handler, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
 			job->intr_status, job->hw_status, job->cmd_status);

 	if (job->intr_status & (m_RGA3_INT_FRM_DONE | m_RGA3_INT_CMD_LINE_FINISH)) {
@@ -2172,7 +2174,7 @@ static int rga3_irq(struct rga_scheduler_t *scheduler)
 	} else if (job->intr_status & m_RGA3_INT_ERROR_MASK) {
 		set_bit(RGA_JOB_STATE_INTR_ERR, &job->state);

-		pr_err("irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
+		rga_job_err(job, "irq handler err! INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
 		       job->intr_status, job->hw_status, job->cmd_status);
 		scheduler->ops->soft_reset(scheduler);
 	}
@@ -2187,28 +2189,28 @@ static int rga3_irq(struct rga_scheduler_t *scheduler)
 static int rga3_isr_thread(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	if (DEBUGGER_EN(INT_FLAG))
-		pr_info("isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
+		rga_job_log(job, "isr thread, INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x]\n",
 			rga_read(RGA3_INT_RAW, scheduler),
 			rga_read(RGA3_STATUS0, scheduler),
 			rga_read(RGA3_CMD_STATE, scheduler));

 	if (test_bit(RGA_JOB_STATE_INTR_ERR, &job->state)) {
 		if (job->intr_status & m_RGA3_INT_RAG_MI_RD_BUS_ERR) {
-			pr_err("DMA read bus error, please check size of the input_buffer or whether the buffer has been freed.\n");
+			rga_job_err(job, "DMA read bus error, please check size of the input_buffer or whether the buffer has been freed.\n");
 			job->ret = -EFAULT;
 		} else if (job->intr_status & m_RGA3_INT_WIN0_FBCD_DEC_ERR) {
-			pr_err("win0 FBC decoder error, please check the fbc image of the source.\n");
+			rga_job_err(job, "win0 FBC decoder error, please check the fbc image of the source.\n");
 			job->ret = -EFAULT;
 		} else if (job->intr_status & m_RGA3_INT_WIN1_FBCD_DEC_ERR) {
-			pr_err("win1 FBC decoder error, please check the fbc image of the source.\n");
+			rga_job_err(job, "win1 FBC decoder error, please check the fbc image of the source.\n");
 			job->ret = -EFAULT;
 		} else if (job->intr_status & m_RGA3_INT_RGA_MI_WR_BUS_ERR) {
-			pr_err("wr buss error, please check size of the output_buffer or whether the buffer has been freed.\n");
+			rga_job_err(job, "wr buss error, please check size of the output_buffer or whether the buffer has been freed.\n");
 			job->ret = -EFAULT;
 		}

 		if (job->ret == 0) {
-			pr_err("rga intr error[0x%x]!\n", job->intr_status);
+			rga_job_err(job, "rga intr error[0x%x]!\n", job->intr_status);
 			job->ret = -EFAULT;
 		}
 	}
--- a/drivers/video/rockchip/rga3/rga_common.c
+++ b/drivers/video/rockchip/rga3/rga_common.c
@@ -5,8 +5,6 @@
 * Author: Cerf Yu <cerf.yu@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_common: " fmt
-
 #include "rga.h"
 #include "rga_common.h"

@@ -436,7 +434,7 @@ int rga_get_format_bits(uint32_t format)
 		bits = 1;
 		break;
 	default:
-		pr_err("unknown format [0x%x]\n", format);
+		rga_err("unknown format [0x%x]\n", format);
 		return -1;
 	}

@@ -511,7 +509,7 @@ int rga_get_pixel_stride_from_format(uint32_t format)
 		pixel_stride = 4;
 		break;
 	default:
-		pr_err("unknown format [0x%x]\n", format);
+		rga_err("unknown format [0x%x]\n", format);
 		return -1;
 	}

@@ -536,6 +534,42 @@ const char *rga_get_render_mode_str(uint8_t mode)
 	}
 }

+const char *rga_get_store_mode_str(uint32_t mode)
+{
+	switch (mode) {
+	case RGA_RASTER_MODE:
+		return "raster";
+	case RGA_FBC_MODE:
+		return "afbc16x16";
+	case RGA_TILE_MODE:
+		return "tile8x8";
+	case RGA_TILE4x4_MODE:
+		return "tile4x4";
+	case RGA_RKFBC_MODE:
+		return "rkfbc64x4";
+	case RGA_AFBC32x8_MODE:
+		return "afbc32x8";
+	default:
+		return "unknown";
+	}
+}
+
+const char *rga_get_interp_str(uint8_t interp)
+{
+	switch (interp) {
+	case RGA_INTERP_DEFAULT:
+		return "default";
+	case RGA_INTERP_LINEAR:
+		return "bi-linear";
+	case RGA_INTERP_BICUBIC:
+		return "bi-cubic";
+	case RGA_INTERP_AVERAGE:
+		return "average_filter";
+	default:
+		return "unknown";
+	}
+}
+
 const char *rga_get_rotate_mode_str(uint8_t mode)
 {
 	switch (mode) {
@@ -798,7 +832,7 @@ int rga_image_size_cal(int w, int h, int format,
 		yrgb = (w * h) >> 1;
 		break;
 	default:
-		pr_err("Unsuport format [0x%x]\n", format);
+		rga_err("Unsuport format [0x%x]\n", format);
 		return -EFAULT;
 	}

@@ -814,14 +848,80 @@ int rga_image_size_cal(int w, int h, int format,

 void rga_dump_memory_parm(struct rga_memory_parm *parm)
 {
-	pr_info("memory param: w = %d, h = %d, f = %s(0x%x), size = %d\n",
+	rga_log("memory param: w = %d, h = %d, f = %s(0x%x), size = %d\n",
 		parm->width, parm->height, rga_get_format_name(parm->format),
 		parm->format, parm->size);
 }

 void rga_dump_external_buffer(struct rga_external_buffer *buffer)
 {
-	pr_info("external: memory = 0x%lx, type = %s\n",
+	rga_log("external: memory = 0x%lx, type = %s\n",
 		(unsigned long)buffer->memory, rga_get_memory_type_str(buffer->type));
 	rga_dump_memory_parm(&buffer->memory_parm);
 }
+
+static void rga_dump_image_info(struct rga_request *request, const char *name,
+				struct rga_img_info_t *img, uint8_t handle_flag, int need_mmu)
+{
+	if (handle_flag) {
+		if (img->uv_addr && img->v_addr)
+			rga_req_log(request, "%s: handle[y,uv,v] = [%ld(%#lx), %ld(%#lx), %ld(%#lx)], mode = %s\n",
+				name,
+				(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
+				(unsigned long)img->uv_addr, (unsigned long)img->uv_addr,
+				(unsigned long)img->v_addr, (unsigned long)img->v_addr,
+				rga_get_store_mode_str(img->rd_mode));
+		else if (img->uv_addr)
+			rga_req_log(request, "%s: handle[y,uv] = [%ld(%#lx), %ld(%#lx)], mode = %s\n",
+				name,
+				(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
+				(unsigned long)img->uv_addr, (unsigned long)img->uv_addr,
+				rga_get_store_mode_str(img->rd_mode));
+		else
+			rga_req_log(request, "%s: handle = %ld(%#lx), mode = %s\n",
+				name,
+				(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
+				rga_get_store_mode_str(img->rd_mode));
+	} else {
+		if (img->yrgb_addr)
+			rga_req_log(request, "%s: fd = %ld(%#lx), mode = %s\n",
+				name,
+				(unsigned long)img->yrgb_addr, (unsigned long)img->yrgb_addr,
+				rga_get_store_mode_str(img->rd_mode));
+		else if (img->uv_addr)
+			rga_req_log(request, "%s: %s = %#lx, mode = %s\n",
+				name,
+				need_mmu ? "virt_addr" : "phys_addr", (unsigned long)img->uv_addr,
+				rga_get_store_mode_str(img->rd_mode));
+	}
+
+	rga_req_log(request, "%s: rect[x,y,w,h] = [%d, %d, %d, %d], stride[w,h] = [%d, %d], format = %s(%#x)\n",
+		name,
+		img->x_offset, img->y_offset, img->act_w, img->act_h, img->vir_w, img->vir_h,
+		rga_get_format_name(img->format), img->format);
+}
+
+void rga_dump_req(struct rga_request *request, struct rga_req *req)
+{
+	rga_req_log(request, "render_mode = %d, bitblit_mode = %d, rotate_mode = %d\n",
+		req->render_mode, req->bsfilter_flag,
+		req->rotate_mode);
+
+	rga_dump_image_info(request, "src", &req->src, req->handle_flag,
+			    (req->mmu_info.mmu_flag >> 8) & 1);
+	if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0 || req->pat.v_addr != 0)
+		rga_dump_image_info(request, "pat", &req->pat, req->handle_flag,
+				    (req->mmu_info.mmu_flag >> 9) & 1);
+	rga_dump_image_info(request, "dst", &req->dst, req->handle_flag,
+			    (req->mmu_info.mmu_flag >> 10) & 1);
+
+	rga_req_log(request, "mmu: mmu_flag = %#x en = %#x\n",
+		req->mmu_info.mmu_flag, req->mmu_info.mmu_en);
+	rga_req_log(request, "alpha: rop_mode = %#x\n", req->alpha_rop_mode);
+	rga_req_log(request, "csc = %#x\n", req->yuv2rgb_mode);
+	rga_req_log(request, "imterplotion: horiz = %s(%#x), verti = %s(%#x)\n",
+		rga_get_interp_str(req->interp.horiz), req->interp.horiz,
+		rga_get_interp_str(req->interp.verti), req->interp.verti);
+	rga_req_log(request, "core_mask = %#x, priority = %d, in_fence = %d(%#x)\n",
+		req->core, req->priority, req->in_fence_fd, req->in_fence_fd);
+}
--- a/drivers/video/rockchip/rga3/rga_debugger.c
+++ b/drivers/video/rockchip/rga3/rga_debugger.c
@@ -7,8 +7,6 @@
 *	Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_debugger: " fmt
-
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/syscalls.h>
@@ -192,11 +190,12 @@ static int rga_load_show(struct seq_file *m, void *data)
 	int i;
 	int load;
 	u32 busy_time_total;
+	ktime_t now;

 	session_manager = rga_drvdata->session_manager;

 	seq_printf(m, "num of scheduler = %d\n", rga_drvdata->num_of_scheduler);
-	seq_printf(m, "================= load ==================\n");
+	seq_puts(m, "================= load ==================\n");

 	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
 		scheduler = rga_drvdata->scheduler[i];
@@ -215,13 +214,20 @@ static int rga_load_show(struct seq_file *m, void *data)
 			load = 100;

 		seq_printf(m, "\t load = %d%%\n", load);
-		seq_printf(m, "-----------------------------------\n");
+		seq_puts(m, "-----------------------------------\n");
 	}

+	seq_puts(m, "=========================================\n");
+	seq_puts(m, "<session>  <status>  <tgid>  <process>\n");
+
 	mutex_lock(&session_manager->lock);

+	now = ktime_get();
 	idr_for_each_entry(&session_manager->ctx_id_idr, session, id)
-		seq_printf(m, "\t process %d: pid = %d, name: %s\n", id,
+		seq_printf(m, "%-9d  %-8s  %-6d  %-s\n",
+			session->id,
+			ktime_us_delta(now, session->last_active) < RGA_LOAD_ACTIVE_MAX_US ?
+				"active" : "idle",
 			session->tgid, session->pname);

 	mutex_unlock(&session_manager->lock);
@@ -857,54 +863,6 @@ void rga_request_task_debug_info(struct seq_file *m, struct rga_req *req)
 		req->core, req->priority, req->in_fence_fd);
 }

-void rga_cmd_print_debug_info(struct rga_req *req)
-{
-	pr_info("render_mode = %d, bitblit_mode=%d, rotate_mode = %d\n",
-		req->render_mode, req->bsfilter_flag,
-		req->rotate_mode);
-
-	pr_info("src: y = %lx uv = %lx v = %lx aw = %d ah = %d vw = %d vh = %d\n",
-		 (unsigned long)req->src.yrgb_addr,
-		 (unsigned long)req->src.uv_addr,
-		 (unsigned long)req->src.v_addr,
-		 req->src.act_w, req->src.act_h,
-		 req->src.vir_w, req->src.vir_h);
-	pr_info("src: xoff = %d, yoff = %d, format = 0x%x, rd_mode = %d\n",
-		req->src.x_offset, req->src.y_offset,
-		 req->src.format, req->src.rd_mode);
-
-	if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0
-		|| req->pat.v_addr != 0) {
-		pr_info("pat: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
-			 (unsigned long)req->pat.yrgb_addr,
-			 (unsigned long)req->pat.uv_addr,
-			 (unsigned long)req->pat.v_addr,
-			 req->pat.act_w, req->pat.act_h,
-			 req->pat.vir_w, req->pat.vir_h);
-		pr_info("pat: xoff = %d yoff = %d, format = 0x%x, rd_mode = %d\n",
-			req->pat.x_offset, req->pat.y_offset,
-			req->pat.format, req->pat.rd_mode);
-	}
-
-	pr_info("dst: y=%lx uv=%lx v=%lx aw=%d ah=%d vw=%d vh=%d\n",
-		 (unsigned long)req->dst.yrgb_addr,
-		 (unsigned long)req->dst.uv_addr,
-		 (unsigned long)req->dst.v_addr,
-		 req->dst.act_w, req->dst.act_h,
-		 req->dst.vir_w, req->dst.vir_h);
-	pr_info("dst: xoff = %d, yoff = %d, format = 0x%x, rd_mode = %d\n",
-		req->dst.x_offset, req->dst.y_offset,
-		req->dst.format, req->dst.rd_mode);
-
-	pr_info("mmu: mmu_flag=%x en=%x\n",
-		req->mmu_info.mmu_flag, req->mmu_info.mmu_en);
-	pr_info("alpha: rop_mode = %x\n", req->alpha_rop_mode);
-	pr_info("yuv2rgb mode is %x\n", req->yuv2rgb_mode);
-	pr_info("imterplotion: horiz = 0x%x, verti = 0x%x\n", req->interp.horiz, req->interp.verti);
-	pr_info("set core = %d, priority = %d, in_fence_fd = %d\n",
-		req->core, req->priority, req->in_fence_fd);
-}
-
 #ifdef CONFIG_NO_GKI
 static int rga_dump_image_to_file(struct rga_internal_buffer *dump_buffer,
 				  const char *channel_name,
--- a/drivers/video/rockchip/rga3/rga_dma_buf.c
+++ b/drivers/video/rockchip/rga3/rga_dma_buf.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_dma_buf: " fmt
-
 #include "rga_dma_buf.h"
 #include "rga.h"
 #include "rga_common.h"
@@ -281,7 +279,7 @@ int rga_iommu_map_sgt(struct sg_table *sgt, size_t size,
 	unsigned long align_size;

 	if (sgt == NULL) {
-		pr_err("can not map iommu, because sgt is null!\n");
+		rga_err("can not map iommu, because sgt is null!\n");
 		return -EINVAL;
 	}

@@ -291,18 +289,18 @@ int rga_iommu_map_sgt(struct sg_table *sgt, size_t size,
 	align_size = iova_align(iovad, size);

 	if (DEBUGGER_EN(MSG))
-		pr_info("iova_align size = %ld", align_size);
+		rga_log("iova_align size = %ld", align_size);

 	iova = rga_iommu_dma_alloc_iova(domain, align_size, rga_dev->coherent_dma_mask, rga_dev);
 	if (!iova) {
-		pr_err("rga_iommu_dma_alloc_iova failed");
+		rga_err("rga_iommu_dma_alloc_iova failed");
 		return -ENOMEM;
 	}

 	map_size = iommu_map_sg(domain, iova, sgt->sgl, sgt->orig_nents,
 				rga_dma_info_to_prot(DMA_BIDIRECTIONAL));
 	if (map_size < align_size) {
-		pr_err("iommu can not map sgt to iova");
+		rga_err("iommu can not map sgt to iova");
 		rga_iommu_dma_free_iova(domain, iova, align_size);
 		return -EINVAL;
 	}
@@ -326,7 +324,7 @@ int rga_iommu_map(phys_addr_t paddr, size_t size,
 	unsigned long align_size;

 	if (paddr == 0) {
-		pr_err("can not map iommu, because phys_addr is 0!\n");
+		rga_err("can not map iommu, because phys_addr is 0!\n");
 		return -EINVAL;
 	}

@@ -336,18 +334,18 @@ int rga_iommu_map(phys_addr_t paddr, size_t size,
 	align_size = iova_align(iovad, size);

 	if (DEBUGGER_EN(MSG))
-		pr_info("iova_align size = %ld", align_size);
+		rga_log("iova_align size = %ld", align_size);

 	iova = rga_iommu_dma_alloc_iova(domain, align_size, rga_dev->coherent_dma_mask, rga_dev);
 	if (!iova) {
-		pr_err("rga_iommu_dma_alloc_iova failed");
+		rga_err("rga_iommu_dma_alloc_iova failed");
 		return -ENOMEM;
 	}

 	ret = iommu_map(domain, iova, paddr, align_size,
 			rga_dma_info_to_prot(DMA_BIDIRECTIONAL));
 	if (ret) {
-		pr_err("iommu can not map phys_addr to iova");
+		rga_err("iommu can not map phys_addr to iova");
 		rga_iommu_dma_free_iova(domain, iova, align_size);
 		return ret;
 	}
@@ -371,20 +369,20 @@ int rga_virtual_memory_check(void *vaddr, u32 w, u32 h, u32 format, int fd)

 	one_line = kzalloc(w * 4, GFP_KERNEL);
 	if (!one_line) {
-		pr_err("kzalloc fail %s[%d]\n", __func__, __LINE__);
+		rga_err("kzalloc fail %s[%d]\n", __func__, __LINE__);
 		return 0;
 	}

 	temp_data = w * (h - 1) * bits >> 3;
 	if (fd > 0) {
-		pr_info("vaddr is%p, bits is %d, fd check\n", vaddr, bits);
+		rga_log("vaddr is%p, bits is %d, fd check\n", vaddr, bits);
 		memcpy(one_line, (char *)vaddr + temp_data, w * bits >> 3);
-		pr_info("fd check ok\n");
+		rga_log("fd check ok\n");
 	} else {
-		pr_info("vir addr memory check.\n");
+		rga_log("vir addr memory check.\n");
 		memcpy((void *)((char *)vaddr + temp_data), one_line,
 			 w * bits >> 3);
-		pr_info("vir addr check ok.\n");
+		rga_log("vir addr check ok.\n");
 	}

 	kfree(one_line);
@@ -413,7 +411,7 @@ int rga_dma_memory_check(struct rga_dma_buffer *rga_dma_buffer, struct rga_img_i
 			ret = rga_virtual_memory_check(vaddr, img->vir_w,
 				img->vir_h, img->format, img->yrgb_addr);
 		} else {
-			pr_err("can't vmap the dma buffer!\n");
+			rga_err("can't vmap the dma buffer!\n");
 			return -EINVAL;
 		}
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
@@ -437,21 +435,21 @@ int rga_dma_map_buf(struct dma_buf *dma_buf, struct rga_dma_buffer *rga_dma_buff
 	if (dma_buf != NULL) {
 		get_dma_buf(dma_buf);
 	} else {
-		pr_err("dma_buf is invalid[%p]\n", dma_buf);
+		rga_err("dma_buf is invalid[%p]\n", dma_buf);
 		return -EINVAL;
 	}

 	attach = dma_buf_attach(dma_buf, rga_dev);
 	if (IS_ERR(attach)) {
 		ret = PTR_ERR(attach);
-		pr_err("Failed to attach dma_buf, ret[%d]\n", ret);
+		rga_err("Failed to attach dma_buf, ret[%d]\n", ret);
 		goto err_get_attach;
 	}

 	sgt = dma_buf_map_attachment(attach, dir);
 	if (IS_ERR(sgt)) {
 		ret = PTR_ERR(sgt);
-		pr_err("Failed to map attachment, ret[%d]\n", ret);
+		rga_err("Failed to map attachment, ret[%d]\n", ret);
 		goto err_get_sgt;
 	}

@@ -488,21 +486,21 @@ int rga_dma_map_fd(int fd, struct rga_dma_buffer *rga_dma_buffer,
 	dma_buf = dma_buf_get(fd);
 	if (IS_ERR(dma_buf)) {
 		ret = PTR_ERR(dma_buf);
-		pr_err("Fail to get dma_buf from fd[%d], ret[%d]\n", fd, ret);
+		rga_err("Fail to get dma_buf from fd[%d], ret[%d]\n", fd, ret);
 		return ret;
 	}

 	attach = dma_buf_attach(dma_buf, rga_dev);
 	if (IS_ERR(attach)) {
 		ret = PTR_ERR(attach);
-		pr_err("Failed to attach dma_buf, ret[%d]\n", ret);
+		rga_err("Failed to attach dma_buf, ret[%d]\n", ret);
 		goto err_get_attach;
 	}

 	sgt = dma_buf_map_attachment(attach, dir);
 	if (IS_ERR(sgt)) {
 		ret = PTR_ERR(sgt);
-		pr_err("Failed to map attachment, ret[%d]\n", ret);
+		rga_err("Failed to map attachment, ret[%d]\n", ret);
 		goto err_get_sgt;
 	}

@@ -549,7 +547,7 @@ void rga_dma_sync_flush_range(void *pstart, void *pend, struct rga_scheduler_t *
 int rga_dma_free(struct rga_dma_buffer *buffer)
 {
 	if (buffer == NULL) {
-		pr_err("rga_dma_buffer is NULL.\n");
+		rga_err("rga_dma_buffer is NULL.\n");
 		return -EINVAL;
 	}

--- a/drivers/video/rockchip/rga3/rga_drv.c
+++ b/drivers/video/rockchip/rga3/rga_drv.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga: " fmt
-
 #include "rga2_reg_info.h"
 #include "rga3_reg_info.h"
 #include "rga_dma_buf.h"
@@ -44,7 +42,7 @@ static int rga_mpi_set_channel_buffer(struct dma_buf *dma_buf,

 	buffer.handle = rga_mm_import_buffer(&buffer, session);
 	if (buffer.handle == 0) {
-		pr_err("can not import dma_buf %p\n", dma_buf);
+		rga_err("can not import dma_buf %p\n", dma_buf);
 		return -EFAULT;
 	}
 	channel_info->yrgb_addr = buffer.handle;
@@ -115,14 +113,14 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
 	mutex_lock(&request_manager->lock);
 	request = rga_request_lookup(request_manager, mpi_job->ctx_id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find request from id[%d]", mpi_job->ctx_id);
+		rga_err("can not find request from id[%d]", mpi_job->ctx_id);
 		mutex_unlock(&request_manager->lock);
 		return -EINVAL;
 	}

 	if (request->task_count > 1) {
 		/* TODO */
-		pr_err("Currently request does not support multiple tasks!");
+		rga_req_err(request, "Currently request does not support multiple tasks!");
 		mutex_unlock(&request_manager->lock);
 		return -EINVAL;
 	}
@@ -168,7 +166,7 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
 						 &mpi_cmd.src,
 						 request->session);
 		if (ret < 0) {
-			pr_err("src channel set buffer handle failed!\n");
+			rga_req_err(request, "src channel set buffer handle failed!\n");
 			goto err_put_request;
 		}
 	}
@@ -178,7 +176,7 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
 						 &mpi_cmd.pat,
 						 request->session);
 		if (ret < 0) {
-			pr_err("src1 channel set buffer handle failed!\n");
+			rga_req_err(request, "src1 channel set buffer handle failed!\n");
 			goto err_put_request;
 		}
 	}
@@ -188,7 +186,7 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
 						 &mpi_cmd.dst,
 						 request->session);
 		if (ret < 0) {
-			pr_err("dst channel set buffer handle failed!\n");
+			rga_req_err(request, "dst channel set buffer handle failed!\n");
 			goto err_put_request;
 		}
 	}
@@ -198,16 +196,16 @@ int rga_mpi_commit(struct rga_mpi_job_t *mpi_job)
 	mpi_cmd.mmu_info.mmu_flag = 0;

 	if (DEBUGGER_EN(MSG))
-		rga_cmd_print_debug_info(&mpi_cmd);
+		rga_dump_req(request, &mpi_cmd);

 	ret = rga_request_mpi_submit(&mpi_cmd, request);
 	if (ret < 0) {
 		if (ret == -ERESTARTSYS) {
 			if (DEBUGGER_EN(MSG))
-				pr_err("%s, commit mpi job failed, by a software interrupt.\n",
+				rga_req_err(request, "%s, commit mpi job failed, by a software interrupt.\n",
 					__func__);
 		} else {
-			pr_err("%s, commit mpi job failed\n", __func__);
+			rga_req_err(request, "%s, commit mpi job failed\n", __func__);
 		}

 		goto err_put_request;
@@ -256,7 +254,7 @@ int rga_kernel_commit(struct rga_req *cmd)

 	request_id = rga_request_alloc(0, session);
 	if (request_id < 0) {
-		pr_err("request alloc error!\n");
+		rga_err("request alloc error!\n");
 		ret = request_id;
 		return ret;
 	}
@@ -269,25 +267,25 @@ int rga_kernel_commit(struct rga_req *cmd)

 	ret = rga_request_check(&kernel_request);
 	if (ret < 0) {
-		pr_err("user request check error!\n");
+		rga_err("ID[%d]: user request check error!\n", kernel_request.id);
 		goto err_free_request_by_id;
 	}

 	request = rga_request_kernel_config(&kernel_request);
 	if (IS_ERR(request)) {
-		pr_err("request[%d] config failed!\n", kernel_request.id);
+		rga_err("ID[%d]: config failed!\n", kernel_request.id);
 		ret = -EFAULT;
 		goto err_free_request_by_id;
 	}

 	if (DEBUGGER_EN(MSG)) {
-		pr_info("kernel blit mode: request id = %d", kernel_request.id);
-		rga_cmd_print_debug_info(cmd);
+		rga_req_log(request, "kernel blit mode:\n");
+		rga_dump_req(request, cmd);
 	}

 	ret = rga_request_submit(request);
 	if (ret < 0) {
-		pr_err("request[%d] submit failed!\n", kernel_request.id);
+		rga_req_err(request, "submit failed!\n");
 		goto err_put_request;
 	}

@@ -305,7 +303,7 @@ err_free_request_by_id:

 	request = rga_request_lookup(request_manager, request_id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find request from id[%d]", request_id);
+		rga_err("can not find request from id[%d]", request_id);
 		mutex_unlock(&request_manager->lock);
 		return -EINVAL;
 	}
@@ -336,8 +334,8 @@ static enum hrtimer_restart hrtimer_handler(struct hrtimer *timer)
 		/* if timer action on job running */
 		job = scheduler->running_job;
 		if (job) {
-			scheduler->timer.busy_time += ktime_us_delta(now, job->hw_recoder_time);
-			job->hw_recoder_time = now;
+			scheduler->timer.busy_time += ktime_us_delta(now, job->timestamp.hw_recode);
+			job->timestamp.hw_recode = now;
 		}

 		scheduler->timer.busy_time_record = scheduler->timer.busy_time;
@@ -434,7 +432,7 @@ static void rga_power_enable_all(void)
 		scheduler = rga_drvdata->scheduler[i];
 		ret = rga_power_enable(scheduler);
 		if (ret < 0)
-			pr_err("power enable failed");
+			rga_err("power enable failed");
 	}
 }

@@ -539,13 +537,13 @@ static struct rga_session *rga_session_init(void)

 	session_manager = rga_drvdata->session_manager;
 	if (session_manager == NULL) {
-		pr_err("rga_session_manager is null!\n");
+		rga_err("rga_session_manager is null!\n");
 		return ERR_PTR(-EFAULT);
 	}

 	session = kzalloc(sizeof(*session), GFP_KERNEL);
 	if (!session) {
-		pr_err("rga_session alloc failed\n");
+		rga_err("rga_session alloc failed\n");
 		return ERR_PTR(-ENOMEM);
 	}

@@ -557,7 +555,7 @@ static struct rga_session *rga_session_init(void)
 	if (new_id < 0) {
 		mutex_unlock(&session_manager->lock);

-		pr_err("rga_session alloc id failed!\n");
+		rga_err("rga_session alloc id failed!\n");
 		kfree(session);
 		return ERR_PTR(new_id);
 	}
@@ -570,6 +568,8 @@ static struct rga_session *rga_session_init(void)
 	session->tgid = current->tgid;
 	session->pname = kstrdup_quotable_cmdline(current, GFP_KERNEL);

+	session->last_active = ktime_get();
+
 	return session;
 }

@@ -596,32 +596,32 @@ static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *sessi
 	if (unlikely(copy_from_user(&buffer_pool,
 				    (struct rga_buffer_pool *)arg,
 				    sizeof(buffer_pool)))) {
-		pr_err("rga_buffer_pool copy_from_user failed!\n");
+		rga_err("rga_buffer_pool copy_from_user failed!\n");
 		return -EFAULT;
 	}

 	if (buffer_pool.size > RGA_BUFFER_POOL_SIZE_MAX) {
-		pr_err("Cannot import more than %d buffers at a time!\n",
+		rga_err("Cannot import more than %d buffers at a time!\n",
 		       RGA_BUFFER_POOL_SIZE_MAX);
 		return -EFBIG;
 	}

 	if (buffer_pool.buffers_ptr == 0) {
-		pr_err("Import buffers is NULL!\n");
+		rga_err("Import buffers is NULL!\n");
 		return -EFAULT;
 	}

 	external_buffer = kmalloc(sizeof(struct rga_external_buffer) * buffer_pool.size,
 				  GFP_KERNEL);
 	if (external_buffer == NULL) {
-		pr_err("external buffer list alloc error!\n");
+		rga_err("external buffer list alloc error!\n");
 		return -ENOMEM;
 	}

 	if (unlikely(copy_from_user(external_buffer,
 				    u64_to_user_ptr(buffer_pool.buffers_ptr),
 				    sizeof(struct rga_external_buffer) * buffer_pool.size))) {
-		pr_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
+		rga_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
 		ret = -EFAULT;

 		goto err_free_external_buffer;
@@ -629,13 +629,13 @@ static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *sessi

 	for (i = 0; i < buffer_pool.size; i++) {
 		if (DEBUGGER_EN(MSG)) {
-			pr_info("import buffer info:\n");
+			rga_log("import buffer info:\n");
 			rga_dump_external_buffer(&external_buffer[i]);
 		}

 		ret = rga_mm_import_buffer(&external_buffer[i], session);
 		if (ret <= 0) {
-			pr_err("buffer[%d] mm import buffer failed! memory = 0x%lx, type = %s(0x%x)\n",
+			rga_err("buffer[%d] mm import buffer failed! memory = 0x%lx, type = %s(0x%x)\n",
 			       i, (unsigned long)external_buffer[i].memory,
 			       rga_get_memory_type_str(external_buffer[i].type),
 			       external_buffer[i].type);
@@ -649,7 +649,7 @@ static long rga_ioctl_import_buffer(unsigned long arg, struct rga_session *sessi
 	if (unlikely(copy_to_user(u64_to_user_ptr(buffer_pool.buffers_ptr),
 				  external_buffer,
 				  sizeof(struct rga_external_buffer) * buffer_pool.size))) {
-		pr_err("rga_buffer_pool external_buffer list copy_to_user failed\n");
+		rga_err("rga_buffer_pool external_buffer list copy_to_user failed\n");
 		ret = -EFAULT;

 		goto err_free_external_buffer;
@@ -670,32 +670,32 @@ static long rga_ioctl_release_buffer(unsigned long arg)
 	if (unlikely(copy_from_user(&buffer_pool,
 				    (struct rga_buffer_pool *)arg,
 				    sizeof(buffer_pool)))) {
-		pr_err("rga_buffer_pool  copy_from_user failed!\n");
+		rga_err("rga_buffer_pool  copy_from_user failed!\n");
 		return -EFAULT;
 	}

 	if (buffer_pool.size > RGA_BUFFER_POOL_SIZE_MAX) {
-		pr_err("Cannot release more than %d buffers at a time!\n",
+		rga_err("Cannot release more than %d buffers at a time!\n",
 		       RGA_BUFFER_POOL_SIZE_MAX);
 		return -EFBIG;
 	}

 	if (buffer_pool.buffers_ptr == 0) {
-		pr_err("Release buffers is NULL!\n");
+		rga_err("Release buffers is NULL!\n");
 		return -EFAULT;
 	}

 	external_buffer = kmalloc(sizeof(struct rga_external_buffer) * buffer_pool.size,
 				  GFP_KERNEL);
 	if (external_buffer == NULL) {
-		pr_err("external buffer list alloc error!\n");
+		rga_err("external buffer list alloc error!\n");
 		return -ENOMEM;
 	}

 	if (unlikely(copy_from_user(external_buffer,
 				    u64_to_user_ptr(buffer_pool.buffers_ptr),
 				    sizeof(struct rga_external_buffer) * buffer_pool.size))) {
-		pr_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
+		rga_err("rga_buffer_pool external_buffer list copy_from_user failed\n");
 		ret = -EFAULT;

 		goto err_free_external_buffer;
@@ -703,11 +703,11 @@ static long rga_ioctl_release_buffer(unsigned long arg)

 	for (i = 0; i < buffer_pool.size; i++) {
 		if (DEBUGGER_EN(MSG))
-			pr_info("release buffer handle[%d]\n", external_buffer[i].handle);
+			rga_log("release buffer handle[%d]\n", external_buffer[i].handle);

 		ret = rga_mm_release_buffer(external_buffer[i].handle);
 		if (ret < 0) {
-			pr_err("buffer[%d] mm release buffer failed! handle = %d\n",
+			rga_err("buffer[%d] mm release buffer failed! handle = %d\n",
 			       i, external_buffer[i].handle);

 			goto err_free_external_buffer;
@@ -725,14 +725,14 @@ static long rga_ioctl_request_create(unsigned long arg, struct rga_session *sess
 	uint32_t flags;

 	if (copy_from_user(&flags, (void *)arg, sizeof(uint32_t))) {
-		pr_err("%s failed to copy from usrer!\n", __func__);
+		rga_err("%s failed to copy from user!\n", __func__);
 		return -EFAULT;
 	}

 	id = rga_request_alloc(flags, session);

 	if (copy_to_user((void *)arg, &id, sizeof(uint32_t))) {
-		pr_err("%s failed to copy to usrer!\n", __func__);
+		rga_err("%s failed to copy to user!\n", __func__);
 		return -EFAULT;
 	}

@@ -751,29 +751,29 @@ static long rga_ioctl_request_submit(unsigned long arg, bool run_enbale)
 	if (unlikely(copy_from_user(&user_request,
 				    (struct rga_user_request *)arg,
 				    sizeof(user_request)))) {
-		pr_err("%s copy_from_user failed!\n", __func__);
+		rga_err("%s copy_from_user failed!\n", __func__);
 		return -EFAULT;
 	}

 	ret = rga_request_check(&user_request);
 	if (ret < 0) {
-		pr_err("user request check error!\n");
+		rga_err("user request check error!\n");
 		return ret;
 	}

 	if (DEBUGGER_EN(MSG))
-		pr_info("config request id = %d", user_request.id);
+		rga_log("config request id = %d", user_request.id);

 	request = rga_request_config(&user_request);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("request[%d] config failed!\n", user_request.id);
+		rga_err("request[%d] config failed!\n", user_request.id);
 		return -EFAULT;
 	}

 	if (run_enbale) {
 		ret = rga_request_submit(request);
 		if (ret < 0) {
-			pr_err("request[%d] submit failed!\n", user_request.id);
+			rga_err("request[%d] submit failed!\n", user_request.id);
 			return -EFAULT;
 		}

@@ -781,7 +781,7 @@ static long rga_ioctl_request_submit(unsigned long arg, bool run_enbale)
 			user_request.release_fence_fd = request->release_fence_fd;
 			if (copy_to_user((struct rga_req *)arg,
 					 &user_request, sizeof(user_request))) {
-				pr_err("copy_to_user failed\n");
+				rga_err("copy_to_user failed\n");
 				return -EFAULT;
 			}
 		}
@@ -802,23 +802,23 @@ static long rga_ioctl_request_cancel(unsigned long arg)

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_err("rga_pending_request_manager is null!\n");
 		return -EFAULT;
 	}

 	if (unlikely(copy_from_user(&id, (uint32_t *)arg, sizeof(uint32_t)))) {
-		pr_err("request id copy_from_user failed!\n");
+		rga_err("request id copy_from_user failed!\n");
 		return -EFAULT;
 	}

 	if (DEBUGGER_EN(MSG))
-		pr_info("config cancel request id = %d", id);
+		rga_log("config cancel request id = %d", id);

 	mutex_lock(&request_manager->lock);

 	request = rga_request_lookup(request_manager, id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find request from id[%d]", id);
+		rga_err("can not find request from id[%d]", id);
 		mutex_unlock(&request_manager->lock);
 		return -EINVAL;
 	}
@@ -841,7 +841,7 @@ static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *

 	request_id = rga_request_alloc(0, session);
 	if (request_id < 0) {
-		pr_err("request alloc error!\n");
+		rga_err("request alloc error!\n");
 		ret = request_id;
 		return ret;
 	}
@@ -854,13 +854,13 @@ static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *

 	ret = rga_request_check(&user_request);
 	if (ret < 0) {
-		pr_err("user request check error!\n");
+		rga_err("ID[%d]: user request check error!\n", user_request.id);
 		goto err_free_request_by_id;
 	}

 	request = rga_request_config(&user_request);
 	if (IS_ERR(request)) {
-		pr_err("request[%d] config failed!\n", user_request.id);
+		rga_err("ID[%d]: config failed!\n", user_request.id);
 		ret = -EFAULT;
 		goto err_free_request_by_id;
 	}
@@ -871,14 +871,14 @@ static long rga_ioctl_blit(unsigned long arg, uint32_t cmd, struct rga_session *

 	ret = rga_request_submit(request);
 	if (ret < 0) {
-		pr_err("request[%d] submit failed!\n", user_request.id);
+		rga_req_err(request, "submit failed!\n");
 		goto err_put_request;
 	}

 	if (request->sync_mode == RGA_BLIT_ASYNC) {
 		rga_req->out_fence_fd = request->release_fence_fd;
 		if (copy_to_user((struct rga_req *)arg, rga_req, sizeof(struct rga_req))) {
-			pr_err("copy_to_user failed\n");
+			rga_req_err(request, "copy_to_user failed\n");
 			ret = -EFAULT;
 			goto err_put_request;
 		}
@@ -896,7 +896,7 @@ err_free_request_by_id:

 	request = rga_request_lookup(request_manager, request_id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find request from id[%d]", request_id);
+		rga_err("can not find request from id[%d]", request_id);
 		mutex_unlock(&request_manager->lock);
 		return -EINVAL;
 	}
@@ -920,7 +920,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
 	struct rga_session *session = file->private_data;

 	if (!rga) {
-		pr_err("rga_drvdata is null, rga is not init\n");
+		rga_err("rga_drvdata is null, rga is not init\n");
 		return -ENODEV;
 	}

@@ -1048,7 +1048,7 @@ static long rga_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
 	case RGA_IMPORT_DMA:
 	case RGA_RELEASE_DMA:
 	default:
-		pr_err("unknown ioctl cmd!\n");
+		rga_err("unknown ioctl cmd!\n");
 		ret = -EINVAL;
 		break;
 	}
@@ -1124,6 +1124,8 @@ static irqreturn_t rga_irq_handler(int irq, void *data)
 	irqreturn_t irq_ret = IRQ_NONE;
 	struct rga_scheduler_t *scheduler = data;

+	scheduler->running_job->timestamp.hw_done = ktime_get();
+
 	if (scheduler->ops->irq)
 		irq_ret = scheduler->ops->irq(scheduler);

@@ -1138,7 +1140,7 @@ static irqreturn_t rga_isr_thread(int irq, void *data)

 	job = rga_job_done(scheduler);
 	if (job == NULL) {
-		pr_err("isr thread invalid job!\n");
+		rga_err("isr thread invalid job!\n");
 		return IRQ_HANDLED;
 	}

--- a/drivers/video/rockchip/rga3/rga_fence.c
+++ b/drivers/video/rockchip/rga3/rga_fence.c
@@ -5,14 +5,13 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_fence: " fmt
-
 #include <linux/dma-fence.h>
 #include <linux/sync_file.h>
 #include <linux/slab.h>

 #include "rga_drv.h"
 #include "rga_fence.h"
+#include "rga_common.h"

 static const char *rga_fence_get_name(struct dma_fence *fence)
 {
@@ -57,7 +56,7 @@ struct dma_fence *rga_dma_fence_alloc(void)
 	struct dma_fence *fence = NULL;

 	if (fence_ctx == NULL) {
-		pr_err("fence_context is NULL!\n");
+		rga_err("fence_context is NULL!\n");
 		return ERR_PTR(-EINVAL);
 	}

@@ -100,7 +99,7 @@ struct dma_fence *rga_get_dma_fence_from_fd(int fence_fd)

 	fence = sync_file_get_fence(fence_fd);
 	if (!fence)
-		pr_err("can not get fence from fd\n");
+		rga_err("can not get fence from fd\n");

 	return fence;
 }
@@ -123,7 +122,7 @@ int rga_dma_fence_add_callback(struct dma_fence *fence, dma_fence_func_t func, v

 	waiter = kmalloc(sizeof(*waiter), GFP_KERNEL);
 	if (!waiter) {
-		pr_err("%s: Failed to allocate waiter\n", __func__);
+		rga_err("%s: Failed to allocate waiter\n", __func__);
 		return -ENOMEM;
 	}

@@ -131,10 +130,10 @@ int rga_dma_fence_add_callback(struct dma_fence *fence, dma_fence_func_t func, v

 	ret = dma_fence_add_callback(fence, &waiter->waiter, func);
 	if (ret == -ENOENT) {
-		pr_err("'input fence' has been already signaled.");
+		rga_err("'input fence' has been already signaled.");
 		goto err_free_waiter;
 	} else if (ret == -EINVAL) {
-		pr_err("%s: failed to add callback to dma_fence, err: %d\n", __func__, ret);
+		rga_err("%s: failed to add callback to dma_fence, err: %d\n", __func__, ret);
 		goto err_free_waiter;
 	}

--- a/drivers/video/rockchip/rga3/rga_iommu.c
+++ b/drivers/video/rockchip/rga3/rga_iommu.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_iommu: " fmt
-
 #include "rga_iommu.h"
 #include "rga_dma_buf.h"
 #include "rga_mm.h"
@@ -37,11 +35,11 @@ int rga_user_memory_check(struct page **pages, u32 w, u32 h, u32 format, int fla
 	}

 	if (flag == 1) {
-		pr_info("src user memory check\n");
-		pr_info("tai data is %d\n", *tai_vaddr);
+		rga_log("src user memory check\n");
+		rga_log("tai data is %d\n", *tai_vaddr);
 	} else {
-		pr_info("dst user memory check\n");
-		pr_info("tai data is %d\n", *tai_vaddr);
+		rga_log("dst user memory check\n");
+		rga_log("tai data is %d\n", *tai_vaddr);
 	}

 	if (taidata_num == 0)
@@ -100,14 +98,14 @@ static int rga_mmu_buf_get_try(struct rga_mmu_base *t, uint32_t size)

 	if ((t->back - t->front) > t->size) {
 		if (t->front + size > t->back - t->size) {
-			pr_info("front %d, back %d dsize %d size %d",
+			rga_log("front %d, back %d dsize %d size %d",
 				t->front, t->back, t->size, size);
 			ret = -ENOMEM;
 			goto out;
 		}
 	} else {
 		if ((t->front + size) > t->back) {
-			pr_info("front %d, back %d dsize %d size %d",
+			rga_log("front %d, back %d dsize %d size %d",
 				t->front, t->back, t->size, size);
 			ret = -ENOMEM;
 			goto out;
@@ -115,7 +113,7 @@ static int rga_mmu_buf_get_try(struct rga_mmu_base *t, uint32_t size)

 		if (t->front + size > t->size) {
 			if (size > (t->back - t->size)) {
-				pr_info("front %d, back %d dsize %d size %d",
+				rga_log("front %d, back %d dsize %d size %d",
 					t->front, t->back, t->size, size);
 				ret = -ENOMEM;
 				goto out;
@@ -138,7 +136,7 @@ unsigned int *rga_mmu_buf_get(struct rga_mmu_base *mmu_base, uint32_t size)

 	ret = rga_mmu_buf_get_try(mmu_base, size);
 	if (ret < 0) {
-		pr_err("Get MMU mem failed\n");
+		rga_err("Get MMU mem failed\n");
 		return NULL;
 	}

@@ -242,7 +240,7 @@ static int rga_iommu_intr_fault_handler(struct iommu_domain *iommu, struct devic
 	if (job == NULL)
 		return 0;

-	pr_err("IOMMU intr fault, IOVA[0x%lx], STATUS[0x%x]\n", iova, status);
+	rga_err("IOMMU intr fault, IOVA[0x%lx], STATUS[0x%x]\n", iova, status);
 	if (scheduler->ops->irq)
 		scheduler->ops->irq(scheduler);

@@ -253,13 +251,13 @@ static int rga_iommu_intr_fault_handler(struct iommu_domain *iommu, struct devic
 	}

 	if (status & RGA_IOMMU_IRQ_PAGE_FAULT) {
-		pr_err("RGA IOMMU: page fault! Please check the memory size.\n");
+		rga_err("RGA IOMMU: page fault! Please check the memory size.\n");
 		job->ret = -EACCES;
 	} else if (status & RGA_IOMMU_IRQ_BUS_ERROR) {
-		pr_err("RGA IOMMU: bus error! Please check if the memory is invalid or has been freed.\n");
+		rga_err("RGA IOMMU: bus error! Please check if the memory is invalid or has been freed.\n");
 		job->ret = -EACCES;
 	} else {
-		pr_err("RGA IOMMU: Wrong IOMMU interrupt signal!\n");
+		rga_err("RGA IOMMU: Wrong IOMMU interrupt signal!\n");
 	}

 	return 0;
--- a/drivers/video/rockchip/rga3/rga_job.c
+++ b/drivers/video/rockchip/rga3/rga_job.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_job: " fmt
-
 #include "rga_job.h"
 #include "rga_fence.h"
 #include "rga_dma_buf.h"
@@ -44,11 +42,6 @@ static void rga_job_get(struct rga_job *job)

 static int rga_job_cleanup(struct rga_job *job)
 {
-	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], job cleanup total cost time %lld us\n",
-			job->request_id,
-			ktime_us_delta(ktime_get(), job->timestamp));
-
 	rga_job_put(job);

 	return 0;
@@ -64,7 +57,7 @@ static int rga_job_judgment_support_core(struct rga_job *job)
 	req = &job->rga_command_base;
 	mm = rga_drvdata->mm;
 	if (mm == NULL) {
-		pr_err("rga mm is null!\n");
+		rga_job_err(job, "rga mm is null!\n");
 		return -EFAULT;
 	}

@@ -126,7 +119,7 @@ static struct rga_job *rga_job_alloc(struct rga_req *rga_command_base)
 	INIT_LIST_HEAD(&job->head);
 	kref_init(&job->refcount);

-	job->timestamp = ktime_get();
+	job->timestamp.init = ktime_get();
 	job->pid = current->pid;

 	job->rga_command_base = *rga_command_base;
@@ -154,33 +147,6 @@ static struct rga_job *rga_job_alloc(struct rga_req *rga_command_base)
 	return job;
 }

-static void rga_job_dump_info(struct rga_job *job)
-{
-	pr_info("job: reqeust_id = %d, priority = %d, core = %d\n",
-		job->request_id, job->priority, job->core);
-}
-
-void rga_job_scheduler_dump_info(struct rga_scheduler_t *scheduler)
-{
-	struct rga_job *job_pos;
-
-	lockdep_assert_held(&scheduler->irq_lock);
-
-	pr_info("===============================================================\n");
-	pr_info("%s core = %d job_count = %d status = %d\n",
-		dev_driver_string(scheduler->dev),
-		scheduler->core, scheduler->job_count, scheduler->status);
-
-	if (scheduler->running_job)
-		rga_job_dump_info(scheduler->running_job);
-
-	list_for_each_entry(job_pos, &scheduler->todo_list, head) {
-		rga_job_dump_info(job_pos);
-	}
-
-	pr_info("===============================================================\n");
-}
-
 static int rga_job_run(struct rga_job *job, struct rga_scheduler_t *scheduler)
 {
 	int ret = 0;
@@ -188,23 +154,19 @@ static int rga_job_run(struct rga_job *job, struct rga_scheduler_t *scheduler)
 	/* enable power */
 	ret = rga_power_enable(scheduler);
 	if (ret < 0) {
-		pr_err("power enable failed");
+		rga_job_err(job, "power enable failed");
 		return ret;
 	}

 	ret = scheduler->ops->set_reg(job, scheduler);
 	if (ret < 0) {
-		pr_err("set reg failed");
+		rga_job_err(job, "set reg failed");
 		rga_power_disable(scheduler);
 		return ret;
 	}

 	set_bit(RGA_JOB_STATE_RUNNING, &job->state);

-	/* for debug */
-	if (DEBUGGER_EN(MSG))
-		rga_job_dump_info(job);
-
 	return ret;
 }

@@ -238,7 +200,8 @@ next_job:
 	ret = rga_job_run(job, scheduler);
 	/* If some error before hw run */
 	if (ret < 0) {
-		pr_err("some error on rga_job_run before hw start, %s(%d)\n", __func__, __LINE__);
+		rga_job_err(job, "some error on rga_job_run before hw start, %s(%d)\n",
+			__func__, __LINE__);

 		spin_lock_irqsave(&scheduler->irq_lock, flags);
 		scheduler->running_job = NULL;
@@ -259,20 +222,22 @@ struct rga_job *rga_job_done(struct rga_scheduler_t *scheduler)
 {
 	struct rga_job *job;
 	unsigned long flags;
-	ktime_t now = ktime_get();

 	spin_lock_irqsave(&scheduler->irq_lock, flags);

 	job = scheduler->running_job;
 	if (job == NULL) {
-		pr_err("core[0x%x] running job has been cleanup.\n", scheduler->core);
+		rga_err("%s(%#x) running job has been cleanup.\n",
+			rga_get_core_name(scheduler->core), scheduler->core);

 		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
 		return NULL;
 	}
 	scheduler->running_job = NULL;

-	scheduler->timer.busy_time += ktime_us_delta(now, job->hw_recoder_time);
+	scheduler->timer.busy_time +=
+		ktime_us_delta(job->timestamp.hw_done, job->timestamp.hw_recode);
+	job->session->last_active = job->timestamp.hw_done;
 	set_bit(RGA_JOB_STATE_DONE, &job->state);

 	spin_unlock_irqrestore(&scheduler->irq_lock, flags);
@@ -284,10 +249,9 @@ struct rga_job *rga_job_done(struct rga_scheduler_t *scheduler)
 		rga_dump_job_image(job);

 	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], hardware[%s] cost time %lld us, work cycle %d\n",
-			job->request_id,
+		rga_job_log(job, "hardware[%s] cost time %lld us, work cycle %d\n",
 			rga_get_core_name(scheduler->core),
-			ktime_us_delta(now, job->hw_running_time),
+			ktime_us_delta(job->timestamp.hw_done, job->timestamp.hw_execute),
 			job->work_cycle);

 	rga_mm_unmap_job_info(job);
@@ -301,8 +265,8 @@ static int rga_job_timeout_query_state(struct rga_job *job, int orig_ret)

 	if (scheduler->ops->read_status) {
 		scheduler->ops->read_status(job, scheduler);
-		pr_err("request[%d] core[%d]: INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
-			job->request_id, scheduler->core,
+		rga_job_err(job, "core[%d]: INTR[0x%x], HW_STATUS[0x%x], CMD_STATUS[0x%x], WORK_CYCLE[0x%x(%d)]\n",
+			scheduler->core,
 			job->intr_status, job->hw_status, job->cmd_status,
 			job->work_cycle, job->work_cycle);
 	}
@@ -312,12 +276,11 @@ static int rga_job_timeout_query_state(struct rga_job *job, int orig_ret)
 		return orig_ret;
 	} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
 		   test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
-		pr_err("request[%d] job hardware has finished, but the software has timeout!\n",
-			job->request_id);
+		rga_job_err(job, "job hardware has finished, but the software has timeout!\n");
 		return -EBUSY;
 	} else if (!test_bit(RGA_JOB_STATE_DONE, &job->state) &&
 		   !test_bit(RGA_JOB_STATE_FINISH, &job->state)) {
-		pr_err("request[%d] job hardware has timeout.\n", job->request_id);
+		rga_job_err(job, "job hardware has timeout.\n");
 		return -EBUSY;
 	}

@@ -331,13 +294,13 @@ static void rga_job_scheduler_timeout_clean(struct rga_scheduler_t *scheduler)

 	spin_lock_irqsave(&scheduler->irq_lock, flags);

-	if (scheduler->running_job == NULL || scheduler->running_job->hw_running_time == 0) {
+	if (scheduler->running_job == NULL || scheduler->running_job->timestamp.hw_execute == 0) {
 		spin_unlock_irqrestore(&scheduler->irq_lock, flags);
 		return;
 	}

 	job = scheduler->running_job;
-	if (ktime_ms_delta(ktime_get(), job->hw_running_time) >= RGA_JOB_TIMEOUT_DELAY) {
+	if (ktime_ms_delta(ktime_get(), job->timestamp.hw_execute) >= RGA_JOB_TIMEOUT_DELAY) {
 		job->ret = rga_job_timeout_query_state(job, job->ret);

 		scheduler->running_job = NULL;
@@ -388,6 +351,7 @@ static void rga_job_insert_todo_list(struct rga_job *job)
 			list_add_tail(&job->head, &scheduler->todo_list);
 	}

+	job->timestamp.insert = ktime_get();
 	scheduler->job_count++;
 	set_bit(RGA_JOB_STATE_PENDING, &job->state);

@@ -407,7 +371,7 @@ static struct rga_scheduler_t *rga_job_schedule(struct rga_job *job)
 	if (rga_drvdata->num_of_scheduler > 1) {
 		job->core = rga_job_assign(job);
 		if (job->core <= 0) {
-			pr_err("job assign failed");
+			rga_job_err(job, "job assign failed");
 			job->ret = -EINVAL;
 			return NULL;
 		}
@@ -418,7 +382,7 @@ static struct rga_scheduler_t *rga_job_schedule(struct rga_job *job)

 	scheduler = job->scheduler;
 	if (scheduler == NULL) {
-		pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
+		rga_job_err(job, "failed to get scheduler, %s(%d)\n", __func__, __LINE__);
 		job->ret = -EFAULT;
 		return NULL;
 	}
@@ -434,7 +398,7 @@ struct rga_job *rga_job_commit(struct rga_req *rga_command_base, struct rga_requ

 	job = rga_job_alloc(rga_command_base);
 	if (!job) {
-		pr_err("failed to alloc rga job!\n");
+		rga_err("failed to alloc rga job!\n");
 		return ERR_PTR(-ENOMEM);
 	}

@@ -445,33 +409,32 @@ struct rga_job *rga_job_commit(struct rga_req *rga_command_base, struct rga_requ

 	scheduler = rga_job_schedule(job);
 	if (scheduler == NULL) {
-		pr_err("failed to get scheduler, %s(%d)\n", __func__, __LINE__);
 		goto err_free_job;
 	}

 	job->cmd_buf = rga_dma_alloc_coherent(scheduler, RGA_CMD_REG_SIZE);
 	if (job->cmd_buf == NULL) {
-		pr_err("failed to alloc command buffer.\n");
+		rga_job_err(job, "failed to alloc command buffer.\n");
 		goto err_free_job;
 	}

 	/* Memory mapping needs to keep pd enabled. */
 	if (rga_power_enable(scheduler) < 0) {
-		pr_err("power enable failed");
+		rga_job_err(job, "power enable failed");
 		job->ret = -EFAULT;
 		goto err_free_cmd_buf;
 	}

 	ret = rga_mm_map_job_info(job);
 	if (ret < 0) {
-		pr_err("%s: failed to map job info\n", __func__);
+		rga_job_err(job, "%s: failed to map job info\n", __func__);
 		job->ret = ret;
 		goto err_power_disable;
 	}

 	ret = scheduler->ops->init_reg(job);
 	if (ret < 0) {
-		pr_err("%s: init reg failed", __func__);
+		rga_job_err(job, "%s: init reg failed", __func__);
 		job->ret = ret;
 		goto err_unmap_job_info;
 	}
@@ -577,11 +540,11 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
 	struct rga_pending_request_manager *request_manager = rga_drvdata->pend_request_manager;

 	if (DEBUGGER_EN(MSG))
-		pr_info("acquire_fence_fd = %d", acquire_fence_fd);
+		rga_req_log(request, "acquire_fence_fd = %d", acquire_fence_fd);

 	acquire_fence = rga_get_dma_fence_from_fd(acquire_fence_fd);
 	if (IS_ERR_OR_NULL(acquire_fence)) {
-		pr_err("%s: failed to get acquire dma_fence from[%d]\n",
+		rga_req_err(request, "%s: failed to get acquire dma_fence from[%d]\n",
 		       __func__, acquire_fence_fd);
 		return -EINVAL;
 	}
@@ -595,7 +558,7 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
 		ksys_close(acquire_fence_fd);
 #endif
 #else
-		pr_err("Please update the driver to v1.2.28 to prevent acquire_fence_fd leaks.");
+		rga_req_err(request, "Please update the driver to v1.2.28 to prevent acquire_fence_fd leaks.");
 		return -EFAULT;
 #endif
 	}
@@ -603,7 +566,7 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,

 	ret = rga_dma_fence_get_status(acquire_fence);
 	if (ret < 0) {
-		pr_err("%s: Current acquire fence unexpectedly has error status before signal\n",
+		rga_req_err(request, "%s: Current acquire fence unexpectedly has error status before signal\n",
 		       __func__);
 		return ret;
 	} else if (ret > 0) {
@@ -622,7 +585,7 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
 	ret = rga_dma_fence_add_callback(acquire_fence, cb_func, (void *)request);
 	if (ret < 0) {
 		if (ret != -ENOENT)
-			pr_err("%s: failed to add fence callback\n", __func__);
+			rga_req_err(request, "%s: failed to add fence callback\n", __func__);

 		mutex_lock(&request_manager->lock);
 		rga_request_put(request);
@@ -636,23 +599,23 @@ static int rga_request_add_acquire_fence_callback(int acquire_fence_fd,
 int rga_request_check(struct rga_user_request *req)
 {
 	if (req->id <= 0) {
-		pr_err("user request id[%d] is invalid", req->id);
+		rga_err("ID[%d]: request_id is invalid", req->id);
 		return -EINVAL;
 	}

 	if (req->task_num <= 0) {
-		pr_err("invalied user request!\n");
+		rga_err("ID[%d]: invalid user request!\n", req->id);
 		return -EINVAL;
 	}

 	if (req->task_ptr == 0) {
-		pr_err("task_ptr is NULL!\n");
+		rga_err("ID[%d]: task_ptr is NULL!\n", req->id);
 		return -EINVAL;
 	}

 	if (req->task_num > RGA_TASK_NUM_MAX) {
-		pr_err("Only supports running %d tasks, now %d\n",
-		       RGA_TASK_NUM_MAX, req->task_num);
+		rga_err("ID[%d]: Only supports running %d tasks, now %d\n",
+			req->id, RGA_TASK_NUM_MAX, req->task_num);
 		return -EFBIG;
 	}

@@ -742,14 +705,16 @@ static int rga_request_scheduler_job_abort(struct rga_request *request)
 				scheduler->status = RGA_SCHEDULER_ABORT;
 				list_add_tail(&job->head, &list_to_free);

-				if (job->hw_running_time != 0) {
+				if (job->timestamp.hw_execute != 0) {
 					scheduler->timer.busy_time +=
-						ktime_us_delta(ktime_get(), job->hw_recoder_time);
+						ktime_us_delta(ktime_get(),
+							       job->timestamp.hw_recode);
 					scheduler->ops->soft_reset(scheduler);
 				}
+				job->session->last_active = ktime_get();

-				pr_err("reset core[%d] by request[%d] abort",
-				       scheduler->core, request->id);
+				rga_req_err(request, "reset core[%d] by request abort",
+					scheduler->core);
 				running_abort_count++;
 			}
 		}
@@ -776,9 +741,9 @@ static int rga_request_scheduler_job_abort(struct rga_request *request)
 	    all_task_count == request->task_count)
 		return 1;

-	pr_err("request[%d] abort! finished %d failed %d running_abort %d todo_abort %d\n",
-	       request->id, request->finished_task_count, request->failed_task_count,
-	       running_abort_count, todo_abort_count);
+	rga_err("request[%d] abort! finished %d failed %d running_abort %d todo_abort %d\n",
+		request->id, request->finished_task_count, request->failed_task_count,
+		running_abort_count, todo_abort_count);

 	return 0;
 }
@@ -824,7 +789,7 @@ void rga_request_session_destroy_abort(struct rga_session *session)

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_err("rga_pending_request_manager is null!\n");
 		return;
 	}

@@ -832,8 +797,7 @@ void rga_request_session_destroy_abort(struct rga_session *session)

 	idr_for_each_entry(&request_manager->request_idr, request, request_id) {
 		if (session == request->session) {
-			pr_err("[tgid:%d pid:%d] destroy request[%d] when the user exits",
-			       session->tgid, current->pid, request->id);
+			rga_req_err(request, "destroy when the user exits");
 			rga_request_put(request);
 		}
 	}
@@ -904,17 +868,20 @@ int rga_request_commit(struct rga_request *request)
 	int i = 0;
 	struct rga_job *job;

+	if (DEBUGGER_EN(MSG))
+		rga_req_log(request, "commit process: %s\n", request->session->pname);
+
 	for (i = 0; i < request->task_count; i++) {
 		struct rga_req *req = &(request->task_list[i]);

 		if (DEBUGGER_EN(MSG)) {
-			pr_info("commit request[%d] task[%d]:\n", request->id, i);
-			rga_cmd_print_debug_info(req);
+			rga_req_log(request, "commit task[%d]:\n", i);
+			rga_dump_req(request, req);
 		}

 		job = rga_job_commit(req, request);
 		if (IS_ERR(job)) {
-			pr_err("request[%d] task[%d] job_commit failed.\n", request->id, i);
+			rga_req_err(request, "task[%d] job_commit failed.\n", i);
 			rga_request_release_abort(request, PTR_ERR(job));

 			return PTR_ERR(job);
@@ -940,7 +907,7 @@ static void rga_request_acquire_fence_work(struct work_struct *work)

 	ret = rga_request_commit(request);
 	if (ret < 0) {
-		pr_err("acquire_fence callback: rga request[%d] commit failed!\n", request->id);
+		rga_req_err(request, "acquire_fence callback: request commit failed!\n");

 		spin_lock_irqsave(&request->lock, flags);

@@ -982,7 +949,7 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_job_err(job, "rga_pending_request_manager is null!\n");
 		return -EFAULT;
 	}

@@ -990,7 +957,7 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job

 	request = rga_request_lookup(request_manager, job->request_id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find internal request from id[%d]", job->request_id);
+		rga_job_err(job, "can not find internal request from id[%d]", job->request_id);
 		mutex_unlock(&request_manager->lock);
 		return -EINVAL;
 	}
@@ -1027,10 +994,10 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job
 		rga_dma_fence_signal(request->release_fence, request->ret);

 		is_finished = true;
+		job->timestamp.done = ktime_get();

 		if (DEBUGGER_EN(MSG))
-			pr_info("request[%d] finished %d failed %d\n",
-				request->id, finished_count, failed_count);
+			rga_job_log(job, "finished %d failed %d\n", finished_count, failed_count);

 		/* current submit request put */
 		mutex_lock(&request_manager->lock);
@@ -1047,10 +1014,17 @@ int rga_request_release_signal(struct rga_scheduler_t *scheduler, struct rga_job

 	mutex_unlock(&request_manager->lock);

-	if (DEBUGGER_EN(TIME))
-		pr_info("request[%d], job done total cost time %lld us\n",
-			job->request_id,
-			ktime_us_delta(ktime_get(), job->timestamp));
+	if (DEBUGGER_EN(TIME)) {
+		rga_job_log(job,
+			"stats: prepare %lld us, schedule %lld us, hardware %lld us, free %lld us\n",
+			ktime_us_delta(job->timestamp.insert, job->timestamp.init),
+			ktime_us_delta(job->timestamp.hw_execute, job->timestamp.insert),
+			ktime_us_delta(job->timestamp.hw_done, job->timestamp.hw_execute),
+			ktime_us_delta(ktime_get(), job->timestamp.hw_done));
+		rga_job_log(job, "total: job done cost %lld us, cleanup done cost %lld us\n",
+			ktime_us_delta(job->timestamp.done, job->timestamp.init),
+			ktime_us_delta(ktime_get(), job->timestamp.init));
+	}

 	rga_job_cleanup(job);

@@ -1067,7 +1041,7 @@ struct rga_request *rga_request_config(struct rga_user_request *user_request)

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_err("rga_pending_request_manager is null!\n");
 		return ERR_PTR(-EFAULT);
 	}

@@ -1075,7 +1049,7 @@ struct rga_request *rga_request_config(struct rga_user_request *user_request)

 	request = rga_request_lookup(request_manager, user_request->id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find request from id[%d]", user_request->id);
+		rga_err("can not find request from id[%d]", user_request->id);
 		mutex_unlock(&request_manager->lock);
 		return ERR_PTR(-EINVAL);
 	}
@@ -1085,14 +1059,14 @@ struct rga_request *rga_request_config(struct rga_user_request *user_request)

 	task_list = kmalloc_array(user_request->task_num, sizeof(struct rga_req), GFP_KERNEL);
 	if (task_list == NULL) {
-		pr_err("task_req list alloc error!\n");
+		rga_req_err(request, "task_req list alloc error!\n");
 		ret = -ENOMEM;
 		goto err_put_request;
 	}

 	if (unlikely(copy_from_user(task_list, u64_to_user_ptr(user_request->task_ptr),
 				    sizeof(struct rga_req) * user_request->task_num))) {
-		pr_err("rga_user_request task list copy_from_user failed\n");
+		rga_req_err(request, "rga_user_request task list copy_from_user failed\n");
 		ret = -EFAULT;
 		goto err_free_task_list;
 	}
@@ -1131,7 +1105,7 @@ struct rga_request *rga_request_kernel_config(struct rga_user_request *user_requ

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_err("rga_pending_request_manager is null!\n");
 		return ERR_PTR(-EFAULT);
 	}

@@ -1139,7 +1113,7 @@ struct rga_request *rga_request_kernel_config(struct rga_user_request *user_requ

 	request = rga_request_lookup(request_manager, user_request->id);
 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("can not find request from id[%d]", user_request->id);
+		rga_err("can not find request from id[%d]", user_request->id);
 		mutex_unlock(&request_manager->lock);
 		return ERR_PTR(-EINVAL);
 	}
@@ -1149,7 +1123,7 @@ struct rga_request *rga_request_kernel_config(struct rga_user_request *user_requ

 	task_list = kmalloc_array(user_request->task_num, sizeof(struct rga_req), GFP_KERNEL);
 	if (task_list == NULL) {
-		pr_err("task_req list alloc error!\n");
+		rga_req_err(request, "task_req list alloc error!\n");
 		ret = -ENOMEM;
 		goto err_put_request;
 	}
@@ -1192,7 +1166,7 @@ int rga_request_submit(struct rga_request *request)
 	if (request->is_running) {
 		spin_unlock_irqrestore(&request->lock, flags);

-		pr_err("can not re-config when request is running\n");
+		rga_req_err(request, "can not re-config when request is running\n");
 		ret = -EFAULT;
 		goto err_put_current_mm;
 	}
@@ -1200,7 +1174,7 @@ int rga_request_submit(struct rga_request *request)
 	if (request->task_list == NULL) {
 		spin_unlock_irqrestore(&request->lock, flags);

-		pr_err("can not find task list from id[%d]\n", request->id);
+		rga_req_err(request, "can not find task list\n");
 		ret = -EINVAL;
 		goto err_put_current_mm;
 	}
@@ -1219,7 +1193,7 @@ int rga_request_submit(struct rga_request *request)
 	if (request->sync_mode == RGA_BLIT_ASYNC) {
 		release_fence = rga_dma_fence_alloc();
 		if (IS_ERR(release_fence)) {
-			pr_err("Can not alloc release fence!\n");
+			rga_req_err(request, "Can not alloc release fence!\n");
 			ret = IS_ERR(release_fence);
 			goto err_reset_request;
 		}
@@ -1237,7 +1211,7 @@ int rga_request_submit(struct rga_request *request)
 				/* acquire fence has been signaled */
 				goto request_commit;
 			} else {
-				pr_err("Failed to add callback with acquire fence fd[%d]!\n",
+				rga_req_err(request, "Failed to add callback with acquire fence fd[%d]!\n",
 				       request->acquire_fence_fd);
 				goto err_put_release_fence;
 			}
@@ -1247,7 +1221,7 @@ int rga_request_submit(struct rga_request *request)
 request_commit:
 	ret = rga_request_commit(request);
 	if (ret < 0) {
-		pr_err("rga request[%d] commit failed!\n", request->id);
+		rga_req_err(request, "request commit failed!\n");
 		goto err_put_release_fence;
 	}

@@ -1255,7 +1229,7 @@ export_release_fence_fd:
 	if (request->release_fence != NULL) {
 		ret = rga_dma_fence_get_fd(request->release_fence);
 		if (ret < 0) {
-			pr_err("Failed to alloc release fence fd!\n");
+			rga_req_err(request, "Failed to alloc release fence fd!\n");
 			rga_request_release_abort(request, ret);
 			return ret;
 		}
@@ -1295,20 +1269,20 @@ int rga_request_mpi_submit(struct rga_req *req, struct rga_request *request)
 	request_manager = rga_drvdata->pend_request_manager;

 	if (request->sync_mode == RGA_BLIT_ASYNC) {
-		pr_err("mpi unsupported async mode!\n");
+		rga_req_err(request, "mpi unsupported async mode!\n");
 		return -EINVAL;
 	}

 	spin_lock_irqsave(&request->lock, flags);

 	if (request->is_running) {
-		pr_err("can not re-config when request is running");
+		rga_req_err(request, "can not re-config when request is running");
 		spin_unlock_irqrestore(&request->lock, flags);
 		return -EFAULT;
 	}

 	if (request->task_list == NULL) {
-		pr_err("can not find task list from id[%d]", request->id);
+		rga_req_err(request, "can not find task list");
 		spin_unlock_irqrestore(&request->lock, flags);
 		return -EINVAL;
 	}
@@ -1332,7 +1306,7 @@ int rga_request_mpi_submit(struct rga_req *req, struct rga_request *request)

 	job = rga_job_commit(req, request);
 	if (IS_ERR_OR_NULL(job)) {
-		pr_err("failed to commit job!\n");
+		rga_req_err(request, "failed to commit job!\n");
 		return job ? PTR_ERR(job) : -EFAULT;
 	}

@@ -1351,14 +1325,14 @@ int rga_request_free(struct rga_request *request)

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_err("rga_pending_request_manager is null!\n");
 		return -EFAULT;
 	}

 	WARN_ON(!mutex_is_locked(&request_manager->lock));

 	if (IS_ERR_OR_NULL(request)) {
-		pr_err("request already freed");
+		rga_err("request already freed");
 		return -EFAULT;
 	}

@@ -1430,13 +1404,13 @@ int rga_request_alloc(uint32_t flags, struct rga_session *session)

 	request_manager = rga_drvdata->pend_request_manager;
 	if (request_manager == NULL) {
-		pr_err("rga_pending_request_manager is null!\n");
+		rga_err("rga_pending_request_manager is null!\n");
 		return -EFAULT;
 	}

 	request = kzalloc(sizeof(*request), GFP_KERNEL);
 	if (request == NULL) {
-		pr_err("can not kzalloc for rga_request\n");
+		rga_err("can not kzalloc for rga_request\n");
 		return -ENOMEM;
 	}

@@ -1458,7 +1432,7 @@ int rga_request_alloc(uint32_t flags, struct rga_session *session)
 	new_id = idr_alloc_cyclic(&request_manager->request_idr, request, 1, 0, GFP_NOWAIT);
 	idr_preload_end();
 	if (new_id < 0) {
-		pr_err("request alloc id failed!\n");
+		rga_err("request alloc id failed!\n");

 		mutex_unlock(&request_manager->lock);
 		kfree(request);
--- a/drivers/video/rockchip/rga3/rga_mm.c
+++ b/drivers/video/rockchip/rga3/rga_mm.c
--- a/drivers/video/rockchip/rga3/rga_policy.c
+++ b/drivers/video/rockchip/rga3/rga_policy.c
@@ -5,8 +5,6 @@
 * Author: Huang Lee <Putin.li@rock-chips.com>
 */

-#define pr_fmt(fmt) "rga_policy: " fmt
-
 #include "rga_job.h"
 #include "rga_common.h"
 #include "rga_hw_config.h"
@@ -150,7 +148,8 @@ static bool rga_check_format(const struct rga_hw_data *data,
 	return false;
 }

-static bool rga_check_align(uint32_t byte_stride_align, uint32_t format, uint16_t w_stride)
+static bool rga_check_align(struct rga_job *job,
+			    uint32_t byte_stride_align, uint32_t format, uint16_t w_stride)
 {
 	int bit_stride, pixel_stride, align, gcd;

@@ -166,14 +165,14 @@ static bool rga_check_align(uint32_t byte_stride_align, uint32_t format, uint16_
 	if (DEBUGGER_EN(MSG)) {
 		gcd = GET_GCD(pixel_stride, byte_stride_align * 8);
 		align = GET_LCM(pixel_stride, byte_stride_align * 8, gcd) / pixel_stride;
-		pr_info("unsupported width stride %d, 0x%x should be %d aligned!",
+		rga_job_log(job, "unsupported width stride %d, 0x%x should be %d aligned!",
 			w_stride, format, align);
 	}

 	return false;
 }

-static bool rga_check_channel(const struct rga_hw_data *data,
+static bool rga_check_channel(struct rga_job *job, const struct rga_hw_data *data,
 			      struct rga_img_info_t *img,
 			      const char *name, int input, int win_num)
 {
@@ -186,7 +185,7 @@ static bool rga_check_channel(const struct rga_hw_data *data,

 	if (!rga_check_resolution(range, img->act_w, img->act_h)) {
 		if (DEBUGGER_EN(MSG))
-			pr_info("%s resolution check error, input range[%dx%d ~ %dx%d], [w,h] = [%d, %d]\n",
+			rga_job_log(job, "%s resolution check error, input range[%dx%d ~ %dx%d], [w,h] = [%d, %d]\n",
 				name,
 				data->input_range.min.width, data->input_range.min.height,
 				data->input_range.max.width, data->input_range.max.height,
@@ -200,7 +199,7 @@ static bool rga_check_channel(const struct rga_hw_data *data,
 				  img->act_w + img->x_offset,
 				  img->act_h + img->y_offset)) {
 		if (DEBUGGER_EN(MSG))
-			pr_info("%s RGA3 resolution check error, input range[%dx%d ~ %dx%d], [w+x,h+y] = [%d, %d]\n",
+			rga_job_log(job, "%s RGA3 resolution check error, input range[%dx%d ~ %dx%d], [w+x,h+y] = [%d, %d]\n",
 				name,
 				data->input_range.min.width, data->input_range.min.height,
 				data->input_range.max.width, data->input_range.max.height,
@@ -211,14 +210,14 @@ static bool rga_check_channel(const struct rga_hw_data *data,

 	if (!rga_check_format(data, img->rd_mode, img->format, win_num)) {
 		if (DEBUGGER_EN(MSG))
-			pr_info("%s format check error, mode = %#x, format = %#x\n",
+			rga_job_log(job, "%s format check error, mode = %#x, format = %#x\n",
 				name, img->rd_mode, img->format);
 		return false;
 	}

-	if (!rga_check_align(data->byte_stride_align, img->format, img->vir_w)) {
+	if (!rga_check_align(job, data->byte_stride_align, img->format, img->vir_w)) {
 		if (DEBUGGER_EN(MSG))
-			pr_info("%s align check error, byte_stride_align[%d], format[%#x], vir_w[%d]\n",
+			rga_job_log(job, "%s align check error, byte_stride_align[%d], format[%#x], vir_w[%d]\n",
 				name, data->byte_stride_align, img->format, img->vir_w);
 		return false;
 	}
@@ -226,8 +225,8 @@ static bool rga_check_channel(const struct rga_hw_data *data,
 	return true;
 }

-static bool rga_check_scale(const struct rga_hw_data *data,
-				struct rga_req *rga_base)
+static bool rga_check_scale(struct rga_job *job, const struct rga_hw_data *data,
+			    struct rga_req *rga_base)
 {
 	struct rga_img_info_t *src0 = &rga_base->src;
 	struct rga_img_info_t *dst = &rga_base->dst;
@@ -259,7 +258,7 @@ static bool rga_check_scale(const struct rga_hw_data *data,
 	return true;
 check_error:
 	if (DEBUGGER_EN(MSG))
-		pr_info("scale check error, scale limit[1/%d ~ %d], src[%d, %d], dst[%d, %d]\n",
+		rga_job_log(job, "scale check error, scale limit[1/%d ~ %d], src[%d, %d], dst[%d, %d]\n",
 			(1 << data->max_downscale_factor), (1 << data->max_upscale_factor),
 			sw, sh, dw, dh);

@@ -287,8 +286,8 @@ int rga_job_assign(struct rga_job *job)
 	/* assigned by userspace */
 	if (rga_base->core > RGA_NONE_CORE) {
 		if (rga_base->core > RGA_CORE_MASK) {
-			pr_err("invalid setting core by user\n");
-			goto finish;
+			rga_job_err(job, "invalid setting core by user\n");
+			return -1;
 		} else if (rga_base->core & RGA_CORE_MASK)
 			specified_cores = rga_base->core;
 	}
@@ -305,19 +304,21 @@ int rga_job_assign(struct rga_job *job)
 			continue;

 		if (DEBUGGER_EN(MSG))
-			pr_info("start policy on core = %d", scheduler->core);
+			rga_job_log(job, "start policy on %s(%#x)",
+				rga_get_core_name(scheduler->core), scheduler->core);

 		if (scheduler->data->mmu == RGA_MMU &&
 		    job->flags & RGA_JOB_UNSUPPORT_RGA_MMU) {
 			if (DEBUGGER_EN(MSG))
-				pr_info("RGA2 only support under 4G memory!\n");
+				rga_job_log(job, "RGA2 only support under 4G memory!\n");
 			continue;
 		}

 		if (feature > 0) {
 			if (!(feature & data->feature)) {
 				if (DEBUGGER_EN(MSG))
-					pr_info("core = %d, break on feature\n",
+					rga_job_log(job, "%s(%#x), break on feature\n",
+						rga_get_core_name(scheduler->core),
 						scheduler->core);
 				continue;
 			}
@@ -328,74 +329,94 @@ int rga_job_assign(struct rga_job *job)
 			if (src1->yrgb_addr > 0) {
 				if (!(src0->rd_mode & data->win[0].rd_mode)) {
 					if (DEBUGGER_EN(MSG))
-						pr_info("core[%#x], src0 break on rd_mode[%#x]\n",
-							scheduler->core, src0->rd_mode);
+						rga_job_log(job, "%s(%#x), src0 break on %s(%#x)\n",
+							rga_get_core_name(scheduler->core),
+							scheduler->core,
+							rga_get_store_mode_str(src0->rd_mode),
+							src0->rd_mode);
 					continue;
 				}

 				if (!(src1->rd_mode & data->win[1].rd_mode)) {
 					if (DEBUGGER_EN(MSG))
-						pr_info("core[%#x], src1 break on rd_mode[%#x]\n",
-							scheduler->core, src1->rd_mode);
+						rga_job_log(job, "%s(%#x), src1 break on %s(%#x)\n",
+							rga_get_core_name(scheduler->core),
+							scheduler->core,
+							rga_get_store_mode_str(src1->rd_mode),
+							src1->rd_mode);
 					continue;
 				}

 				if (!(dst->rd_mode & data->win[2].rd_mode)) {
 					if (DEBUGGER_EN(MSG))
-						pr_info("core[%#x], dst break on rd_mode[%#x]\n",
-							scheduler->core, dst->rd_mode);
+						rga_job_log(job, "%s(%#x), dst break on %s(%#x)\n",
+							rga_get_core_name(scheduler->core),
+							scheduler->core,
+							rga_get_store_mode_str(dst->rd_mode),
+							dst->rd_mode);
 					continue;
 				}
 			} else {
 				if (!(src0->rd_mode & data->win[0].rd_mode)) {
 					if (DEBUGGER_EN(MSG))
-						pr_info("core[%#x], src break on rd_mode[%#x]\n",
-							scheduler->core, src0->rd_mode);
+						rga_job_log(job, "%s(%#x), src break on %s(%#x)\n",
+							rga_get_core_name(scheduler->core),
+							scheduler->core,
+							rga_get_store_mode_str(src0->rd_mode),
+							src0->rd_mode);
 					continue;
 				}

 				if (!(dst->rd_mode & data->win[2].rd_mode)) {
 					if (DEBUGGER_EN(MSG))
-						pr_info("core[%#x], dst break on rd_mode[%#x]\n",
-							scheduler->core, dst->rd_mode);
+						rga_job_log(job, "%s(%#x), dst break on %s(%#x)\n",
+							rga_get_core_name(scheduler->core),
+							scheduler->core,
+							rga_get_store_mode_str(dst->rd_mode),
+							dst->rd_mode);
 					continue;
 				}
 			}

-			if (!rga_check_scale(data, rga_base)) {
+			if (!rga_check_scale(job, data, rga_base)) {
 				if (DEBUGGER_EN(MSG))
-					pr_info("core = %d, break on rga_check_scale",
+					rga_job_log(job, "%s(%#x), break on rga_check_scale",
+						rga_get_core_name(scheduler->core),
 						scheduler->core);
 				continue;
 			}

-			if (!rga_check_channel(data, src0, "src0", true, 0)) {
+			if (!rga_check_channel(job, data, src0, "src0", true, 0)) {
 				if (DEBUGGER_EN(MSG))
-					pr_info("core = %d, break on src0",
+					rga_job_log(job, "%s(%#x), break on src0",
+						rga_get_core_name(scheduler->core),
 						scheduler->core);
 				continue;
 			}

 			if (src1->yrgb_addr > 0) {
-				if (!rga_check_channel(data, src1, "src1", true, 1)) {
+				if (!rga_check_channel(job, data, src1, "src1", true, 1)) {
 					if (DEBUGGER_EN(MSG))
-						pr_info("core = %d, break on src1",
+						rga_job_log(job, "%s(%#x), break on src1",
+							rga_get_core_name(scheduler->core),
 							scheduler->core);
 					continue;
 				}
 			}
 		}

-		if (!rga_check_channel(data, dst, "dst", false, 2)) {
+		if (!rga_check_channel(job, data, dst, "dst", false, 2)) {
 			if (DEBUGGER_EN(MSG))
-				pr_info("core = %d, break on dst",
+				rga_job_log(job, "%s(%#x), break on dst",
+					rga_get_core_name(scheduler->core),
 					scheduler->core);
 			continue;
 		}

 		if (!rga_check_csc(data, rga_base)) {
 			if (DEBUGGER_EN(MSG))
-				pr_info("core = %d, break on rga_check_csc",
+				rga_job_log(job, "%s(%#x), break on rga_check_csc",
+					rga_get_core_name(scheduler->core),
 					scheduler->core);
 			continue;
 		}
@@ -403,13 +424,9 @@ int rga_job_assign(struct rga_job *job)
 		optional_cores |= scheduler->core;
 	}

-	if (DEBUGGER_EN(MSG))
-		pr_info("optional_cores = %d\n", optional_cores);
-
 	if (optional_cores == 0) {
-		core = -1;
-		pr_err("invalid function policy\n");
-		goto finish;
+		rga_job_err(job, "no core match\n");
+		return -1;
 	}

 	for (i = 0; i < rga_drvdata->num_of_scheduler; i++) {
@@ -438,9 +455,10 @@ int rga_job_assign(struct rga_job *job)
 	}

 	/* TODO: need consider full load */
-finish:
 	if (DEBUGGER_EN(MSG))
-		pr_info("assign core: %d\n", core);
+		rga_job_log(job, "matched cores = %#x, assign core: %s(%#x)\n",
+			optional_cores,
+			rga_get_core_name(core), core);

 	return core;
 }