diff --git a/arch/arm/boot/dts/rk3506-evb1-v10.dtsi b/arch/arm/boot/dts/rk3506-evb1-v10.dtsi index 050d9c49022f..9a26dd76e3f5 100644 --- 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 { diff --git a/arch/arm64/boot/dts/rockchip/Makefile b/arch/arm64/boot/dts/rockchip/Makefile index 1d475a805c97..e900b426caaa 100644 --- 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 diff --git a/arch/arm64/boot/dts/rockchip/rk3399-sapphire-excavator-edp.dtsi b/arch/arm64/boot/dts/rockchip/rk3399-sapphire-excavator-edp.dtsi index ab2a79b4edad..0385af2f8403 100644 --- 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 @@ }; }; }; - diff --git a/arch/arm64/boot/dts/rockchip/rk3562-toybrick-android.dts b/arch/arm64/boot/dts/rockchip/rk3562-toybrick-android.dts new file mode 100644 index 000000000000..63dd7fc082de --- /dev/null +++ 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" diff --git a/arch/arm64/boot/dts/rockchip/rk3562-toybrick-linux.dts b/arch/arm64/boot/dts/rockchip/rk3562-toybrick-linux.dts new file mode 100644 index 000000000000..bf6fe46c95de --- /dev/null +++ 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" diff --git a/arch/arm64/boot/dts/rockchip/rk3562-toybrick.dtsi b/arch/arm64/boot/dts/rockchip/rk3562-toybrick.dtsi new file mode 100644 index 000000000000..14c5526e0fcb --- /dev/null +++ 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 +#include +#include + +/ { + 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 = ; + 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 + ðm0_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 = ; + 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"; +}; diff --git a/arch/arm64/boot/dts/rockchip/rk3576.dtsi b/arch/arm64/boot/dts/rockchip/rk3576.dtsi index 96f0f45c9e9f..6956a7027efc 100644 --- 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>; diff --git a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-qp.c b/drivers/gpu/drm/bridge/synopsys/dw-hdmi-qp.c index b3c19200cd48..6511cabe9071 100644 --- 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; diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.h b/drivers/gpu/drm/rockchip/rockchip_drm_drv.h index b65781c36f96..cd679cf19c51 100644 --- 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; diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c index dbc0193bf1f2..89dc2b101ba6 100644 --- 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; diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.h b/drivers/gpu/drm/rockchip/rockchip_drm_vop.h index 78782ee8e834..8d5729c8b943 100644 --- 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; diff --git a/drivers/gpu/drm/rockchip/rockchip_vop_reg.c b/drivers/gpu/drm/rockchip/rockchip_vop_reg.c index 8008159f0a5b..8b3edda93ec5 100644 --- 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[] = { diff --git a/drivers/media/i2c/rk628/rk628_bt1120_v4l2.c b/drivers/media/i2c/rk628/rk628_bt1120_v4l2.c index d332fb0639f8..bdc6b2c3f31b 100644 --- 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; } diff --git a/drivers/media/i2c/rk628/rk628_csi_v4l2.c b/drivers/media/i2c/rk628/rk628_csi_v4l2.c index 74e22bea489f..c02ab61e998d 100644 --- 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); diff --git a/drivers/media/platform/rockchip/hdmirx/rk_hdmirx.c b/drivers/media/platform/rockchip/hdmirx/rk_hdmirx.c index 7217eddf83d4..5df2e28d862b 100644 --- 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 { diff --git a/drivers/video/rockchip/rga3/include/rga.h b/drivers/video/rockchip/rga3/include/rga.h index 857d98ffe14a..c54e4a897695 100644 --- 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 { diff --git a/drivers/video/rockchip/rga3/include/rga_common.h b/drivers/video/rockchip/rga3/include/rga_common.h index 1afdb6ef59f7..6c64f74019c9 100644 --- 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 diff --git a/drivers/video/rockchip/rga3/include/rga_debugger.h b/drivers/video/rockchip/rga3/include/rga_debugger.h index f6d423872b28..cc2966ec554d 100644 --- 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); diff --git a/drivers/video/rockchip/rga3/include/rga_drv.h b/drivers/video/rockchip/rga3/include/rga_drv.h index 2ef48e8c469a..37e6bd8bb9b3 100644 --- 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; diff --git a/drivers/video/rockchip/rga3/rga2_reg_info.c b/drivers/video/rockchip/rga3/rga2_reg_info.c index 9a16eb14faca..0b46b5813600 100644 --- 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 */ -#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; } } diff --git a/drivers/video/rockchip/rga3/rga3_reg_info.c b/drivers/video/rockchip/rga3/rga3_reg_info.c index e8df4106731d..9df753f696ba 100644 --- 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 */ -#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; } } diff --git a/drivers/video/rockchip/rga3/rga_common.c b/drivers/video/rockchip/rga3/rga_common.c index 77ad30bd5857..a8af72430303 100644 --- a/drivers/video/rockchip/rga3/rga_common.c +++ b/drivers/video/rockchip/rga3/rga_common.c @@ -5,8 +5,6 @@ * Author: Cerf Yu */ -#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); +} diff --git a/drivers/video/rockchip/rga3/rga_debugger.c b/drivers/video/rockchip/rga3/rga_debugger.c index da37a17d8efd..93c5fcf3ec48 100644 --- a/drivers/video/rockchip/rga3/rga_debugger.c +++ b/drivers/video/rockchip/rga3/rga_debugger.c @@ -7,8 +7,6 @@ * Huang Lee */ -#define pr_fmt(fmt) "rga_debugger: " fmt - #include #include #include @@ -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, " \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, diff --git a/drivers/video/rockchip/rga3/rga_dma_buf.c b/drivers/video/rockchip/rga3/rga_dma_buf.c index da421580c9bb..e72470e5c5f5 100644 --- 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 */ -#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; } diff --git a/drivers/video/rockchip/rga3/rga_drv.c b/drivers/video/rockchip/rga3/rga_drv.c index d692f58df3eb..203d10ee938c 100644 --- a/drivers/video/rockchip/rga3/rga_drv.c +++ b/drivers/video/rockchip/rga3/rga_drv.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; } diff --git a/drivers/video/rockchip/rga3/rga_fence.c b/drivers/video/rockchip/rga3/rga_fence.c index 7d831d55d15d..9c663f3be5ca 100644 --- a/drivers/video/rockchip/rga3/rga_fence.c +++ b/drivers/video/rockchip/rga3/rga_fence.c @@ -5,14 +5,13 @@ * Author: Huang Lee */ -#define pr_fmt(fmt) "rga_fence: " fmt - #include #include #include #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; } diff --git a/drivers/video/rockchip/rga3/rga_iommu.c b/drivers/video/rockchip/rga3/rga_iommu.c index 6ef9cbc0d5d2..3ba0d58b2c20 100644 --- a/drivers/video/rockchip/rga3/rga_iommu.c +++ b/drivers/video/rockchip/rga3/rga_iommu.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; diff --git a/drivers/video/rockchip/rga3/rga_job.c b/drivers/video/rockchip/rga3/rga_job.c index 809006a2bc2b..25e1b978f2e9 100644 --- a/drivers/video/rockchip/rga3/rga_job.c +++ b/drivers/video/rockchip/rga3/rga_job.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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); diff --git a/drivers/video/rockchip/rga3/rga_mm.c b/drivers/video/rockchip/rga3/rga_mm.c index e793a632a13e..c5de4127dfb0 100644 --- a/drivers/video/rockchip/rga3/rga_mm.c +++ b/drivers/video/rockchip/rga3/rga_mm.c @@ -5,8 +5,6 @@ * Author: Cerf Yu */ -#define pr_fmt(fmt) "rga_mm: " fmt - #include "rga.h" #include "rga_job.h" #include "rga_mm.h" @@ -53,14 +51,14 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory for (i = 0; i < pageCount; i++) { vma = find_vma(current_mm, (Memory + i) << PAGE_SHIFT); if (!vma) { - pr_err("page[%d] failed to get vma\n", i); + rga_err("page[%d] failed to get vma\n", i); ret = RGA_OUT_OF_RESOURCES; break; } pgd = pgd_offset(current_mm, (Memory + i) << PAGE_SHIFT); if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd))) { - pr_err("page[%d] failed to get pgd\n", i); + rga_err("page[%d] failed to get pgd\n", i); ret = RGA_OUT_OF_RESOURCES; break; } @@ -71,7 +69,7 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory */ p4d = p4d_offset(pgd, (Memory + i) << PAGE_SHIFT); if (p4d_none(*p4d) || unlikely(p4d_bad(*p4d))) { - pr_err("page[%d] failed to get p4d\n", i); + rga_err("page[%d] failed to get p4d\n", i); ret = RGA_OUT_OF_RESOURCES; break; } @@ -82,20 +80,20 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory #endif if (pud_none(*pud) || unlikely(pud_bad(*pud))) { - pr_err("page[%d] failed to get pud\n", i); + rga_err("page[%d] failed to get pud\n", i); ret = RGA_OUT_OF_RESOURCES; break; } pmd = pmd_offset(pud, (Memory + i) << PAGE_SHIFT); if (pmd_none(*pmd) || unlikely(pmd_bad(*pmd))) { - pr_err("page[%d] failed to get pmd\n", i); + rga_err("page[%d] failed to get pmd\n", i); ret = RGA_OUT_OF_RESOURCES; break; } pte = pte_offset_map_lock(current_mm, pmd, (Memory + i) << PAGE_SHIFT, &ptl); if (pte_none(*pte)) { - pr_err("page[%d] failed to get pte\n", i); + rga_err("page[%d] failed to get pte\n", i); pte_unmap_unlock(pte, ptl); ret = RGA_OUT_OF_RESOURCES; break; @@ -107,8 +105,8 @@ static int rga_get_user_pages_from_vma(struct page **pages, unsigned long Memory } if (ret == RGA_OUT_OF_RESOURCES && i > 0) - pr_err("Only get buffer %d byte from vma, but current image required %d byte", - (int)(i * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); + rga_err("Only get buffer %d byte from vma, but current image required %d byte", + (int)(i * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); return ret; } @@ -149,8 +147,8 @@ static int rga_get_user_pages(struct page **pages, unsigned long Memory, ret = rga_get_user_pages_from_vma(pages, Memory, pageCount, current_mm); if (ret < 0 && result > 0) { - pr_err("Only get buffer %d byte from user pages, but current image required %d byte\n", - (int)(result * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); + rga_err("Only get buffer %d byte from user pages, but current image required %d byte\n", + (int)(result * PAGE_SIZE), (int)(pageCount * PAGE_SIZE)); } } @@ -176,7 +174,7 @@ static struct sg_table *rga_alloc_sgt(struct rga_virt_addr *virt_addr) sgt = kzalloc(sizeof(*sgt), GFP_KERNEL); if (sgt == NULL) { - pr_err("%s alloc sgt error!\n", __func__); + rga_err("%s alloc sgt error!\n", __func__); return ERR_PTR(-ENOMEM); } @@ -189,7 +187,7 @@ static struct sg_table *rga_alloc_sgt(struct rga_virt_addr *virt_addr) virt_addr->size, GFP_KERNEL); if (ret) { - pr_err("sg_alloc_table_from_pages failed"); + rga_err("sg_alloc_table_from_pages failed"); goto out_free_sgt; } @@ -250,8 +248,8 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p, count = RGA_GET_PAGE_COUNT(img_size + offset); size = count * PAGE_SIZE; if (!size) { - pr_err("failed to calculating buffer size! size = %ld, count = %d, offset = %ld\n", - size, count, (unsigned long)offset); + rga_err("failed to calculating buffer size! size = %ld, count = %d, offset = %ld\n", + size, count, (unsigned long)offset); rga_dump_memory_parm(memory_parm); return -EFAULT; } @@ -259,21 +257,21 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p, /* alloc pages and page_table */ order = get_order(count * sizeof(struct page *)); if (order >= MAX_ORDER) { - pr_err("Can not alloc pages with order[%d] for viraddr pages, max_order = %d\n", - order, MAX_ORDER); + rga_err("Can not alloc pages with order[%d] for viraddr pages, max_order = %d\n", + order, MAX_ORDER); return -ENOMEM; } pages = (struct page **)__get_free_pages(GFP_KERNEL, order); if (pages == NULL) { - pr_err("%s can not alloc pages for viraddr pages\n", __func__); + rga_err("%s can not alloc pages for viraddr pages\n", __func__); return -ENOMEM; } /* get pages from virtual address. */ ret = rga_get_user_pages(pages, viraddr >> PAGE_SHIFT, count, writeFlag, mm); if (ret < 0) { - pr_err("failed to get pages from virtual adrees: 0x%lx\n", + rga_err("failed to get pages from virtual adrees: 0x%lx\n", (unsigned long)viraddr); ret = -EINVAL; goto out_free_pages; @@ -284,7 +282,7 @@ static int rga_alloc_virt_addr(struct rga_virt_addr **virt_addr_p, *virt_addr_p = kzalloc(sizeof(struct rga_virt_addr), GFP_KERNEL); if (*virt_addr_p == NULL) { - pr_err("%s alloc virt_addr error!\n", __func__); + rga_err("%s alloc virt_addr error!\n", __func__); ret = -ENOMEM; goto out_put_and_free_pages; } @@ -316,7 +314,7 @@ static inline bool rga_mm_check_memory_limit(struct rga_scheduler_t *scheduler, if (scheduler->data->mmu == RGA_MMU && !(mm_flag & RGA_MEM_UNDER_4G)) { - pr_err("%s unsupported memory larger than 4G!\n", + rga_err("%s unsupported memory larger than 4G!\n", rga_get_mmu_type_str(scheduler->data->mmu)); return false; } @@ -383,7 +381,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, scheduler = job ? job->scheduler : rga_drvdata->scheduler[rga_drvdata->map_scheduler_index]; if (scheduler == NULL) { - pr_err("Invalid scheduler device!\n"); + rga_err("Invalid scheduler device!\n"); return -EINVAL; } @@ -395,7 +393,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, external_buffer->memory_parm.format, NULL, NULL, NULL); if (ex_buffer_size <= 0) { - pr_err("failed to calculating buffer size!\n"); + rga_err("failed to calculating buffer size!\n"); rga_dump_memory_parm(&external_buffer->memory_parm); return ex_buffer_size == 0 ? -EINVAL : ex_buffer_size; } @@ -408,7 +406,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_err("%s alloc internal_buffer error!\n", __func__); return -ENOMEM; } @@ -428,15 +426,15 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, break; } if (ret < 0) { - pr_err("%s core[%d] map dma buffer error!\n", - __func__, scheduler->core); + rga_err("%s core[%d] map dma buffer error!\n", + __func__, scheduler->core); goto free_buffer; } if (buffer->size < ex_buffer_size) { - pr_err("Only get buffer %ld byte from %s = 0x%lx, but current image required %d byte\n", - buffer->size, rga_get_memory_type_str(external_buffer->type), - (unsigned long)external_buffer->memory, ex_buffer_size); + rga_err("Only get buffer %ld byte from %s = 0x%lx, but current image required %d byte\n", + buffer->size, rga_get_memory_type_str(external_buffer->type), + (unsigned long)external_buffer->memory, ex_buffer_size); rga_dump_memory_parm(&external_buffer->memory_parm); ret = -EINVAL; goto unmap_buffer; @@ -457,7 +455,7 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, if (rga_mm_check_contiguous_sgt(buffer->sgt)) { phys_addr = sg_phys(buffer->sgt->sgl); if (phys_addr == 0) { - pr_err("%s get physical address error!", __func__); + rga_err("%s get physical address error!", __func__); ret = -EFAULT; goto unmap_buffer; } @@ -466,8 +464,8 @@ static int rga_mm_map_dma_buffer(struct rga_external_buffer *external_buffer, } if (!rga_mm_check_memory_limit(scheduler, mm_flag)) { - pr_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", - scheduler->core, mm_flag); + rga_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", + scheduler->core, mm_flag); ret = -EINVAL; goto unmap_buffer; } @@ -539,13 +537,13 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, scheduler = job ? job->scheduler : rga_drvdata->scheduler[rga_drvdata->map_scheduler_index]; if (scheduler == NULL) { - pr_err("Invalid scheduler device!\n"); + rga_err("Invalid scheduler device!\n"); return -EINVAL; } internal_buffer->current_mm = job ? job->mm : current->mm; if (internal_buffer->current_mm == NULL) { - pr_err("%s, cannot get current mm!\n", __func__); + rga_err("%s, cannot get current mm!\n", __func__); return -EFAULT; } mmgrab(internal_buffer->current_mm); @@ -556,14 +554,14 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, &internal_buffer->memory_parm, write_flag, internal_buffer->current_mm); if (ret < 0) { - pr_err("Can not alloc rga_virt_addr from 0x%lx\n", + rga_err("Can not alloc rga_virt_addr from 0x%lx\n", (unsigned long)external_buffer->memory); goto put_current_mm; } sgt = rga_alloc_sgt(virt_addr); if (IS_ERR(sgt)) { - pr_err("alloc sgt error!\n"); + rga_err("alloc sgt error!\n"); ret = PTR_ERR(sgt); goto free_virt_addr; } @@ -574,7 +572,7 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, if (rga_mm_check_contiguous_sgt(sgt)) { phys_addr = sg_phys(sgt->sgl); if (phys_addr == 0) { - pr_err("%s get physical address error!", __func__); + rga_err("%s get physical address error!", __func__); ret = -EFAULT; goto free_sgt; } @@ -590,15 +588,15 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, mm_flag |= RGA_MEM_FORCE_FLUSH_CACHE; if (!rga_mm_check_memory_limit(scheduler, mm_flag)) { - pr_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", - scheduler->core, mm_flag); + rga_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", + scheduler->core, mm_flag); ret = -EINVAL; goto free_sgt; } buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal dma_buffer error!\n", __func__); + rga_err("%s alloc internal dma_buffer error!\n", __func__); ret = -ENOMEM; goto free_sgt; } @@ -607,8 +605,8 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, case RGA_IOMMU: ret = rga_iommu_map_sgt(sgt, virt_addr->size, buffer, scheduler->dev); if (ret < 0) { - pr_err("%s core[%d] iommu_map virtual address error!\n", - __func__, scheduler->core); + rga_err("%s core[%d] iommu_map virtual address error!\n", + __func__, scheduler->core); goto free_dma_buffer; } @@ -618,7 +616,7 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, case RGA_MMU: ret = dma_map_sg(scheduler->dev, sgt->sgl, sgt->orig_nents, DMA_BIDIRECTIONAL); if (ret == 0) { - pr_err("%s core[%d] dma_map_sgt error! va = 0x%lx, nents = %d\n", + rga_err("%s core[%d] dma_map_sgt error! va = 0x%lx, nents = %d\n", __func__, scheduler->core, (unsigned long)virt_addr->addr, sgt->orig_nents); ret = -EINVAL; @@ -629,8 +627,8 @@ static int rga_mm_map_virt_addr(struct rga_external_buffer *external_buffer, if (mm_flag & RGA_MEM_PHYSICAL_CONTIGUOUS) break; - pr_err("Current %s[%d] cannot support physically discontinuous virtual address!\n", - rga_get_mmu_type_str(scheduler->data->mmu), scheduler->data->mmu); + rga_err("Current %s[%d] cannot support physically discontinuous virtual address!\n", + rga_get_mmu_type_str(scheduler->data->mmu), scheduler->data->mmu); ret = -EOPNOTSUPP; goto free_dma_buffer; } @@ -691,7 +689,7 @@ static int rga_mm_map_phys_addr(struct rga_external_buffer *external_buffer, scheduler = job ? job->scheduler : rga_drvdata->scheduler[rga_drvdata->map_scheduler_index]; if (scheduler == NULL) { - pr_err("Invalid scheduler device!\n"); + rga_err("Invalid scheduler device!\n"); return -EINVAL; } @@ -703,7 +701,7 @@ static int rga_mm_map_phys_addr(struct rga_external_buffer *external_buffer, internal_buffer->memory_parm.format, NULL, NULL, NULL); if (buffer_size <= 0) { - pr_err("Failed to get phys addr size!\n"); + rga_err("Failed to get phys addr size!\n"); rga_dump_memory_parm(&internal_buffer->memory_parm); return buffer_size == 0 ? -EINVAL : buffer_size; } @@ -714,21 +712,21 @@ static int rga_mm_map_phys_addr(struct rga_external_buffer *external_buffer, mm_flag |= RGA_MEM_UNDER_4G; if (!rga_mm_check_memory_limit(scheduler, mm_flag)) { - pr_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", - scheduler->core, mm_flag); + rga_err("scheduler core[%d] unsupported mm_flag[0x%x]!\n", + scheduler->core, mm_flag); return -EINVAL; } buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal dma buffer error!\n", __func__); + rga_err("%s alloc internal dma buffer error!\n", __func__); return -ENOMEM; } if (scheduler->data->mmu == RGA_IOMMU) { ret = rga_iommu_map(phys_addr, buffer_size, buffer, scheduler->dev); if (ret < 0) { - pr_err("%s core[%d] map phys_addr error!\n", __func__, scheduler->core); + rga_err("%s core[%d] map phys_addr error!\n", __func__, scheduler->core); goto free_dma_buffer; } } @@ -762,7 +760,7 @@ static int rga_mm_unmap_buffer(struct rga_internal_buffer *internal_buffer) rga_mm_unmap_phys_addr(internal_buffer); break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); return -EFAULT; } @@ -784,10 +782,8 @@ static int rga_mm_map_buffer(struct rga_external_buffer *external_buffer, internal_buffer->type = external_buffer->type; ret = rga_mm_map_dma_buffer(external_buffer, internal_buffer, job); - if (ret < 0) { - pr_err("%s map dma_buf error!\n", __func__); + if (ret < 0) return ret; - } internal_buffer->size = internal_buffer->dma_buffer->size - internal_buffer->dma_buffer->offset; @@ -797,10 +793,8 @@ static int rga_mm_map_buffer(struct rga_external_buffer *external_buffer, internal_buffer->type = RGA_VIRTUAL_ADDRESS; ret = rga_mm_map_virt_addr(external_buffer, internal_buffer, job, write_flag); - if (ret < 0) { - pr_err("%s map virtual address error!\n", __func__); + if (ret < 0) return ret; - } internal_buffer->size = internal_buffer->virt_addr->size - internal_buffer->virt_addr->offset; @@ -810,15 +804,17 @@ static int rga_mm_map_buffer(struct rga_external_buffer *external_buffer, internal_buffer->type = RGA_PHYSICAL_ADDRESS; ret = rga_mm_map_phys_addr(external_buffer, internal_buffer, job); - if (ret < 0) { - pr_err("%s map physical address error!\n", __func__); + if (ret < 0) return ret; - } internal_buffer->mm_flag |= RGA_MEM_NEED_USE_IOMMU; break; default: - pr_err("Illegal external buffer!\n"); + if (job) + rga_job_err(job, "Illegal external buffer!\n"); + else + rga_err("Illegal external buffer!\n"); + return -EFAULT; } @@ -938,7 +934,7 @@ rga_mm_lookup_external(struct rga_mm *mm_session, break; default: - pr_err("Illegal external buffer!\n"); + rga_err("Illegal external buffer!\n"); return NULL; } @@ -962,7 +958,7 @@ int rga_mm_lookup_flag(struct rga_mm *mm_session, uint64_t handle) output_buffer = rga_mm_lookup_handle(mm_session, handle); if (output_buffer == NULL) { - pr_err("This handle[%ld] is illegal.\n", (unsigned long)handle); + rga_err("This handle[%ld] is illegal.\n", (unsigned long)handle); return -EINVAL; } @@ -987,8 +983,9 @@ struct sg_table *rga_mm_lookup_sgt(struct rga_internal_buffer *buffer) void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) { - pr_info("handle = %d refcount = %d mm_flag = 0x%x\n", - dump_buffer->handle, kref_read(&dump_buffer->refcount), + rga_buf_log(dump_buffer, "type = %s, refcount = %d mm_flag = 0x%x\n", + rga_get_memory_type_str(dump_buffer->type), + kref_read(&dump_buffer->refcount), dump_buffer->mm_flag); switch (dump_buffer->type) { @@ -997,10 +994,9 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) if (rga_mm_is_invalid_dma_buffer(dump_buffer->dma_buffer)) break; - pr_info("dma_buffer:\n"); - pr_info("dma_buf = %p\n", + rga_buf_log(dump_buffer, "dma_buf = %p\n", dump_buffer->dma_buffer->dma_buf); - pr_info("iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", + rga_buf_log(dump_buffer, "iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", (unsigned long)dump_buffer->dma_buffer->iova, (unsigned long)dump_buffer->dma_buffer->dma_addr, (unsigned long)dump_buffer->dma_buffer->offset, @@ -1009,15 +1005,14 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) dump_buffer->dma_buffer->scheduler->core); if (dump_buffer->mm_flag & RGA_MEM_PHYSICAL_CONTIGUOUS) - pr_info("is contiguous, pa = 0x%lx\n", + rga_log("is contiguous, pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); break; case RGA_VIRTUAL_ADDRESS: if (dump_buffer->virt_addr == NULL) break; - pr_info("virtual address:\n"); - pr_info("va = 0x%lx, pages = %p, size = %ld\n", + rga_buf_log(dump_buffer, "va = 0x%lx, pages = %p, size = %ld\n", (unsigned long)dump_buffer->virt_addr->addr, dump_buffer->virt_addr->pages, dump_buffer->virt_addr->size); @@ -1025,7 +1020,7 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) if (rga_mm_is_invalid_dma_buffer(dump_buffer->dma_buffer)) break; - pr_info("iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", + rga_buf_log(dump_buffer, "iova = 0x%lx, dma_addr = 0x%lx, offset = 0x%lx, sgt = %p, size = %ld, map_core = 0x%x\n", (unsigned long)dump_buffer->dma_buffer->iova, (unsigned long)dump_buffer->dma_buffer->dma_addr, (unsigned long)dump_buffer->dma_buffer->offset, @@ -1034,15 +1029,14 @@ void rga_mm_dump_buffer(struct rga_internal_buffer *dump_buffer) dump_buffer->dma_buffer->scheduler->core); if (dump_buffer->mm_flag & RGA_MEM_PHYSICAL_CONTIGUOUS) - pr_info("is contiguous, pa = 0x%lx\n", + rga_buf_log(dump_buffer, "is contiguous, pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); break; case RGA_PHYSICAL_ADDRESS: - pr_info("physical address:\n"); - pr_info("pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); + rga_buf_log(dump_buffer, "pa = 0x%lx\n", (unsigned long)dump_buffer->phys_addr); break; default: - pr_err("Illegal external buffer!\n"); + rga_buf_err(dump_buffer, "Illegal buffer! type= %d\n", dump_buffer->type); break; } } @@ -1054,15 +1048,15 @@ void rga_mm_dump_info(struct rga_mm *mm_session) WARN_ON(!mutex_is_locked(&mm_session->lock)); - pr_info("rga mm info:\n"); + rga_log("rga mm info:\n"); - pr_info("buffer count = %d\n", mm_session->buffer_count); - pr_info("===============================================================\n"); + rga_log("buffer count = %d\n", mm_session->buffer_count); + rga_log("===============================================================\n"); idr_for_each_entry(&mm_session->memory_idr, dump_buffer, id) { rga_mm_dump_buffer(dump_buffer); - pr_info("---------------------------------------------------------------\n"); + rga_log("---------------------------------------------------------------\n"); } } @@ -1192,8 +1186,8 @@ static int rga_mm_set_mmu_base(struct rga_job *job, img_size = rga_image_size_cal(img->vir_w, img->vir_h, img->format, &yrgb_size, &uv_size, &v_size); if (img_size <= 0) { - pr_err("Image size cal error! width = %d, height = %d, format = %s\n", - img->vir_w, img->vir_h, rga_get_format_name(img->format)); + rga_job_err(job, "Image size cal error! width = %d, height = %d, format = %s\n", + img->vir_w, img->vir_h, rga_get_format_name(img->format)); return -EINVAL; } @@ -1212,23 +1206,23 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_count = yrgb_count + uv_count + v_count; if (page_count <= 0) { - pr_err("page count cal error! yrba = %d, uv = %d, v = %d\n", - yrgb_count, uv_count, v_count); + rga_job_err(job, "page count cal error! yrba = %d, uv = %d, v = %d\n", + yrgb_count, uv_count, v_count); return -EFAULT; } if (job->flags & RGA_JOB_USE_HANDLE) { order = get_order(page_count * sizeof(uint32_t *)); if (order >= MAX_ORDER) { - pr_err("Can not alloc pages with order[%d] for page_table, max_order = %d\n", - order, MAX_ORDER); + rga_job_err(job, "Can not alloc pages with order[%d] for page_table, max_order = %d\n", + order, MAX_ORDER); return -ENOMEM; } page_table = (uint32_t *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); if (page_table == NULL) { - pr_err("%s can not alloc pages for page_table, order = %d\n", - __func__, order); + rga_job_err(job, "%s can not alloc pages for page_table, order = %d\n", + __func__, order); return -ENOMEM; } } else { @@ -1236,7 +1230,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_table = rga_mmu_buf_get(rga_drvdata->mmu_base, page_count); if (page_table == NULL) { - pr_err("mmu_buf get error!\n"); + rga_err("mmu_buf get error!\n"); mutex_unlock(&rga_drvdata->lock); return -EFAULT; } @@ -1246,7 +1240,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->y_addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_job_err(job, "rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1254,7 +1248,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->uv_addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_job_err(job, "rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1262,7 +1256,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->v_addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_job_err(job, "rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1277,23 +1271,23 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_count = RGA_GET_PAGE_COUNT(img_size + img_offset); if (page_count < 0) { - pr_err("page count cal error! yrba = %d, uv = %d, v = %d\n", - yrgb_count, uv_count, v_count); + rga_job_err(job, "page count cal error! yrba = %d, uv = %d, v = %d\n", + yrgb_count, uv_count, v_count); return -EFAULT; } if (job->flags & RGA_JOB_USE_HANDLE) { order = get_order(page_count * sizeof(uint32_t *)); if (order >= MAX_ORDER) { - pr_err("Can not alloc pages with order[%d] for page_table, max_order = %d\n", - order, MAX_ORDER); + rga_job_err(job, "Can not alloc pages with order[%d] for page_table, max_order = %d\n", + order, MAX_ORDER); return -ENOMEM; } page_table = (uint32_t *)__get_free_pages(GFP_KERNEL | GFP_DMA32, order); if (page_table == NULL) { - pr_err("%s can not alloc pages for page_table, order = %d\n", - __func__, order); + rga_job_err(job, "%s can not alloc pages for page_table, order = %d\n", + __func__, order); return -ENOMEM; } } else { @@ -1301,7 +1295,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, page_table = rga_mmu_buf_get(rga_drvdata->mmu_base, page_count); if (page_table == NULL) { - pr_err("mmu_buf get error!\n"); + rga_job_err(job, "mmu_buf get error!\n"); mutex_unlock(&rga_drvdata->lock); return -EFAULT; } @@ -1311,7 +1305,7 @@ static int rga_mm_set_mmu_base(struct rga_job *job, sgt = rga_mm_lookup_sgt(job_buf->addr); if (sgt == NULL) { - pr_err("rga2 cannot get sgt from internal buffer!\n"); + rga_job_err(job, "rga2 cannot get sgt from internal buffer!\n"); ret = -EINVAL; goto err_free_page_table; } @@ -1343,8 +1337,8 @@ static int rga_mm_sync_dma_sg_for_device(struct rga_internal_buffer *buffer, scheduler = buffer->dma_buffer->scheduler; if (scheduler == NULL) { - pr_err("%s(%d), failed to get scheduler, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_job_err(job, "%s(%d), failed to get scheduler, core = 0x%x\n", + __func__, __LINE__, job->core); return -EFAULT; } @@ -1354,8 +1348,8 @@ static int rga_mm_sync_dma_sg_for_device(struct rga_internal_buffer *buffer, } else { sgt = rga_mm_lookup_sgt(buffer); if (sgt == NULL) { - pr_err("%s(%d), failed to get sgt, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_job_err(job, "%s(%d), failed to get sgt, core = 0x%x\n", + __func__, __LINE__, job->core); return -EINVAL; } @@ -1363,7 +1357,7 @@ static int rga_mm_sync_dma_sg_for_device(struct rga_internal_buffer *buffer, } if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], %s, flush CPU cache for device cost %lld us\n", + rga_job_log(job, "handle[%d], %s, flush CPU cache for device cost %lld us\n", buffer->handle, rga_get_dma_data_direction_str(dir), ktime_us_delta(ktime_get(), timestamp)); @@ -1380,8 +1374,8 @@ static int rga_mm_sync_dma_sg_for_cpu(struct rga_internal_buffer *buffer, scheduler = buffer->dma_buffer->scheduler; if (scheduler == NULL) { - pr_err("%s(%d), failed to get scheduler, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_job_err(job, "%s(%d), failed to get scheduler, core = 0x%x\n", + __func__, __LINE__, job->core); return -EFAULT; } @@ -1391,8 +1385,8 @@ static int rga_mm_sync_dma_sg_for_cpu(struct rga_internal_buffer *buffer, } else { sgt = rga_mm_lookup_sgt(buffer); if (sgt == NULL) { - pr_err("%s(%d), failed to get sgt, core = 0x%x\n", - __func__, __LINE__, job->core); + rga_job_err(job, "%s(%d), failed to get sgt, core = 0x%x\n", + __func__, __LINE__, job->core); return -EINVAL; } @@ -1400,7 +1394,7 @@ static int rga_mm_sync_dma_sg_for_cpu(struct rga_internal_buffer *buffer, } if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], %s, flush CPU cache for CPU cost %lld us\n", + rga_job_log(job, "handle[%d], %s, flush CPU cache for CPU cost %lld us\n", buffer->handle, rga_get_dma_data_direction_str(dir), ktime_us_delta(ktime_get(), timestamp)); @@ -1417,7 +1411,7 @@ static int rga_mm_get_buffer_info(struct rga_job *job, case RGA_IOMMU: addr = rga_mm_lookup_iova(internal_buffer); if (addr == 0) { - pr_err("core[%d] lookup buffer_type[0x%x] iova error!\n", + rga_job_err(job, "core[%d] lookup buffer_type[0x%x] iova error!\n", job->core, internal_buffer->type); return -EINVAL; } @@ -1441,7 +1435,7 @@ static int rga_mm_get_buffer_info(struct rga_job *job, addr = internal_buffer->phys_addr; break; default: - pr_err("Illegal external buffer!\n"); + rga_job_err(job, "Illegal external buffer!\n"); return -EFAULT; } break; @@ -1464,14 +1458,14 @@ static int rga_mm_get_buffer(struct rga_mm *mm, struct rga_internal_buffer *internal_buffer = NULL; if (handle == 0) { - pr_err("No buffer handle can be used!\n"); + rga_job_err(job, "No buffer handle can be used!\n"); return -EFAULT; } mutex_lock(&mm->lock); *buf = rga_mm_lookup_handle(mm, handle); if (*buf == NULL) { - pr_err("This handle[%ld] is illegal.\n", (unsigned long)handle); + rga_job_err(job, "This handle[%ld] is illegal.\n", (unsigned long)handle); mutex_unlock(&mm->lock); return -EFAULT; @@ -1481,7 +1475,7 @@ static int rga_mm_get_buffer(struct rga_mm *mm, kref_get(&internal_buffer->refcount); if (DEBUGGER_EN(MM)) { - pr_info("handle[%d] get info:\n", (int)handle); + rga_job_log(job, "handle[%d] get info:\n", (int)handle); rga_mm_dump_buffer(internal_buffer); } @@ -1489,13 +1483,14 @@ static int rga_mm_get_buffer(struct rga_mm *mm, ret = rga_mm_get_buffer_info(job, internal_buffer, channel_addr); if (ret < 0) { - pr_err("handle[%ld] failed to get internal buffer info!\n", (unsigned long)handle); + rga_job_err(job, "handle[%ld] failed to get internal buffer info!\n", + (unsigned long)handle); return ret; } if (internal_buffer->size < require_size) { ret = -EINVAL; - pr_err("Only get buffer %ld byte from handle[%ld], but current required %d byte\n", + rga_job_err(job, "Only get buffer %ld byte from handle[%ld], but current required %d byte\n", internal_buffer->size, (unsigned long)handle, require_size); goto put_internal_buffer; @@ -1509,7 +1504,7 @@ static int rga_mm_get_buffer(struct rga_mm *mm, */ ret = rga_mm_sync_dma_sg_for_device(internal_buffer, job, dir); if (ret < 0) { - pr_err("sync sgt for device error!\n"); + rga_job_err(job, "sync sgt for device error!\n"); goto put_internal_buffer; } } @@ -1532,10 +1527,10 @@ static void rga_mm_put_buffer(struct rga_mm *mm, { if (internal_buffer->mm_flag & RGA_MEM_FORCE_FLUSH_CACHE && dir != DMA_NONE) if (rga_mm_sync_dma_sg_for_cpu(internal_buffer, job, dir)) - pr_err("sync sgt for cpu error!\n"); + rga_job_err(job, "sync sgt for cpu error!\n"); if (DEBUGGER_EN(MM)) { - pr_info("handle[%d] put info:\n", (int)internal_buffer->handle); + rga_job_log(job, "handle[%d] put info:\n", (int)internal_buffer->handle); rga_mm_dump_buffer(internal_buffer); } @@ -1573,8 +1568,8 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, img_size = rga_image_size_cal(img->vir_w, img->vir_h, img->format, &yrgb_size, &uv_size, &v_size); if (img_size <= 0) { - pr_err("Image size cal error! width = %d, height = %d, format = %s\n", - img->vir_w, img->vir_h, rga_get_format_name(img->format)); + rga_job_err(job, "Image size cal error! width = %d, height = %d, format = %s\n", + img->vir_w, img->vir_h, rga_get_format_name(img->format)); return -EINVAL; } @@ -1585,7 +1580,8 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->yrgb_addr, &job_buf->y_addr, yrgb_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get y/rgb address info!\n", handle); + rga_job_err(job, "handle[%d] Can't get y/rgb address info!\n", + handle); return ret; } } @@ -1595,7 +1591,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->uv_addr, &job_buf->uv_addr, uv_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get uv address info!\n", handle); + rga_job_err(job, "handle[%d] Can't get uv address info!\n", handle); return ret; } } @@ -1605,7 +1601,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->v_addr, &job_buf->v_addr, v_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get uv address info!\n", handle); + rga_job_err(job, "handle[%d] Can't get uv address info!\n", handle); return ret; } } @@ -1615,7 +1611,8 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, ret = rga_mm_get_buffer(mm, job, handle, &img->yrgb_addr, &job_buf->addr, img_size, dir); if (ret < 0) { - pr_err("handle[%d] Can't get y/rgb address info!\n", handle); + rga_job_err(job, "handle[%d] Can't get y/rgb address info!\n", + handle); return ret; } } @@ -1627,7 +1624,7 @@ static int rga_mm_get_channel_handle_info(struct rga_mm *mm, rga_mm_is_need_mmu(job, job_buf->addr)) { ret = rga_mm_set_mmu_base(job, img, job_buf); if (ret < 0) { - pr_err("Can't set RGA2 MMU_BASE from handle!\n"); + rga_job_err(job, "Can't set RGA2 MMU_BASE from handle!\n"); rga_mm_put_channel_handle_info(mm, job, job_buf, dir); return ret; @@ -1651,21 +1648,21 @@ static int rga_mm_get_handle_info(struct rga_job *job) case BITBLT_MODE: case COLOR_PALETTE_MODE: if (unlikely(req->src.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] src0 channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->src.yrgb_addr); + rga_job_err(job, "render_mode[0x%x] src0 channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->src.yrgb_addr); return -EINVAL; } if (unlikely(req->dst.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] dst channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->dst.yrgb_addr); + rga_job_err(job, "render_mode[0x%x] dst channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->dst.yrgb_addr); return -EINVAL; } if (req->bsfilter_flag) { if (unlikely(req->pat.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] src1/pat channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->pat.yrgb_addr); + rga_job_err(job, "render_mode[0x%x] src1/pat channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->pat.yrgb_addr); return -EINVAL; } } @@ -1673,8 +1670,8 @@ static int rga_mm_get_handle_info(struct rga_job *job) break; case COLOR_FILL_MODE: if (unlikely(req->dst.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] dst channel handle[%ld] must is valid!", - req->render_mode, (unsigned long)req->dst.yrgb_addr); + rga_job_err(job, "render_mode[0x%x] dst channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->dst.yrgb_addr); return -EINVAL; } @@ -1683,14 +1680,14 @@ static int rga_mm_get_handle_info(struct rga_job *job) case UPDATE_PALETTE_TABLE_MODE: case UPDATE_PATTEN_BUF_MODE: if (unlikely(req->pat.yrgb_addr <= 0)) { - pr_err("render_mode[0x%x] lut/pat channel handle[%ld] must is valid!, req->render_mode", - req->render_mode, (unsigned long)req->pat.yrgb_addr); + rga_job_err(job, "render_mode[0x%x] lut/pat channel handle[%ld] must is valid!", + req->render_mode, (unsigned long)req->pat.yrgb_addr); return -EINVAL; } break; default: - pr_err("%s, unknown render mode!\n", __func__); + rga_job_err(job, "%s, unknown render mode!\n", __func__); break; } @@ -1699,7 +1696,7 @@ static int rga_mm_get_handle_info(struct rga_job *job) &job->src_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("Can't get src buffer info from handle!\n"); + rga_job_err(job, "Can't get src buffer info from handle!\n"); return ret; } } @@ -1709,7 +1706,7 @@ static int rga_mm_get_handle_info(struct rga_job *job) &job->dst_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("Can't get dst buffer info from handle!\n"); + rga_job_err(job, "Can't get dst buffer info from handle!\n"); return ret; } } @@ -1731,7 +1728,7 @@ static int rga_mm_get_handle_info(struct rga_job *job) DMA_BIDIRECTIONAL); } if (ret < 0) { - pr_err("Can't get pat buffer info from handle!\n"); + rga_job_err(job, "Can't get pat buffer info from handle!\n"); return ret; } } @@ -1770,15 +1767,15 @@ static int rga_mm_get_channel_external_buffer(int mmu_flag, /* Default unsupported multi-planar format */ external_buffer = kzalloc(sizeof(*external_buffer), GFP_KERNEL); if (external_buffer == NULL) { - pr_err("Cannot alloc job_buffer!\n"); + rga_err("Cannot alloc job_buffer!\n"); return -ENOMEM; } if (img_info->yrgb_addr) { dma_buf = dma_buf_get(img_info->yrgb_addr); if (IS_ERR(dma_buf)) { - pr_err("%s dma_buf_get fail fd[%lu]\n", - __func__, (unsigned long)img_info->yrgb_addr); + rga_err("%s dma_buf_get fail fd[%lu]\n", + __func__, (unsigned long)img_info->yrgb_addr); kfree(external_buffer); return -EINVAL; } @@ -1842,7 +1839,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 8) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, src0, &job->src_buffer); if (ret < 0) { - pr_err("Cannot get src0 channel buffer!\n"); + rga_job_err(job, "Cannot get src0 channel buffer!\n"); return ret; } } @@ -1851,7 +1848,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 10) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, dst, &job->dst_buffer); if (ret < 0) { - pr_err("Cannot get dst channel buffer!\n"); + rga_job_err(job, "Cannot get dst channel buffer!\n"); goto error_put_buffer; } } @@ -1860,7 +1857,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 9) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, src1, &job->src1_buffer); if (ret < 0) { - pr_err("Cannot get src1 channel buffer!\n"); + rga_job_err(job, "Cannot get src1 channel buffer!\n"); goto error_put_buffer; } } @@ -1869,7 +1866,7 @@ static int rga_mm_get_external_buffer(struct rga_job *job) mmu_flag = ((job->rga_command_base.mmu_info.mmu_flag >> 11) & 1); ret = rga_mm_get_channel_external_buffer(mmu_flag, els, &job->els_buffer); if (ret < 0) { - pr_err("Cannot get els channel buffer!\n"); + rga_job_err(job, "Cannot get els channel buffer!\n"); goto error_put_buffer; } } @@ -1886,10 +1883,10 @@ static void rga_mm_unmap_channel_job_buffer(struct rga_job *job, { if (job_buffer->addr->mm_flag & RGA_MEM_FORCE_FLUSH_CACHE && dir != DMA_NONE) if (rga_mm_sync_dma_sg_for_cpu(job_buffer->addr, job, dir)) - pr_err("sync sgt for cpu error!\n"); + rga_job_err(job, "sync sgt for cpu error!\n"); if (DEBUGGER_EN(MM)) { - pr_info("unmap buffer:\n"); + rga_job_log(job, "unmap buffer:\n"); rga_mm_dump_buffer(job_buffer->addr); } @@ -1910,31 +1907,31 @@ static int rga_mm_map_channel_job_buffer(struct rga_job *job, buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_job_err(job, "%s alloc internal_buffer error!\n", __func__); return -ENOMEM; } ret = rga_mm_map_buffer(job_buffer->ex_addr, buffer, job, write_flag); if (ret < 0) { - pr_err("job buffer map failed!\n"); + rga_job_err(job, "job buffer map failed!\n"); goto error_free_buffer; } if (DEBUGGER_EN(MM)) { - pr_info("map buffer:\n"); + rga_job_log(job, "map buffer:\n"); rga_mm_dump_buffer(buffer); } ret = rga_mm_get_buffer_info(job, buffer, &img->yrgb_addr); if (ret < 0) { - pr_err("Failed to get internal buffer info!\n"); + rga_job_err(job, "Failed to get internal buffer info!\n"); goto error_unmap_buffer; } if (buffer->mm_flag & RGA_MEM_FORCE_FLUSH_CACHE) { ret = rga_mm_sync_dma_sg_for_device(buffer, job, dir); if (ret < 0) { - pr_err("sync sgt for device error!\n"); + rga_job_err(job, "sync sgt for device error!\n"); goto error_unmap_buffer; } } @@ -1947,7 +1944,7 @@ static int rga_mm_map_channel_job_buffer(struct rga_job *job, rga_mm_is_need_mmu(job, job_buffer->addr)) { ret = rga_mm_set_mmu_base(job, img, job_buffer); if (ret < 0) { - pr_err("Can't set RGA2 MMU_BASE!\n"); + rga_job_err(job, "Can't set RGA2 MMU_BASE!\n"); job_buffer->addr = NULL; goto error_unmap_buffer; } @@ -1985,7 +1982,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) ret = rga_mm_get_external_buffer(job); if (ret < 0) { - pr_err("failed to get external buffer from job_cmd!\n"); + rga_job_err(job, "failed to get external buffer from job_cmd!\n"); return ret; } @@ -1996,7 +1993,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->src_buffer, DMA_TO_DEVICE, false); if (ret < 0) { - pr_err("src channel map job buffer failed!"); + rga_job_err(job, "src channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2006,7 +2003,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->dst_buffer, DMA_TO_DEVICE, true); if (ret < 0) { - pr_err("dst channel map job buffer failed!"); + rga_job_err(job, "dst channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2021,7 +2018,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->src1_buffer, dir, false); if (ret < 0) { - pr_err("src1 channel map job buffer failed!"); + rga_job_err(job, "src1 channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2031,7 +2028,7 @@ static int rga_mm_map_buffer_info(struct rga_job *job) &job->els_buffer, DMA_BIDIRECTIONAL, false); if (ret < 0) { - pr_err("els channel map job buffer failed!"); + rga_job_err(job, "els channel map job buffer failed!"); goto error_unmap_buffer; } } @@ -2055,7 +2052,7 @@ static void rga_mm_free_channel_fake_buffer(struct rga_job *job, return; if (DEBUGGER_EN(MM)) { - pr_info("free fake-buffer dump info:\n"); + rga_job_log(job, "free fake-buffer dump info:\n"); rga_mm_dump_buffer(buffer); } @@ -2078,7 +2075,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); if (buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_job_err(job, "%s alloc internal_buffer error!\n", __func__); return -ENOMEM; } @@ -2087,7 +2084,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, dma_buf = rga_dma_alloc_coherent(job->scheduler, size); if (dma_buf == NULL) { ret = -ENOMEM; - pr_err("%s failed to alloc dma_buf.\n", __func__); + rga_job_err(job, "%s failed to alloc dma_buf.\n", __func__); goto error_free_buffer; } @@ -2100,7 +2097,7 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, } if (!rga_mm_check_memory_limit(job->scheduler, mm_flag)) { - pr_err("%s scheduler core[%d] unsupported mm_flag[0x%x]!\n", + rga_job_err(job, "%s scheduler core[%d] unsupported mm_flag[0x%x]!\n", __func__, job->scheduler->core, mm_flag); ret = -EINVAL; goto error_free_dma_buf; @@ -2118,10 +2115,8 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, buffer->memory_parm.size = size; ret = rga_mm_get_buffer_info(job, buffer, &img->yrgb_addr); - if (ret < 0) { - pr_err("%s failed to get internal buffer info!\n", __func__); + if (ret < 0) goto error_free_dma_buf; - } rga_convert_addr(img, false); @@ -2131,14 +2126,13 @@ static int rga_mm_alloc_channel_fake_buffer(struct rga_job *job, rga_mm_is_need_mmu(job, job_buffer->addr)) { ret = rga_mm_set_mmu_base(job, img, job_buffer); if (ret < 0) { - pr_err("%s can't set RGA2 MMU_BASE!\n", __func__); job_buffer->addr = NULL; goto error_free_dma_buf; } } if (DEBUGGER_EN(MM)) { - pr_info("alloc fake-buffer dump info:\n"); + rga_job_log(job, "alloc fake-buffer dump info:\n"); rga_mm_dump_buffer(buffer); } @@ -2177,7 +2171,7 @@ static int rga_mm_alloc_fake_buffer(struct rga_job *job) ret = rga_mm_alloc_channel_fake_buffer(job, &req->src, &job->src_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("%s src channel map job buffer failed!", __func__); + rga_job_err(job, "%s src channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } @@ -2186,7 +2180,7 @@ static int rga_mm_alloc_fake_buffer(struct rga_job *job) ret = rga_mm_alloc_channel_fake_buffer(job, &req->dst, &job->dst_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("%s dst channel map job buffer failed!", __func__); + rga_job_err(job, "%s dst channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } @@ -2201,14 +2195,14 @@ static int rga_mm_alloc_fake_buffer(struct rga_job *job) ret = rga_mm_alloc_channel_fake_buffer(job, &req->pat, &job->src1_buffer, dir); if (ret < 0) { - pr_err("%s src1 channel map job buffer failed!", __func__); + rga_job_err(job, "%s src1 channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } else if (req->pat.yrgb_addr != 0 || req->pat.uv_addr != 0) { ret = rga_mm_alloc_channel_fake_buffer(job, &req->pat, &job->els_buffer, DMA_TO_DEVICE); if (ret < 0) { - pr_err("%s els channel map job buffer failed!", __func__); + rga_job_err(job, "%s els channel map job buffer failed!", __func__); goto error_free_fake_buffer; } } @@ -2234,8 +2228,8 @@ int rga_mm_map_job_info(struct rga_job *job) return ret; if (DEBUGGER_EN(TIME)) - pr_info("request[%d], alloc fake buffer cost %lld us\n", - job->request_id, ktime_us_delta(ktime_get(), timestamp)); + rga_job_log(job, "alloc fake buffer cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); job->flags &= ~RGA_JOB_USE_HANDLE; job->flags |= RGA_JOB_DEBUG_FAKE_BUFFER; @@ -2246,23 +2240,23 @@ int rga_mm_map_job_info(struct rga_job *job) if (job->flags & RGA_JOB_USE_HANDLE) { ret = rga_mm_get_handle_info(job); if (ret < 0) { - pr_err("failed to get buffer from handle\n"); + rga_job_err(job, "failed to get buffer from handle\n"); return ret; } if (DEBUGGER_EN(TIME)) - pr_info("request[%d], get buffer_handle info cost %lld us\n", - job->request_id, ktime_us_delta(ktime_get(), timestamp)); + rga_job_log(job, "get buffer_handle info cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); } else { ret = rga_mm_map_buffer_info(job); if (ret < 0) { - pr_err("failed to map buffer\n"); + rga_job_err(job, "failed to map buffer\n"); return ret; } if (DEBUGGER_EN(TIME)) - pr_info("request[%d], map buffer cost %lld us\n", - job->request_id, ktime_us_delta(ktime_get(), timestamp)); + rga_job_log(job, "map buffer cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); } return 0; @@ -2276,8 +2270,8 @@ void rga_mm_unmap_job_info(struct rga_job *job) rga_mm_free_fake_buffer(job); if (DEBUGGER_EN(TIME)) - pr_info("request[%d], free fake buffer cost %lld us\n", - job->request_id, ktime_us_delta(ktime_get(), timestamp)); + rga_job_log(job, "free fake buffer cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); return; } @@ -2286,14 +2280,14 @@ void rga_mm_unmap_job_info(struct rga_job *job) rga_mm_put_handle_info(job); if (DEBUGGER_EN(TIME)) - pr_info("request[%d], put buffer_handle info cost %lld us\n", - job->request_id, ktime_us_delta(ktime_get(), timestamp)); + rga_job_log(job, "put buffer_handle info cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); } else { rga_mm_unmap_buffer_info(job); if (DEBUGGER_EN(TIME)) - pr_info("request[%d], unmap buffer cost %lld us\n", - job->request_id, ktime_us_delta(ktime_get(), timestamp)); + rga_job_log(job, "unmap buffer cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); } } @@ -2317,7 +2311,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, mm = rga_drvdata->mm; if (mm == NULL) { - pr_err("rga mm is null!\n"); + rga_err("rga mm is null!\n"); return -EFAULT; } @@ -2331,7 +2325,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, mutex_unlock(&mm->lock); if (DEBUGGER_EN(MM)) { - pr_info("import existing buffer:\n"); + rga_buf_log(internal_buffer, "import existing buffer:\n"); rga_mm_dump_buffer(internal_buffer); } @@ -2343,7 +2337,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, /* finally, map and cached external_buffer in rga_mm */ internal_buffer = kzalloc(sizeof(struct rga_internal_buffer), GFP_KERNEL); if (internal_buffer == NULL) { - pr_err("%s alloc internal_buffer error!\n", __func__); + rga_err("%s alloc internal_buffer error!\n", __func__); mutex_unlock(&mm->lock); return -ENOMEM; @@ -2365,7 +2359,7 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, new_id = idr_alloc_cyclic(&mm->memory_idr, internal_buffer, 1, 0, GFP_NOWAIT); idr_preload_end(); if (new_id < 0) { - pr_err("internal_buffer alloc id failed!\n"); + rga_err("internal_buffer alloc id failed!\n"); ret = new_id; mutex_unlock(&mm->lock); @@ -2376,15 +2370,15 @@ int rga_mm_import_buffer(struct rga_external_buffer *external_buffer, mm->buffer_count++; if (DEBUGGER_EN(MM)) { - pr_info("import buffer:\n"); + rga_buf_log(internal_buffer, "import buffer:\n"); rga_mm_dump_buffer(internal_buffer); } mutex_unlock(&mm->lock); if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], import buffer cost %lld us\n", - internal_buffer->handle, ktime_us_delta(ktime_get(), timestamp)); + rga_buf_log(internal_buffer, "import buffer cost %lld us\n", + ktime_us_delta(ktime_get(), timestamp)); return internal_buffer->handle; @@ -2402,7 +2396,7 @@ int rga_mm_release_buffer(uint32_t handle) mm = rga_drvdata->mm; if (mm == NULL) { - pr_err("rga mm is null!\n"); + rga_err("rga mm is null!\n"); return -EFAULT; } @@ -2411,21 +2405,21 @@ int rga_mm_release_buffer(uint32_t handle) /* Find the buffer that has been imported */ internal_buffer = rga_mm_lookup_handle(mm, handle); if (IS_ERR_OR_NULL(internal_buffer)) { - pr_err("This is not a buffer that has been imported, handle = %d\n", (int)handle); + rga_err("This is not a buffer that has been imported, handle = %d\n", (int)handle); mutex_unlock(&mm->lock); return -ENOENT; } if (DEBUGGER_EN(MM)) { - pr_info("release buffer:\n"); + rga_buf_log(internal_buffer, "release buffer:\n"); rga_mm_dump_buffer(internal_buffer); } kref_put(&internal_buffer->refcount, rga_mm_kref_release_buffer); if (DEBUGGER_EN(TIME)) - pr_info("handle[%d], release buffer cost %lld us\n", + rga_log("handle[%d]: release buffer cost %lld us\n", handle, ktime_us_delta(ktime_get(), timestamp)); mutex_unlock(&mm->lock); @@ -2441,7 +2435,7 @@ int rga_mm_session_release_buffer(struct rga_session *session) mm = rga_drvdata->mm; if (mm == NULL) { - pr_err("rga mm is null!\n"); + rga_err("rga mm is null!\n"); return -EFAULT; } @@ -2449,7 +2443,7 @@ int rga_mm_session_release_buffer(struct rga_session *session) idr_for_each_entry(&mm->memory_idr, buffer, i) { if (session == buffer->session) { - pr_err("[tgid:%d] Destroy handle[%d] when the user exits\n", + rga_err("[tgid:%d] Destroy handle[%d] when the user exits\n", session->tgid, buffer->handle); rga_mm_force_releaser_buffer(buffer); } diff --git a/drivers/video/rockchip/rga3/rga_policy.c b/drivers/video/rockchip/rga3/rga_policy.c index 6194b0fccba1..4cb3bff7ee49 100644 --- a/drivers/video/rockchip/rga3/rga_policy.c +++ b/drivers/video/rockchip/rga3/rga_policy.c @@ -5,8 +5,6 @@ * Author: Huang Lee */ -#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; }