Lines Matching +full:en +full:- +full:host1
1 diff -Naur a/arch/arm/boot/Makefile b/arch/arm/boot/Makefile
2 --- a/arch/arm/boot/Makefile 2022-05-27 17:20:13.781877650 +0800
3 +++ b/arch/arm/boot/Makefile 2022-05-31 11:56:47.693259679 +0800
4 @@ -16,6 +16,7 @@
12 @@ -24,10 +25,12 @@
13 ZRELADDR := $(zreladdr-y)
14 PARAMS_PHYS := $(params_phys-y)
15 INITRD_PHYS := $(initrd_phys-y)
16 +DTB_OBJS ?= $(dtb-y)
21 -targets := Image zImage xipImage bootpImage uImage
22 +targets := Image zImage xipImage bootpImage uImage zImage-dtb
26 @@ -66,6 +69,10 @@
30 +$(obj)/zImage-dtb: $(obj)/zImage $(DTB_OBJS_FULL) FORCE
37 @@ -86,7 +93,7 @@
41 -$(obj)/uImage: $(obj)/zImage FORCE
42 +$(obj)/uImage: $(obj)/zImage-dtb FORCE
46 diff -Naur a/arch/arm64/boot/dts/amlogic/Makefile b/arch/arm64/boot/dts/amlogic/Makefile
47 --- a/arch/arm64/boot/dts/amlogic/Makefile 2022-05-27 17:20:14.013880643 +0800
48 +++ b/arch/arm64/boot/dts/amlogic/Makefile 2022-06-04 12:12:41.042068628 +0800
49 @@ -1,50 +1,2 @@
50 # SPDX-License-Identifier: GPL-2.0
51 -dtb-$(CONFIG_ARCH_MESON) += meson-axg-s400.dtb
52 -dtb-$(CONFIG_ARCH_MESON) += meson-g12a-sei510.dtb
53 -dtb-$(CONFIG_ARCH_MESON) += meson-g12a-u200.dtb
54 -dtb-$(CONFIG_ARCH_MESON) += meson-g12a-x96-max.dtb
55 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-gtking.dtb
56 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-gtking-pro.dtb
57 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-a311d-khadas-vim3.dtb
58 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-s922x-khadas-vim3.dtb
59 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-odroid-n2.dtb
60 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-odroid-n2-plus.dtb
61 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-ugoos-am6.dtb
62 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-kii-pro.dtb
63 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-nanopi-k2.dtb
64 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-nexbox-a95x.dtb
65 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-odroidc2.dtb
66 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-p200.dtb
67 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-p201.dtb
68 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-vega-s95-pro.dtb
69 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-vega-s95-meta.dtb
70 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-vega-s95-telos.dtb
71 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-wetek-hub.dtb
72 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-wetek-play2.dtb
73 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s805x-libretech-ac.dtb
74 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-hwacom-amazetv.dtb
75 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-khadas-vim.dtb
76 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-libretech-cc.dtb
77 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-libretech-cc-v2.dtb
78 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-nexbox-a95x.dtb
79 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-p212.dtb
80 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-p230.dtb
81 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-p231.dtb
82 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-phicomm-n1.dtb
83 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-sml5442tw.dtb
84 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s805x-p241.dtb
85 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905w-p281.dtb
86 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905w-tx3-mini.dtb
87 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-libretech-pc.dtb
88 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-khadas-vim2.dtb
89 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-nexbox-a1.dtb
90 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-q200.dtb
91 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-q201.dtb
92 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-rbox-pro.dtb
93 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-s912-libretech-pc.dtb
94 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-vega-s96.dtb
95 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-wetek-core2.dtb
96 -dtb-$(CONFIG_ARCH_MESON) += meson-sm1-sei610.dtb
97 -dtb-$(CONFIG_ARCH_MESON) += meson-sm1-khadas-vim3l.dtb
98 -dtb-$(CONFIG_ARCH_MESON) += meson-sm1-odroid-c4.dtb
99 -dtb-$(CONFIG_ARCH_MESON) += meson-a1-ad401.dtb
100 +dtb-$(CONFIG_ARCH_MESON) += meson-g12b-unionpi-tiger.dtb
102 diff -Naur a/arch/arm64/boot/dts/amlogic/meson-g12b-a311d.dtsi b/arch/arm64/boot/dts/amlogic/meson-…
103 --- a/arch/arm64/boot/dts/amlogic/meson-g12b-a311d.dtsi 2022-05-27 17:20:14.013880643 +0800
104 +++ b/arch/arm64/boot/dts/amlogic/meson-g12b-a311d.dtsi 2022-05-31 11:56:47.693259679 +0800
105 @@ -11,26 +11,6 @@
106 compatible = "operating-points-v2";
107 opp-shared;
109 - opp-100000000 {
110 - opp-hz = /bits/ 64 <100000000>;
111 - opp-microvolt = <731000>;
112 - };
113 -
114 - opp-250000000 {
115 - opp-hz = /bits/ 64 <250000000>;
116 - opp-microvolt = <731000>;
117 - };
118 -
119 - opp-500000000 {
120 - opp-hz = /bits/ 64 <500000000>;
121 - opp-microvolt = <731000>;
122 - };
123 -
124 - opp-667000000 {
125 - opp-hz = /bits/ 64 <667000000>;
126 - opp-microvolt = <731000>;
127 - };
128 -
129 opp-1000000000 {
130 opp-hz = /bits/ 64 <1000000000>;
131 opp-microvolt = <761000>;
132 @@ -65,31 +45,21 @@
133 opp-hz = /bits/ 64 <1800000000>;
134 opp-microvolt = <1001000>;
136 - };
137 -
138 - cpub_opp_table_1: opp-table-1 {
139 - compatible = "operating-points-v2";
140 - opp-shared;
142 - opp-100000000 {
143 - opp-hz = /bits/ 64 <100000000>;
144 - opp-microvolt = <731000>;
145 + opp-1908000000 {
146 + opp-hz = /bits/ 64 <1908000000>;
147 + opp-microvolt = <1022000>;
150 - opp-250000000 {
151 - opp-hz = /bits/ 64 <250000000>;
152 - opp-microvolt = <731000>;
153 - };
154 -
155 - opp-500000000 {
156 - opp-hz = /bits/ 64 <500000000>;
157 - opp-microvolt = <731000>;
158 + opp-2016000000 {
159 + opp-hz = /bits/ 64 <2016000000>;
160 + opp-microvolt = <1022000>;
164 - opp-667000000 {
165 - opp-hz = /bits/ 64 <667000000>;
166 - opp-microvolt = <731000>;
167 - };
168 + cpub_opp_table_1: opp-table-1 {
169 + compatible = "operating-points-v2";
170 + opp-shared;
172 opp-1000000000 {
173 opp-hz = /bits/ 64 <1000000000>;
174 @@ -126,24 +96,34 @@
175 opp-microvolt = <831000>;
178 - opp-1908000000 {
179 - opp-hz = /bits/ 64 <1908000000>;
180 - opp-microvolt = <861000>;
181 - };
182 -
183 - opp-2016000000 {
184 - opp-hz = /bits/ 64 <2016000000>;
185 - opp-microvolt = <911000>;
186 - };
187 -
188 - opp-2108000000 {
189 - opp-hz = /bits/ 64 <2108000000>;
190 - opp-microvolt = <951000>;
191 - };
192 -
193 - opp-2208000000 {
194 - opp-hz = /bits/ 64 <2208000000>;
195 - opp-microvolt = <1011000>;
196 - };
197 + opp-1908000000 {
198 + opp-hz = /bits/ 64 <1908000000>;
199 + opp-microvolt = <861000>;
202 + opp-2016000000 {
203 + opp-hz = /bits/ 64 <2016000000>;
204 + opp-microvolt = <911000>;
207 + opp-2108000000 {
208 + opp-hz = /bits/ 64 <2108000000>;
209 + opp-microvolt = <951000>;
212 + opp-2208000000 {
213 + opp-hz = /bits/ 64 <2208000000>;
214 + opp-microvolt = <1011000>;
217 + opp-2304000000 {
218 + opp-hz = /bits/ 64 <2304000000>;
219 + opp-microvolt = <1022000>;
222 + opp-2400000000 {
223 + opp-hz = /bits/ 64 <2400000000>;
224 + opp-microvolt = <1022000>;
228 diff -Naur a/arch/arm64/boot/dts/amlogic/meson-g12b-unionpi-tiger.dts b/arch/arm64/boot/dts/amlogic…
229 --- a/arch/arm64/boot/dts/amlogic/meson-g12b-unionpi-tiger.dts 1970-01-01 08:00:00.000000000 +0800
230 +++ b/arch/arm64/boot/dts/amlogic/meson-g12b-unionpi-tiger.dts 2022-07-04 13:57:46.707580803 +0800
231 @@ -0,0 +1,489 @@
232 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
239 +/dts-v1/;
241 +#include "meson-g12b-a311d.dtsi"
242 +#include "meson-unionpi-tiger.dtsi"
243 +#include "meson-g12b-unionpi-tiger.dtsi"
248 + amlogic-dt-id = "g12b_w400_b";
250 + reserved-memory {
252 + compatible = "shared-dma-pool";
256 + linux,contiguous-region;
260 + compatible = "shared-dma-pool";
264 + linux,contiguous-region;
268 + compatible = "shared-dma-pool";
272 + linux,contiguous-region;
276 + compatible = "shared-dma-pool";
281 + linux,contiguous-region;
286 + compatible = "amlogic, codec-mm-reserved";
289 + //no-map;
299 + dev_name = "amlogic-canvas";
315 + clock-names = "parser_top",
327 + memory-region = <&codec_mm_cma &codec_mm_reserved>;
335 + #address-cells=<1>;
336 + #size-cells=<1>;
371 + interrupt-names = "vsync",
384 + interrupt-names = "mailbox_2";
388 + compatible = "amlogic, ge2d-g12a";
392 + interrupt-names = "ge2d";
396 + clock-names = "clk_vapb_0",
409 + clock-names = "cts_vipnanoq_axi_clk_composite",
412 + interrupt-names = "galcore";
419 + reg-names = "NN_REG","NN_SRAM","NN_MEM0",
424 + memory-region = <&galcore_reserved>;
429 + #address-cells=<2>;
430 + #size-cells=<2>;
464 + compatible = "amlogic, bt-dev";
472 + compatible = "amlogic, wifi-dev";
480 + part-0 = <&logo>;
481 + part-1 = <&updater>;
482 + part-2 = <&misc>;
483 + part-3 = <&dto>;
484 + part-4 = <&cri_data>;
485 + part-5 = <¶m>;
486 + part-6 = <&boot>;
487 + part-7 = <&rsv>;
488 + part-8 = <&tee>;
489 + part-9 = <&vendor>;
490 + part-10 = <&odm>;
491 + part-11 = <&system>;
492 + part-12 = <&cache>;
493 + part-13 = <&data>;
583 + unifykey-num = <17>;
584 + unifykey-index-0 = <&keysn_0>;
585 + unifykey-index-1 = <&keysn_1>;
586 + unifykey-index-2 = <&keysn_2>;
587 + unifykey-index-3 = <&keysn_3>;
588 + unifykey-index-4 = <&keysn_4>;
589 + unifykey-index-5 = <&keysn_5>;
590 + unifykey-index-6 = <&keysn_6>;
591 + unifykey-index-7 = <&keysn_7>;
592 + unifykey-index-8 = <&keysn_8>;
593 + unifykey-index-9 = <&keysn_9>;
594 + unifykey-index-10= <&keysn_10>;
595 + unifykey-index-11= <&keysn_11>;
596 + unifykey-index-12= <&keysn_12>;
597 + unifykey-index-13= <&keysn_13>;
598 + unifykey-index-14= <&keysn_14>;
599 + unifykey-index-15= <&keysn_15>;
600 + unifykey-index-16= <&keysn_16>;
603 + key-name = "usid";
604 + key-device = "normal";
605 + key-permit = "read","write","del";
608 + key-name = "mac";
609 + key-device = "normal";
610 + key-permit = "read","write","del";
613 + key-name = "hdcp";
614 + key-device = "secure";
615 + key-type = "sha1";
616 + key-permit = "read","write","del";
619 + key-name = "secure_boot_set";
620 + key-device = "efuse";
621 + key-permit = "write";
624 + key-name = "mac_bt";
625 + key-device = "normal";
626 + key-permit = "read","write","del";
627 + key-type = "mac";
630 + key-name = "mac_wifi";
631 + key-device = "normal";
632 + key-permit = "read","write","del";
633 + key-type = "mac";
636 + key-name = "hdcp2_tx";
637 + key-device = "normal";
638 + key-permit = "read","write","del";
641 + key-name = "hdcp2_rx";
642 + key-device = "normal";
643 + key-permit = "read","write","del";
646 + key-name = "widevinekeybox";
647 + key-device = "secure";
648 + key-permit = "read","write","del";
651 + key-name = "deviceid";
652 + key-device = "normal";
653 + key-permit = "read","write","del";
656 + key-name = "hdcp22_fw_private";
657 + key-device = "secure";
658 + key-permit = "read","write","del";
661 + key-name = "PlayReadykeybox25";
662 + key-device = "secure";
663 + key-permit = "read","write","del";
666 + key-name = "prpubkeybox";// PlayReady
667 + key-device = "secure";
668 + key-permit = "read","write","del";
671 + key-name = "prprivkeybox";// PlayReady
672 + key-device = "secure";
673 + key-permit = "read","write","del";
676 + key-name = "netflix_mgkid";
677 + key-device = "secure";
678 + key-permit = "read","write","del";
681 + key-name = "eth_exphy_para";
682 + key-device = "normal";
683 + key-permit = "read","write","del";
686 + key-name = "um_factory_para";
687 + key-device = "normal";
688 + key-permit = "read","write","del";
695 + sensor-name = "imx219"; /*ov5647,imx290;os08a10;imx227;imx307;imx219*/
696 + pinctrl-names="default";
698 + clock-names = "g12a_24m";
704 + sensor-name = "imx219"; /*ov5647,imx290;os08a10;imx227;imx307;imx219*/
710 + temper-line-offset = <0x1680>;
711 + temper-buf-size = <12>;
712 + temper-frame-num = <1>;
713 + temper-frame-size = <0xBDD800>;
714 + memory-region = <&isp_cma_reserved>;
719 + memory-region = <&adapt_cma_reserved>;
721 diff -Naur a/arch/arm64/boot/dts/amlogic/meson-g12b-unionpi-tiger.dtsi b/arch/arm64/boot/dts/amlogi…
722 --- a/arch/arm64/boot/dts/amlogic/meson-g12b-unionpi-tiger.dtsi 1970-01-01 08:00:00.000000000 +0800
723 +++ b/arch/arm64/boot/dts/amlogic/meson-g12b-unionpi-tiger.dtsi 2022-05-31 11:56:47.693259679 +0800
724 @@ -0,0 +1,101 @@
725 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
733 + vddcpu_a: regulator-vddcpu-a {
734 + compatible = "pwm-regulator";
736 + regulator-name = "VDDCPU_A";
737 + regulator-min-microvolt = <721000>;
738 + regulator-max-microvolt = <1022000>;
739 + regulator-ramp-delay = <10>;
741 + vin-supply = <&dc_in>;
744 + pwm-dutycycle-range = <100 0>;
746 + regulator-boot-on;
747 + regulator-always-on;
750 + vddcpu_b: regulator-vddcpu-b {
751 + compatible = "pwm-regulator";
753 + regulator-name = "VDDCPU_B";
754 + regulator-min-microvolt = <721000>;
755 + regulator-max-microvolt = <1022000>;
756 + regulator-ramp-delay = <10>;
758 + vin-supply = <&dc_in>;
761 + pwm-dutycycle-range = <100 0>;
763 + regulator-boot-on;
764 + regulator-always-on;
769 + cpu-supply = <&vddcpu_b>;
770 + operating-points-v2 = <&cpu_opp_table_0>;
772 + clock-latency = <50000>;
776 + cpu-supply = <&vddcpu_b>;
777 + operating-points-v2 = <&cpu_opp_table_0>;
779 + clock-latency = <50000>;
783 + cpu-supply = <&vddcpu_a>;
784 + operating-points-v2 = <&cpub_opp_table_1>;
786 + clock-latency = <50000>;
790 + cpu-supply = <&vddcpu_a>;
791 + operating-points-v2 = <&cpub_opp_table_1>;
793 + clock-latency = <50000>;
797 + cpu-supply = <&vddcpu_a>;
798 + operating-points-v2 = <&cpub_opp_table_1>;
800 + clock-latency = <50000>;
804 + cpu-supply = <&vddcpu_a>;
805 + operating-points-v2 = <&cpub_opp_table_1>;
807 + clock-latency = <50000>;
811 + pinctrl-0 = <&pwm_a_e_pins>;
812 + pinctrl-names = "default";
814 + clock-names = "clkin0";
819 + pinctrl-0 = <&pwm_ao_c_6_pins>, <&pwm_ao_d_e_pins>;
820 + pinctrl-names = "default";
822 + clock-names = "clkin1";
826 diff -Naur a/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi b/arch/arm64/boot/dts/amlogic/meson-…
827 --- a/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi 2022-05-27 17:20:14.013880643 +0800
828 +++ b/arch/arm64/boot/dts/amlogic/meson-g12-common.dtsi 2022-06-18 13:48:23.734525427 +0800
829 @@ -17,6 +17,12 @@
830 #address-cells = <2>;
831 #size-cells = <2>;
840 #address-cells = <2>;
841 #size-cells = <2>;
842 @@ -43,6 +49,10 @@
846 + system-suspend {
847 + compatible = "amlogic,meson-gx-pm";
851 compatible = "amlogic,meson-gxbb-efuse";
853 @@ -55,10 +65,6 @@
854 gpu_opp_table: gpu-opp-table {
855 compatible = "operating-points-v2";
857 - opp-124999998 {
858 - opp-hz = /bits/ 64 <124999998>;
859 - opp-microvolt = <800000>;
860 - };
861 opp-249999996 {
862 opp-hz = /bits/ 64 <249999996>;
863 opp-microvolt = <800000>;
864 @@ -96,15 +102,19 @@
868 - secmon_reserved: secmon@5000000 {
869 - reg = <0x0 0x05000000 0x0 0x300000>;
870 - no-map;
872 + compatible = "shared-dma-pool";
876 + alloc-ranges = <0x0 0x05000000 0x0 0x3400000>;
877 + clear-map;
881 compatible = "shared-dma-pool";
883 - size = <0x0 0x10000000>;
886 linux,cma-default;
888 @@ -113,6 +123,16 @@
889 sm: secure-monitor {
890 compatible = "amlogic,meson-gxbb-sm";
895 + memory-region = <&secmon_reserved>;
904 compatible = "simple-bus";
905 @@ -224,6 +244,8 @@
906 "timing-adjustment";
907 rx-fifo-depth = <4096>;
908 tx-fifo-depth = <2048>;
910 + reset-names = "stmmaceth";
914 @@ -1681,12 +1703,31 @@
918 - <250000000>,
924 + compatible = "amlogic,g12a-mipi-dphy-analog";
925 + #phy-cells = <0>;
932 + compatible = "amlogic,axg-mipi-dphy";
935 + clock-names = "pclk";
937 + reset-names = "phy";
939 + phy-names = "analog";
940 + #phy-cells = <0>;
945 compatible = "amlogic,g12a-usb3-pcie-phy";
947 @@ -1930,6 +1971,33 @@
951 + uart_ao_b_1_pins: uart-ao-b-1 {
956 + bias-disable;
960 + uart_ao_b_2_pins: uart-ao-b-2 {
965 + bias-disable;
969 + uart_ao_b_cts_rts_pins: uart-ao-b-cts-rts {
974 + bias-disable;
978 pwm_a_e_pins: pwm-a-e {
981 @@ -2003,7 +2071,7 @@
985 - vrtc: rtc@0a8 {
987 compatible = "amlogic,meson-vrtc";
990 @@ -2144,6 +2212,15 @@
991 remote-endpoint = <&hdmi_tx_in>;
1000 + remote-endpoint = <&mipi_dsi_in>;
1005 gic: interrupt-controller@ffc01000 {
1006 @@ -2181,6 +2258,49 @@
1007 amlogic,channel-interrupts = <64 65 66 67 68 69 70 71>;
1010 + mipi_dsi: mipi-dsi@7000 {
1011 + compatible = "amlogic,meson-g12a-dw-mipi-dsi";
1014 + reset-names = "top";
1017 + clock-names = "pclk", "px_clk";
1019 + phy-names = "dphy";
1020 + #address-cells = <1>;
1021 + #size-cells = <0>;
1024 + assigned-clocks = <&clkc CLKID_MIPI_DSI_PXCLK_SEL>;
1025 + assigned-clock-parents = <&clkc CLKID_GP0_PLL>;
1028 + #address-cells = <1>;
1029 + #size-cells = <0>;
1036 + remote-endpoint = <&dpi_out>;
1048 + compatible = "amlogic,meson-gxbb-wdt";
1054 compatible = "amlogic,meson-g12a-spicc";
1056 @@ -2305,6 +2425,7 @@
1058 clock-names = "xtal", "pclk", "baud";
1060 + fifo-size = <128>;
1064 @@ -2400,6 +2521,62 @@
1065 operating-points-v2 = <&gpu_opp_table>;
1066 #cooling-cells = <2>;
1069 + isp_sc: isp-sc@ff655400 {
1070 + compatible = "amlogic, isp-sc";
1072 + reg-names = "isp_sc";
1074 + interrupt-names = "isp_sc";
1080 + reg-names = "ISP";
1081 + isp-efuse = <0xff630038 0x4000>;
1083 + interrupt-names = "ISP";
1084 + temper-buf-size = <24>;
1087 + clock-names = "cts_mipi_isp_clk_composite",
1089 + link-device = <&isp_sc>;
1092 + adapter: isp-adapter@ff650000 {
1093 + compatible = "amlogic, isp-adapter";
1095 + reg-names = "adapter";
1097 + interrupt-names = "adapter-irq";
1101 + phycsi: phy-csi@ff650000 {
1102 + compatible = "amlogic, phy-csi";
1108 + reg-names = "csi2_phy0", "csi2_phy1", "aphy_reg",
1116 + interrupt-names = "phy0-irq",
1117 + "phy1-irq",
1118 + "csi-host0-intr2",
1119 + "csi-host0-intr1",
1120 + "csi-host1-intr2",
1121 + "csi-host1-intr1";
1122 + link-device = <&adapter>;
1127 @@ -2422,4 +2599,10 @@
1128 #clock-cells = <0>;
1132 + compatible = "fixed-clock";
1133 + clock-output-names = "osc8M";
1134 + clock-frequency = <8000000>;
1135 + #clock-cells = <0>;
1138 diff -Naur a/arch/arm64/boot/dts/amlogic/meson-unionpi-tiger.dtsi b/arch/arm64/boot/dts/amlogic/mes…
1139 --- a/arch/arm64/boot/dts/amlogic/meson-unionpi-tiger.dtsi 1970-01-01 08:00:00.000000000 +0800
1140 +++ b/arch/arm64/boot/dts/amlogic/meson-unionpi-tiger.dtsi 2022-06-04 12:16:05.318220487 +0800
1141 @@ -0,0 +1,805 @@
1142 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
1149 +#include <dt-bindings/input/input.h>
1150 +#include <dt-bindings/gpio/meson-g12a-gpio.h>
1151 +#include <dt-bindings/sound/meson-g12a-toacodec.h>
1152 +#include <dt-bindings/sound/meson-g12a-tohdmitx.h>
1153 +#include <dt-bindings/clock/g12a-clkc.h>
1154 +#include <dt-bindings/reset/amlogic,meson-g12a-reset.h>
1155 +#include <dt-bindings/clock/axg-audio-clkc.h>
1173 + stdout-path = "serial0:115200n8";
1181 + gpio-keys-polled {
1182 + compatible = "gpio-keys-polled";
1183 + #address-cells = <1>;
1184 + #size-cells = <0>;
1185 + poll-interval = <100>;
1187 + power-button {
1195 + compatible = "gpio-leds";
1197 + /* USB-OTG Switch GPIO */
1198 + usb-switch {
1201 + default-state = "on";
1205 + emmc_pwrseq: emmc-pwrseq {
1206 + compatible = "mmc-pwrseq-emmc";
1207 + reset-gpios = <&gpio BOOT_12 GPIO_ACTIVE_LOW>;
1210 + sdio_pwrseq: sdio-pwrseq {
1211 + compatible = "mmc-pwrseq-simple";
1212 + reset-gpios = <&gpio GPIOX_6 GPIO_ACTIVE_LOW>;
1215 + dc_in: regulator-dc_in {
1216 + compatible = "regulator-fixed";
1217 + regulator-name = "DC_IN";
1218 + regulator-min-microvolt = <12000000>;
1219 + regulator-max-microvolt = <12000000>;
1220 + regulator-always-on;
1223 + vcc_5v: regulator-vcc_5v {
1224 + compatible = "regulator-fixed";
1225 + regulator-name = "VCC_5V";
1226 + regulator-min-microvolt = <5000000>;
1227 + regulator-max-microvolt = <5000000>;
1228 + vin-supply = <&dc_in>;
1232 + enable-active-high;
1235 + vsys_3v3: regulator-vsys_3v3 {
1236 + compatible = "regulator-fixed";
1237 + regulator-name = "VSYS_3V3";
1238 + regulator-min-microvolt = <3300000>;
1239 + regulator-max-microvolt = <3300000>;
1240 + vin-supply = <&dc_in>;
1241 + regulator-always-on;
1244 + usb_pwr_en: regulator-usb-pwr-en {
1245 + compatible = "regulator-fixed";
1246 + regulator-name = "USB_PWR_EN";
1247 + regulator-min-microvolt = <5000000>;
1248 + regulator-max-microvolt = <5000000>;
1249 + vin-supply = <&vcc_5v>;
1250 + enable-active-high;
1253 + usb1_pow: regulator-usb1-pow {
1254 + compatible = "regulator-fixed";
1255 + regulator-name = "USB1_POW";
1256 + regulator-min-microvolt = <5000000>;
1257 + regulator-max-microvolt = <5000000>;
1258 + vin-supply = <&vcc_5v>;
1259 + enable-active-high;
1262 + vddao_3v3: regulator-vddao-3v3 {
1263 + compatible = "regulator-fixed";
1264 + regulator-name = "VDDAO_3V3";
1265 + regulator-min-microvolt = <3300000>;
1266 + regulator-max-microvolt = <3300000>;
1267 + vin-supply = <&dc_in>;
1268 + regulator-always-on;
1271 + vddao_1v8: regulator-vddao_1v8 {
1272 + compatible = "regulator-fixed";
1273 + regulator-name = "VDDAO_1V8";
1274 + regulator-min-microvolt = <1800000>;
1275 + regulator-max-microvolt = <1800000>;
1276 + vin-supply = <&vddao_3v3>;
1277 + regulator-always-on;
1280 + usb_pwr: regulator-usb_pwr {
1281 + compatible = "regulator-fixed";
1282 + regulator-name = "USB_PWR";
1283 + regulator-min-microvolt = <5000000>;
1284 + regulator-max-microvolt = <5000000>;
1285 + vin-supply = <&vcc_5v>;
1286 + enable-active-high;
1289 + hdmi-connector {
1290 + compatible = "hdmi-connector";
1296 + remote-endpoint = <&hdmi_tx_tmds_out>;
1301 + spdif_dit: audio-codec-1 {
1302 + #sound-dai-cells = <0>;
1303 + compatible = "linux,spdif-dit";
1305 + sound-name-prefix = "DIT";
1309 + compatible = "amlogic,axg-sound-card";
1310 + model = "UNIONPI-TIGER";
1311 + audio-widgets = "Line", "Lineout",
1313 + audio-aux-devs = <&tdmout_b>, <&tdmout_c>,
1315 + audio-routing = "TDMOUT_B IN 0", "FRDDR_A OUT 1",
1340 + /* tdmin -> toddr */
1356 + assigned-clocks = <&clkc CLKID_MPLL2>,
1359 + assigned-clock-parents = <0>, <0>, <0>;
1360 + assigned-clock-rates = <294912000>,
1365 + dai-link-0 {
1366 + sound-dai = <&frddr_a>;
1369 + dai-link-1 {
1370 + sound-dai = <&frddr_b>;
1373 + dai-link-2 {
1374 + sound-dai = <&frddr_c>;
1377 + dai-link-3 {
1378 + sound-dai = <&toddr_a>;
1381 + dai-link-4 {
1382 + sound-dai = <&toddr_b>;
1385 + dai-link-5 {
1386 + sound-dai = <&toddr_c>;
1390 + dai-link-6 {
1391 + sound-dai = <&tdmif_b>;
1392 + dai-format = "i2s";
1393 + dai-tdm-slot-tx-mask-0 = <1 1>;
1394 + dai-tdm-slot-rx-mask-1 = <1 1>;
1395 + dai-tdm-slot-tx-mask-2 = <1 1>;
1396 + dai-tdm-slot-tx-mask-3 = <1 1>;
1397 + mclk-fs = <256>;
1399 + codec-0 {
1400 + sound-dai = <&tohdmitx TOHDMITX_I2S_IN_B>;
1403 + codec-1 {
1404 + sound-dai = <&toacodec TOACODEC_IN_B>;
1408 + codec-2 {
1409 + sound-dai = <&nau8540>;
1414 + dai-link-7 {
1415 + sound-dai = <&tdmif_c>;
1416 + dai-format = "i2s";
1417 + dai-tdm-slot-tx-mask-0 = <1 1>;
1418 + mclk-fs = <256>;
1420 + codec-0 {
1421 + sound-dai = <&tohdmitx TOHDMITX_I2S_IN_C>;
1424 + codec-1 {
1425 + sound-dai = <&toacodec TOACODEC_IN_C>;
1430 + dai-link-8 {
1431 + sound-dai = <&tohdmitx TOHDMITX_I2S_OUT>;
1434 + sound-dai = <&hdmi_tx>;
1439 + dai-link-9 {
1440 + sound-dai = <&toacodec TOACODEC_OUT>;
1443 + sound-dai = <&acodec>;
1454 + AVDD-supply = <&vddao_1v8>;
1467 + pinctrl-0 = <&cec_ao_a_h_pins>;
1468 + pinctrl-names = "default";
1470 + hdmi-phandle = <&hdmi_tx>;
1474 + pinctrl-0 = <&cec_ao_b_h_pins>;
1475 + pinctrl-names = "default";
1477 + hdmi-phandle = <&hdmi_tx>;
1481 + external_phy: ethernet-phy@0 {
1484 + max-speed = <1000>;
1485 + reset-assert-us = <10000>;
1486 + reset-deassert-us = <80000>;
1487 + reset-gpios = <&gpio GPIOZ_15 (GPIO_ACTIVE_LOW | GPIO_OPEN_DRAIN)>;
1489 + interrupt-parent = <&gpio_intc>;
1496 + pinctrl-0 = <ð_pins>, <ð_rgmii_pins>;
1497 + pinctrl-names = "default";
1499 + phy-mode = "rgmii";
1500 + phy-handle = <&external_phy>;
1501 + amlogic,tx-delay-ns = <2>;
1518 + pinctrl-0 = <&hdmitx_hpd_pins>, <&hdmitx_ddc_pins>;
1519 + pinctrl-names = "default";
1520 + hdmi-supply = <&vcc_5v>;
1525 + remote-endpoint = <&hdmi_connector_in>;
1532 + assigned-clocks = <&clkc CLKID_GP0_PLL>,
1535 + assigned-clock-parents = <0>,
1538 + assigned-clock-rates = <720000000>,
1545 + power-supply = <&vddao_3v3>;
1547 + power-supply = <&vcc_5v>;*/
1552 + remote-endpoint = <&dsi_out_panel>;
1568 + remote-endpoint = <&dsi_in_panel>;
1574 + pinctrl-names = "default";
1575 + pinctrl-0 = <&i2c2_sck_x_pins>, <&i2c2_sda_x_pins>;
1576 + clock-frequency = <100000>; /* default 100k */
1581 + pinctrl-names="default";
1582 + pinctrl-0 = <&i2c3_sck_a_pins>, <&i2c3_sda_a_pins>;
1583 + clock-frequency = <100000>; /* default 100k */
1589 + pinctrl-names = "default";
1590 + #address-cells = <1>;
1591 + #size-cells = <0>;
1595 + #address-cells = <1>;
1596 + #size-cells = <0>;
1602 + #address-cells = <1>;
1603 + #size-cells = <0>;
1609 + #address-cells = <1>;
1610 + #size-cells = <0>;
1616 + gpio-controller;
1617 + #gpio-cells = <0x02>;
1619 + gpio-line-names = "WAKEUP_OUT", "PWR_ON_N", "WAKEUP_IN", "W_DISABLE_N",
1620 + "PMU_RSTIN_N", "9342_RST", "SEN-SYNC1", "", "MUTE",
1628 + gpio-controller;
1629 + #gpio-cells = <0x02>;
1631 + gpio-line-names = "GPIO_01", "GPIO_02", "GPIO_03", "GPIO_04",
1639 + #sound-dai-cells = <0>;
1646 + #sound-dai-cells = <0>;
1648 + sound-name-prefix = "Linein";
1654 + #sound-dai-cells = <0>;
1662 + compatible = "edt,edt-ft5406";
1664 + touchscreen-size-x = < 800 >;
1665 + touchscreen-size-y = < 480 >;
1666 + touchscreen-inverted-x = < 1 >;
1667 + touchscreen-inverted-y = < 1 >;
1672 + compatible = "chipone,icn6211-i2c";
1677 + sensor-i2c@6c {
1678 + compatible = "arm, i2c-sensor";
1680 + reg-names = "i2c-sensor";
1681 + slave-addr = <0x6c>;
1682 + reg-type = <2>;
1683 + reg-data-type = <1>;
1684 + link-device = <&phycsi>;
1688 + /*icm-20948*/
1690 + #address-cells = <1>;
1691 + #size-cells = <0>;
1700 + pinctrl-names = "default";
1701 + pinctrl-0 = <&i2c_ao_sck_pins>, <&i2c_ao_sda_pins>;
1702 + clock-frequency = <400000>;
1708 + wakeup-source;
1718 + pinctrl-0 = <&pwm_ao_a_pins>;
1719 + pinctrl-names = "default";
1721 + clock-names = "clkin0";
1726 + vref-supply = <&vddao_1v8>;
1732 + compatible = "amlogic,meson-axg-mmc";
1733 + pinctrl-0 = <&emmc_ctrl_pins>, <&emmc_data_8b_pins>, <&emmc_ds_pins>;
1734 + pinctrl-1 = <&emmc_clk_gate_pins>;
1735 + pinctrl-names = "default", "clk-gate";
1737 + bus-width = <8>;
1738 + cap-mmc-highspeed;
1739 + mmc-ddr-1_8v;
1740 + mmc-hs200-1_8v;
1741 + max-frequency = <200000000>;
1742 + disable-wp;
1744 + mmc-pwrseq = <&emmc_pwrseq>;
1745 + vmmc-supply = <&vddao_3v3>;
1746 + vqmmc-supply = <&vddao_1v8>;
1752 + compatible = "amlogic,meson-axg-mmc";
1753 + pinctrl-0 = <&sdcard_c_pins>;
1754 + pinctrl-1 = <&sdcard_clk_gate_c_pins>;
1755 + pinctrl-names = "default", "clk-gate";
1757 + bus-width = <4>;
1758 + cap-sd-highspeed;
1759 + max-frequency = <50000000>;
1760 + disable-wp;
1762 + cd-gpios = <&gpio GPIOC_6 GPIO_ACTIVE_LOW>;
1763 + vmmc-supply = <&vddao_3v3>;
1764 + vqmmc-supply = <&vddao_3v3>;
1770 + pinctrl-0 = <&sdio_pins>;
1771 + pinctrl-1 = <&sdio_clk_gate_pins>;
1772 + pinctrl-names = "default", "clk-gate";
1773 + #address-cells = <1>;
1774 + #size-cells = <0>;
1776 + bus-width = <4>;
1777 + cap-sd-highspeed;
1778 + sd-uhs-sdr104;
1779 + max-frequency = <167000000>;
1781 + non-removable;
1782 + disable-wp;
1785 + keep-power-in-suspend;
1787 + mmc-pwrseq = <&sdio_pwrseq>;
1789 + vmmc-supply = <&vddao_3v3>;
1790 + vqmmc-supply = <&vddao_1v8>;
1798 + pinctrl-0 = <&tdm_b_sclk_pins>, <&tdm_b_fs_pins>,
1800 + pinctrl-names = "default";
1802 + assigned-clocks = <&clkc_audio AUD_CLKID_TDM_MCLK_PAD0>,
1805 + assigned-clock-parents = <&clkc_audio AUD_CLKID_MST_B_MCLK>,
1808 + assigned-clock-rates = <0>, <0>, <0>;
1867 + pinctrl-0 = <&uart_ao_a_pins>;
1868 + pinctrl-names = "default";
1874 + pinctrl-0 = <&uart_ao_b_2_pins>;
1875 + pinctrl-names = "default";
1881 + pinctrl-0 = <&uart_a_pins>;
1882 + pinctrl-names = "default";
1895 + phy-supply = <&usb1_pow>;
1900 + phy-supply = <&usb1_pow>;
1905 + phy-supply = <&usb_pwr>;
1911 + vbus-supply = <&usb_pwr_en>;
1916 + pinctrl-names = "default","gpio_periphs";
1917 + pinctrl-0 = <&spicc0_x_pins>;
1918 + pinctrl-1 = <&spicc0_ss0_x_pins>;
1920 + cs-gpios = <&gpio GPIOX_10 GPIO_ACTIVE_LOW>;
1926 + spi-max-frequency = <10000000>;
1932 + pinctrl-names = "default";
1933 + pinctrl-0 = <&spicc1_pins>;
1935 + cs-gpios = <&gpio GPIOH_6 GPIO_ACTIVE_LOW>;
1942 + spi-max-frequency = <5000000>;
1943 + interrupt-parent = <&gpio_intc>;
1947 diff -Naur a/arch/arm64/boot/dts/Makefile b/arch/arm64/boot/dts/Makefile
1948 --- a/arch/arm64/boot/dts/Makefile 2022-05-27 17:20:14.009880591 +0800
1949 +++ b/arch/arm64/boot/dts/Makefile 2022-05-31 11:56:47.697259643 +0800
1950 @@ -30,3 +30,5 @@
1951 subdir-y += toshiba
1952 subdir-y += xilinx
1953 subdir-y += zte
1955 +clean-files := dts/*.dtb *.dtb
1956 diff -Naur a/arch/arm64/boot/Makefile b/arch/arm64/boot/Makefile
1957 --- a/arch/arm64/boot/Makefile 2022-05-27 17:20:14.009880591 +0800
1958 +++ b/arch/arm64/boot/Makefile 2022-05-31 11:56:47.697259643 +0800
1959 @@ -16,7 +16,20 @@
1961 OBJCOPYFLAGS_Image :=-O binary -R .note -R .note.gnu.build-id -R .comment -S
1963 -targets := Image Image.bz2 Image.gz Image.lz4 Image.lzma Image.lzo
1964 +targets := Image Image.bz2 Image.gz Image.lz4 Image.lzma Image.lzo Image.gz-dtb
1968 +dtb-$(CONFIG_OF_ALL_DTBS) := $(patsubst $(dtstree)/%.dts,%.dtb, $(foreach d,$(dts-dirs), $(wildcar…
1974 +DTB_LIST := $(dtb-y)
1981 @@ -24,6 +37,9 @@
1985 +$(obj)/Image-dtb: $(obj)/Image $(DTB_OBJS) FORCE
1991 @@ -36,10 +52,35 @@
1995 -install:
1996 +$(obj)/Image.gz-dtb: $(obj)/Image.gz $(DTB_OBJS) FORCE
2003 +if [ $(words $(UIMAGE_LOADADDR)) -ne 1 ]; then \
2011 + @rm -f $(obj)/uImage
2025 -zinstall:
2029 diff -Naur a/arch/arm64/include/asm/kernel-pgtable.h b/arch/arm64/include/asm/kernel-pgtable.h
2030 --- a/arch/arm64/include/asm/kernel-pgtable.h 2022-05-27 17:20:14.061881262 +0800
2031 +++ b/arch/arm64/include/asm/kernel-pgtable.h 2022-05-31 11:56:47.705259573 +0800
2032 @@ -86,7 +86,7 @@
2036 -#define INIT_DIR_SIZE (PAGE_SIZE * EARLY_PAGES(KIMAGE_VADDR, _end))
2041 diff -Naur a/arch/arm64/kernel/head.S b/arch/arm64/kernel/head.S
2042 --- a/arch/arm64/kernel/head.S 2022-05-27 17:20:14.065881314 +0800
2043 +++ b/arch/arm64/kernel/head.S 2022-05-31 11:56:47.705259573 +0800
2044 @@ -36,10 +36,14 @@
2046 #include "efi-header.S"
2048 -#define __PHYS_OFFSET KERNEL_START
2049 +#define __PHYS_OFFSET (KERNEL_START - TEXT_OFFSET)
2051 -#if (PAGE_OFFSET & 0x1fffff) != 0
2061 @@ -73,7 +77,7 @@
2065 - .quad 0 // Image load offset from start of RAM, little-endian
2066 + le64sym _kernel_offset_le // Image load offset from start of RAM, little-endian
2067 le64sym _kernel_size_le // Effective size of kernel image, little-endian
2068 le64sym _kernel_flags_le // Informative flags, little-endian
2070 @@ -379,7 +383,7 @@
2074 - mov_q x5, KIMAGE_VADDR // compile time __va(_text)
2079 @@ -471,7 +475,7 @@
2083 - .quad _text
2084 + .quad _text - TEXT_OFFSET
2088 diff -Naur a/arch/arm64/kernel/image.h b/arch/arm64/kernel/image.h
2089 --- a/arch/arm64/kernel/image.h 2022-05-27 17:20:14.069881366 +0800
2090 +++ b/arch/arm64/kernel/image.h 2022-05-31 11:56:47.705259573 +0800
2091 @@ -62,6 +62,7 @@
2094 DEFINE_IMAGE_LE64(_kernel_size_le, _end - _text); \
2099 diff -Naur a/arch/arm64/kernel/Makefile b/arch/arm64/kernel/Makefile
2100 --- a/arch/arm64/kernel/Makefile 2022-05-27 17:20:14.065881314 +0800
2101 +++ b/arch/arm64/kernel/Makefile 2022-05-31 11:56:47.705259573 +0800
2102 @@ -3,6 +3,8 @@
2106 +CPPFLAGS_vmlinux.lds := -DTEXT_OFFSET=$(TEXT_OFFSET)
2107 +AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
2108 CFLAGS_armv8_deprecated.o := -I$(src)
2111 diff -Naur a/arch/arm64/kernel/vmlinux.lds.S b/arch/arm64/kernel/vmlinux.lds.S
2112 --- a/arch/arm64/kernel/vmlinux.lds.S 2022-05-27 17:20:14.073881416 +0800
2113 +++ b/arch/arm64/kernel/vmlinux.lds.S 2022-05-31 11:56:47.705259573 +0800
2114 @@ -115,7 +115,7 @@
2118 - . = KIMAGE_VADDR;
2123 @@ -305,4 +305,4 @@
2125 * If padding is applied before .head.text, virt<->phys conversions will fail.
2127 -ASSERT(_text == KIMAGE_VADDR, "HEAD is misaligned")
2129 diff -Naur a/arch/arm64/Makefile b/arch/arm64/Makefile
2130 --- a/arch/arm64/Makefile 2022-05-27 17:20:14.009880591 +0800
2131 +++ b/arch/arm64/Makefile 2022-05-31 11:56:47.705259573 +0800
2132 @@ -11,6 +11,9 @@
2133 # Copyright (C) 1995-2001 by Russell King
2135 LDFLAGS_vmlinux :=--no-undefined -X
2136 +CPPFLAGS_vmlinux.lds = -DTEXT_OFFSET=$(TEXT_OFFSET)
2138 +OBJCOPYFLAGS :=-O binary -R .note -R .note.gnu.build-id -R .comment -S
2141 # Pass --no-apply-dynamic-relocs to restore pre-binutils-2.27 behaviour
2142 @@ -96,6 +99,11 @@
2143 asm-arch := armv8.4-a
2147 +# make sure to pass the newest target architecture to -march.
2148 +asm-arch := armv8.5-a
2151 ifdef asm-arch
2152 KBUILD_CFLAGS += -Wa,-march=$(asm-arch) \
2153 -DARM64_ASM_ARCH='"$(asm-arch)"'
2154 @@ -134,6 +142,9 @@
2156 head-y := arch/arm64/kernel/head.o
2164 @@ -144,13 +155,15 @@
2165 KBUILD_CPPFLAGS += -DKASAN_SHADOW_SCALE_SHIFT=$(KASAN_SHADOW_SCALE_SHIFT)
2166 KBUILD_AFLAGS += -DKASAN_SHADOW_SCALE_SHIFT=$(KASAN_SHADOW_SCALE_SHIFT)
2170 core-y += arch/arm64/
2171 libs-y := arch/arm64/lib/ $(libs-y)
2172 libs-$(CONFIG_EFI_STUB) += $(objtree)/drivers/firmware/efi/libstub/lib.a
2176 -KBUILD_IMAGE := $(boot)/Image.gz
2181 diff -Naur a/arch/powerpc/platforms/85xx/mpc85xx_pm_ops.c b/arch/powerpc/platforms/85xx/mpc85xx_pm_…
2182 --- a/arch/powerpc/platforms/85xx/mpc85xx_pm_ops.c 2022-06-30 21:35:01.784330920 +0800
2183 +++ b/arch/powerpc/platforms/85xx/mpc85xx_pm_ops.c 2022-05-27 17:20:14.357885080 +0800
2184 @@ -94,8 +94,9 @@
2186 return -ENOMEM;
2188 - qoriq_pm_ops = &mpc85xx_pm_ops;
2195 diff -Naur a/arch/x86/include/asm/page_64_types.h b/arch/x86/include/asm/page_64_types.h
2196 --- a/arch/x86/include/asm/page_64_types.h 2022-06-30 21:35:01.784330920 +0800
2197 +++ b/arch/x86/include/asm/page_64_types.h 2022-05-27 17:20:14.513887093 +0800
2198 @@ -15,7 +15,7 @@
2202 -#define EXCEPTION_STACK_ORDER (1 + KASAN_STACK_ORDER)
2207 diff -Naur a/arch/x86/kernel/cpu/bugs.c b/arch/x86/kernel/cpu/bugs.c
2208 --- a/arch/x86/kernel/cpu/bugs.c 2022-07-04 18:32:52.121159105 +0800
2209 +++ b/arch/x86/kernel/cpu/bugs.c 2022-05-27 17:20:14.525887248 +0800
2210 @@ -1091,7 +1091,6 @@
2212 …n, data leak possible. See https://www.kernel.org/doc/html/latest/admin-guide/hw-vuln/mds.html for…
2213 …n, data leak possible. See https://www.kernel.org/doc/html/latest/admin-guide/hw-vuln/tsx_async_ab…
2214 -#define MMIO_MSG_SMT "MMIO Stale Data CPU bug present and SMT on, data leak possible. See https://…
2218 @@ -1136,16 +1135,6 @@
2222 - switch (mmio_mitigation) {
2223 - case MMIO_MITIGATION_VERW:
2224 - case MMIO_MITIGATION_UCODE_NEEDED:
2225 - if (sched_smt_active())
2226 - pr_warn_once(MMIO_MSG_SMT);
2227 - break;
2228 - case MMIO_MITIGATION_OFF:
2229 - break;
2230 - }
2231 -
2235 diff -Naur a/arch/x86/kvm/hyperv.c b/arch/x86/kvm/hyperv.c
2236 --- a/arch/x86/kvm/hyperv.c 2022-07-04 18:32:52.121159105 +0800
2237 +++ b/arch/x86/kvm/hyperv.c 2022-05-27 17:20:14.541887454 +0800
2238 @@ -207,7 +207,7 @@
2242 - if (!synic->active && (!host || data))
2243 + if (!synic->active && !host)
2246 trace_kvm_hv_synic_set_msr(vcpu->vcpu_id, msr, data, host);
2247 @@ -253,9 +253,6 @@
2251 - if (!synic->active)
2252 - break;
2253 -
2254 for (i = 0; i < ARRAY_SIZE(synic->sint); i++)
2257 @@ -639,7 +636,7 @@
2261 - if (!synic->active && (!host || config))
2262 + if (!synic->active && !host)
2265 trace_kvm_hv_stimer_set_config(stimer_to_vcpu(stimer)->vcpu_id,
2266 @@ -663,7 +660,7 @@
2270 - if (!synic->active && (!host || count))
2271 + if (!synic->active && !host)
2274 trace_kvm_hv_stimer_set_count(stimer_to_vcpu(stimer)->vcpu_id,
2275 diff -Naur a/drivers/clk/meson/clk-mux.c b/drivers/clk/meson/clk-mux.c
2276 --- a/drivers/clk/meson/clk-mux.c 1970-01-01 08:00:00.000000000 +0800
2277 +++ b/drivers/clk/meson/clk-mux.c 2022-05-31 11:56:47.725259396 +0800
2278 @@ -0,0 +1,214 @@
2280 + * drivers/amlogic/clk/clk-mux.c
2297 +#include <linux/clk-provider.h>
2306 +#include "clk-mux.h"
2313 + if (mux->flags & CLK_MUX_BIG_ENDIAN)
2314 + return ioread32be(mux->reg);
2316 + return readl(mux->reg);
2321 + if (mux->flags & CLK_MUX_BIG_ENDIAN)
2322 + iowrite32be(val, mux->reg);
2324 + writel(val, mux->reg);
2335 + * FIXME need a mux-specific flag to determine if val is bitwise or
2341 + val = clk_mux_readl(mux) >> mux->shift;
2342 + val &= mux->mask;
2344 + if (mux->table) {
2348 + if (mux->table[i] == val)
2350 + return -EINVAL;
2353 + if (val && (mux->flags & CLK_MUX_INDEX_BIT))
2354 + val = ffs(val) - 1;
2356 + if (val && (mux->flags & CLK_MUX_INDEX_ONE))
2357 + val--;
2360 + return -EINVAL;
2371 + if (mux->table) {
2372 + index = mux->table[index];
2374 + if (mux->flags & CLK_MUX_INDEX_BIT)
2377 + if (mux->flags & CLK_MUX_INDEX_ONE)
2381 + if (mux->lock)
2382 + spin_lock_irqsave(mux->lock, flags);
2384 + __acquire(mux->lock);
2386 + if (mux->flags & CLK_MUX_HIWORD_MASK) {
2387 + val = mux->mask << (mux->shift + 16);
2390 + val &= ~(mux->mask << mux->shift);
2393 + val |= index << mux->shift;
2396 + if (mux->lock)
2397 + spin_unlock_irqrestore(mux->lock, flags);
2399 + __release(mux->lock);
2416 + clk_set_parent(hw->clk, parent_hw->clk);
2432 + if ((num_parents == 2) && (mux->flags == CLK_PARENT_ALTERNATE)) {
2439 + ret = clk_set_rate(best_parent->clk, parent_req.rate);
2449 + clk_prepare(best_parent->clk);
2450 + clk_enable(best_parent->clk);
2460 + if (mux->flags & CLK_SET_RATE_PARENT) {
2472 + return -EINVAL;
2475 + req->best_parent_hw = best_parent;
2477 + req->best_parent_rate = best;
2478 + req->rate = best;
2493 diff -Naur a/drivers/clk/meson/clk-mux.h b/drivers/clk/meson/clk-mux.h
2494 --- a/drivers/clk/meson/clk-mux.h 1970-01-01 08:00:00.000000000 +0800
2495 +++ b/drivers/clk/meson/clk-mux.h 2022-05-31 11:56:47.725259396 +0800
2496 @@ -0,0 +1,19 @@
2497 +/* SPDX-License-Identifier: GPL-2.0 */
2506 +#include <linux/clk-provider.h>
2516 diff -Naur a/drivers/clk/meson/clk-pll.c b/drivers/clk/meson/clk-pll.c
2517 --- a/drivers/clk/meson/clk-pll.c 2022-05-27 17:20:14.749890137 +0800
2518 +++ b/drivers/clk/meson/clk-pll.c 2022-05-31 11:56:47.725259396 +0800
2519 @@ -283,6 +283,8 @@
2520 delay--;
2525 return -ETIMEDOUT;
2528 @@ -339,6 +341,9 @@
2530 meson_parm_write(clk->map, &pll->en, 1);
2533 + udelay(pll->rst_delay_us);
2536 meson_parm_write(clk->map, &pll->rst, 0);
2538 diff -Naur a/drivers/clk/meson/clk-pll.h b/drivers/clk/meson/clk-pll.h
2539 --- a/drivers/clk/meson/clk-pll.h 2022-05-27 17:20:14.749890137 +0800
2540 +++ b/drivers/clk/meson/clk-pll.h 2022-05-31 11:56:47.725259396 +0800
2541 @@ -41,6 +41,7 @@
2549 diff -Naur a/drivers/clk/meson/g12a.c b/drivers/clk/meson/g12a.c
2550 --- a/drivers/clk/meson/g12a.c 2022-05-27 17:20:14.749890137 +0800
2551 +++ b/drivers/clk/meson/g12a.c 2022-05-31 11:56:47.725259396 +0800
2552 @@ -15,6 +15,7 @@
2558 #include "clk-mpll.h"
2559 #include "clk-pll.h"
2560 @@ -23,8 +24,9 @@
2561 #include "vid-pll-div.h"
2562 #include "meson-eeclk.h"
2564 +#include "g12a-vcodec-clk.h"
2566 -static DEFINE_SPINLOCK(meson_clk_lock);
2571 @@ -1602,20 +1604,21 @@
2575 - .min = 125,
2576 - .max = 255,
2588 - { .reg = HHI_GP0_PLL_CNTL3, .def = 0x48681c00 },
2589 - { .reg = HHI_GP0_PLL_CNTL4, .def = 0x33771290 },
2593 - { .reg = HHI_GP0_PLL_CNTL6, .def = 0x56540000 },
2598 @@ -1653,6 +1656,7 @@
2606 @@ -3657,6 +3661,86 @@
2693 @@ -4099,6 +4183,96 @@
2790 @@ -4402,6 +4576,9 @@
2800 @@ -4657,6 +4834,10 @@
2811 @@ -4903,6 +5084,9 @@
2821 @@ -5150,6 +5334,10 @@
2832 @@ -5196,7 +5384,58 @@
2839 + clk_base = of_iomap(of_get_parent(pdev->dev.of_node), 0);
2842 + return -1;
2891 diff -Naur a/drivers/clk/meson/g12a.h b/drivers/clk/meson/g12a.h
2892 --- a/drivers/clk/meson/g12a.h 2022-05-27 17:20:14.749890137 +0800
2893 +++ b/drivers/clk/meson/g12a.h 2022-05-31 11:56:47.725259396 +0800
2894 @@ -44,6 +44,7 @@
2902 @@ -70,6 +71,7 @@
2910 @@ -117,6 +119,7 @@
2918 @@ -264,8 +267,9 @@
2924 -#define NR_CLKS 268
2928 #include <dt-bindings/clock/g12a-clkc.h>
2929 diff -Naur a/drivers/clk/meson/g12a-vcodec-clk.c b/drivers/clk/meson/g12a-vcodec-clk.c
2930 --- a/drivers/clk/meson/g12a-vcodec-clk.c 1970-01-01 08:00:00.000000000 +0800
2931 +++ b/drivers/clk/meson/g12a-vcodec-clk.c 2022-05-31 11:56:47.725259396 +0800
2932 @@ -0,0 +1,624 @@
2951 +#include <linux/clk-provider.h>
2958 +#include "clk-mux.h"
2959 +#include "g12a-vcodec-clk.h"
3557 diff -Naur a/drivers/clk/meson/g12a-vcodec-clk.h b/drivers/clk/meson/g12a-vcodec-clk.h
3558 --- a/drivers/clk/meson/g12a-vcodec-clk.h 1970-01-01 08:00:00.000000000 +0800
3559 +++ b/drivers/clk/meson/g12a-vcodec-clk.h 2022-05-31 11:56:47.725259396 +0800
3560 @@ -0,0 +1,12 @@
3561 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
3573 diff -Naur a/drivers/clk/meson/Makefile b/drivers/clk/meson/Makefile
3574 --- a/drivers/clk/meson/Makefile 2022-05-27 17:20:14.749890137 +0800
3575 +++ b/drivers/clk/meson/Makefile 2022-05-31 11:56:47.725259396 +0800
3576 @@ -7,7 +7,7 @@
3577 obj-$(CONFIG_COMMON_CLK_MESON_EE_CLKC) += meson-eeclk.o
3578 obj-$(CONFIG_COMMON_CLK_MESON_MPLL) += clk-mpll.o
3579 obj-$(CONFIG_COMMON_CLK_MESON_PHASE) += clk-phase.o
3580 -obj-$(CONFIG_COMMON_CLK_MESON_PLL) += clk-pll.o
3581 +obj-$(CONFIG_COMMON_CLK_MESON_PLL) += clk-pll.o clk-mux.o
3582 obj-$(CONFIG_COMMON_CLK_MESON_REGMAP) += clk-regmap.o
3583 obj-$(CONFIG_COMMON_CLK_MESON_SCLK_DIV) += sclk-div.o
3584 obj-$(CONFIG_COMMON_CLK_MESON_VID_PLL_DIV) += vid-pll-div.o
3585 @@ -17,5 +17,5 @@
3586 obj-$(CONFIG_COMMON_CLK_AXG) += axg.o axg-aoclk.o
3587 obj-$(CONFIG_COMMON_CLK_AXG_AUDIO) += axg-audio.o
3588 obj-$(CONFIG_COMMON_CLK_GXBB) += gxbb.o gxbb-aoclk.o
3589 -obj-$(CONFIG_COMMON_CLK_G12A) += g12a.o g12a-aoclk.o
3590 +obj-$(CONFIG_COMMON_CLK_G12A) += g12a.o g12a-aoclk.o g12a-vcodec-clk.o
3591 obj-$(CONFIG_COMMON_CLK_MESON8B) += meson8b.o meson8-ddr.o
3592 diff -Naur a/drivers/clk/meson/vid-pll-div.c b/drivers/clk/meson/vid-pll-div.c
3593 --- a/drivers/clk/meson/vid-pll-div.c 2022-05-27 17:20:14.753890189 +0800
3594 +++ b/drivers/clk/meson/vid-pll-div.c 2022-05-31 11:56:47.725259396 +0800
3595 @@ -39,12 +39,14 @@
3610 diff -Naur a/drivers/edac/sb_edac.c b/drivers/edac/sb_edac.c
3611 --- a/drivers/edac/sb_edac.c 2022-06-29 08:47:07.171383478 +0800
3612 +++ b/drivers/edac/sb_edac.c 2022-05-27 17:20:14.881891840 +0800
3613 @@ -1052,7 +1052,7 @@
3614 pci_read_config_dword(pvt->info.pci_vtd, HASWELL_TOHM_1, ®);
3617 - return rc | 0x3ffffff;
3622 diff -Naur a/drivers/firmware/efi/libstub/arm64-stub.c b/drivers/firmware/efi/libstub/arm64-stub.c
3623 --- a/drivers/firmware/efi/libstub/arm64-stub.c 2022-05-27 17:20:14.893891994 +0800
3624 +++ b/drivers/firmware/efi/libstub/arm64-stub.c 2022-05-31 11:56:47.725259396 +0800
3625 @@ -125,7 +125,7 @@
3627 kernel_size = _edata - _text;
3628 kernel_memsize = kernel_size + (_end - _edata);
3629 - *reserve_size = kernel_memsize;
3634 @@ -141,7 +141,7 @@
3638 - } else if (IS_ALIGNED((u64)_text, min_kimg_align)) {
3639 + } else if (IS_ALIGNED((u64)_text - TEXT_OFFSET, min_kimg_align)) {
3643 @@ -161,7 +161,7 @@
3647 - *image_addr = *reserve_addr;
3652 diff -Naur a/drivers/firmware/efi/libstub/Makefile b/drivers/firmware/efi/libstub/Makefile
3653 --- a/drivers/firmware/efi/libstub/Makefile 2022-05-27 17:20:14.893891994 +0800
3654 +++ b/drivers/firmware/efi/libstub/Makefile 2022-05-31 11:56:47.725259396 +0800
3655 @@ -69,6 +69,7 @@
3656 lib-$(CONFIG_X86) += x86-stub.o
3657 lib-$(CONFIG_RISCV) += riscv-stub.o
3658 CFLAGS_arm32-stub.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
3659 +CFLAGS_arm64-stub.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
3661 # Even when -mbranch-protection=none is set, Clang will generate a
3662 # .note.gnu.property for code-less object files (like lib/ctype.c),
3663 diff -Naur a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c b/drivers/gpu/drm/bridge/synopsys/…
3664 --- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c 2022-05-27 17:20:15.513899992 +0800
3665 +++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi-ahb-audio.c 2022-05-31 11:56:47.725259396 +0800
3666 @@ -320,13 +320,17 @@
3667 struct snd_pcm_runtime *runtime = substream->runtime;
3668 struct snd_dw_hdmi *dw = substream->private_data;
3669 void __iomem *base = dw->data.base;
3673 runtime->hw = dw_hdmi_hw;
3675 - ret = snd_pcm_hw_constraint_eld(runtime, dw->data.eld);
3676 - if (ret < 0)
3677 - return ret;
3678 + eld = dw->data.get_eld(dw->data.hdmi);
3687 diff -Naur a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-audio.h b/drivers/gpu/drm/bridge/synopsys/dw-h…
3688 --- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-audio.h 2022-05-27 17:20:15.513899992 +0800
3689 +++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi-audio.h 2022-05-31 11:56:47.725259396 +0800
3690 @@ -9,15 +9,15 @@
3694 - u8 *eld;
3700 - u8 *eld;
3708 diff -Naur a/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c b/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c
3709 --- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c 2022-05-27 17:20:15.513899992 +0800
3710 +++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi.c 2022-05-31 11:56:47.729259361 +0800
3711 @@ -143,6 +143,7 @@
3719 @@ -754,6 +755,19 @@
3721 hdmi->mc_clkdis |= HDMI_MC_CLKDIS_AUDCLK_DISABLE;
3722 hdmi_writeb(hdmi, hdmi->mc_clkdis, HDMI_MC_CLKDIS);
3725 + hdmi_set_cts_n(hdmi, hdmi->audio_cts, 0);
3726 + hdmi_set_cts_n(hdmi, hdmi->audio_cts, hdmi->audio_n);
3732 + if (!hdmi->curr_conn)
3735 + return hdmi->curr_conn->eld;
3739 @@ -2395,21 +2409,6 @@
3743 -static bool hdr_metadata_equal(const struct drm_connector_state *old_state,
3744 - const struct drm_connector_state *new_state)
3745 -{
3746 - struct drm_property_blob *old_blob = old_state->hdr_output_metadata;
3747 - struct drm_property_blob *new_blob = new_state->hdr_output_metadata;
3748 -
3749 - if (!old_blob || !new_blob)
3750 - return old_blob == new_blob;
3751 -
3752 - if (old_blob->length != new_blob->length)
3753 - return false;
3754 -
3755 - return !memcmp(old_blob->data, new_blob->data, old_blob->length);
3756 -}
3757 -
3761 @@ -2423,7 +2422,7 @@
3765 - if (!hdr_metadata_equal(old_state, new_state)) {
3770 @@ -2492,8 +2491,7 @@
3773 if (hdmi->version >= 0x200a && hdmi->plat_data->use_drm_infoframe)
3774 - drm_object_attach_property(&connector->base,
3775 - connector->dev->mode_config.hdr_output_metadata_property, 0);
3778 drm_connector_attach_encoder(connector, hdmi->bridge.encoder);
3780 @@ -2791,7 +2789,8 @@
3781 struct dw_hdmi *hdmi = bridge->driver_private;
3784 - return 0;
3785 + return drm_bridge_attach(bridge->encoder, hdmi->next_bridge,
3790 @@ -3176,6 +3175,52 @@
3791 /* -----------------------------------------------------------------------------
3800 + if (!hdmi->plat_data->output_port)
3803 + endpoint = of_graph_get_endpoint_by_regs(hdmi->dev->of_node,
3804 + hdmi->plat_data->output_port,
3805 + -1);
3809 + * mandatory (such as Rockchip) the plat_data->output_port
3812 + dev_err(hdmi->dev, "Missing endpoint in port@%u\n",
3813 + hdmi->plat_data->output_port);
3814 + return -ENODEV;
3820 + dev_err(hdmi->dev, "Endpoint in port@%u unconnected\n",
3821 + hdmi->plat_data->output_port);
3822 + return -ENODEV;
3826 + dev_err(hdmi->dev, "port@%u remote device is disabled\n",
3827 + hdmi->plat_data->output_port);
3829 + return -ENODEV;
3832 + hdmi->next_bridge = of_drm_find_bridge(remote);
3834 + if (!hdmi->next_bridge)
3835 + return -EPROBE_DEFER;
3843 @@ -3212,6 +3257,10 @@
3844 mutex_init(&hdmi->cec_notifier_mutex);
3845 spin_lock_init(&hdmi->audio_lock);
3851 ddc_node = of_parse_phandle(np, "ddc-i2c-bus", 0);
3853 hdmi->ddc = of_get_i2c_adapter_by_node(ddc_node);
3854 @@ -3377,6 +3426,7 @@
3855 hdmi->bridge.funcs = &dw_hdmi_bridge_funcs;
3856 hdmi->bridge.ops = DRM_BRIDGE_OP_DETECT | DRM_BRIDGE_OP_EDID
3858 + hdmi->bridge.interlace_allowed = true;
3860 hdmi->bridge.of_node = pdev->dev.of_node;
3862 @@ -3395,7 +3445,7 @@
3863 audio.base = hdmi->regs;
3866 - audio.eld = hdmi->connector.eld;
3868 hdmi->enable_audio = dw_hdmi_ahb_audio_enable;
3869 hdmi->disable_audio = dw_hdmi_ahb_audio_disable;
3871 @@ -3408,7 +3458,7 @@
3875 - audio.eld = hdmi->connector.eld;
3879 hdmi->enable_audio = dw_hdmi_i2s_audio_enable;
3880 @@ -3421,7 +3471,7 @@
3881 hdmi->audio = platform_device_register_full(&pdevinfo);
3884 - if (config0 & HDMI_CONFIG0_CEC) {
3885 + if (!plat_data->disable_cec && (config0 & HDMI_CONFIG0_CEC)) {
3889 @@ -3440,8 +3490,7 @@
3892 clk_disable_unprepare(hdmi->iahb_clk);
3893 - if (hdmi->cec_clk)
3894 - clk_disable_unprepare(hdmi->cec_clk);
3895 + clk_disable_unprepare(hdmi->cec_clk);
3897 clk_disable_unprepare(hdmi->isfr_clk);
3899 @@ -3465,8 +3514,7 @@
3901 clk_disable_unprepare(hdmi->iahb_clk);
3902 clk_disable_unprepare(hdmi->isfr_clk);
3903 - if (hdmi->cec_clk)
3904 - clk_disable_unprepare(hdmi->cec_clk);
3905 + clk_disable_unprepare(hdmi->cec_clk);
3907 if (hdmi->i2c)
3908 i2c_del_adapter(&hdmi->i2c->adap);
3909 diff -Naur a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-cec.c b/drivers/gpu/drm/bridge/synopsys/dw-hdm…
3910 --- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-cec.c 2022-05-27 17:20:15.513899992 +0800
3911 +++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi-cec.c 2022-05-31 11:56:47.729259361 +0800
3912 @@ -265,11 +265,9 @@
3914 cec->adap->owner = THIS_MODULE;
3916 - ret = devm_add_action(&pdev->dev, dw_hdmi_cec_del, cec);
3917 - if (ret) {
3918 - cec_delete_adapter(cec->adap);
3919 + ret = devm_add_action_or_reset(&pdev->dev, dw_hdmi_cec_del, cec);
3922 - }
3924 ret = devm_request_threaded_irq(&pdev->dev, cec->irq,
3926 diff -Naur a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-i2s-audio.c b/drivers/gpu/drm/bridge/synopsys/…
3927 --- a/drivers/gpu/drm/bridge/synopsys/dw-hdmi-i2s-audio.c 2022-05-27 17:20:15.513899992 +0800
3928 +++ b/drivers/gpu/drm/bridge/synopsys/dw-hdmi-i2s-audio.c 2022-05-31 11:56:47.729259361 +0800
3929 @@ -135,8 +135,15 @@
3935 + eld = audio->get_eld(audio->hdmi);
3939 + /* Pass en empty ELD if connector not available */
3942 - memcpy(buf, audio->eld, min_t(size_t, MAX_ELD_BYTES, len));
3946 @@ -170,7 +177,7 @@
3950 -static struct hdmi_codec_ops dw_hdmi_i2s_ops = {
3955 diff -Naur a/drivers/gpu/drm/bridge/synopsys/dw-mipi-dsi.c b/drivers/gpu/drm/bridge/synopsys/dw-mip…
3956 --- a/drivers/gpu/drm/bridge/synopsys/dw-mipi-dsi.c 2022-05-27 17:20:15.513899992 +0800
3957 +++ b/drivers/gpu/drm/bridge/synopsys/dw-mipi-dsi.c 2022-05-31 11:56:47.729259361 +0800
3958 @@ -246,6 +246,7 @@
3966 @@ -309,13 +310,37 @@
3967 return readl(dsi->base + reg);
3988 + dsi->panel_bridge = bridge;
3990 + if (!dsi->panel_bridge)
3991 + return -EPROBE_DEFER;
4000 const struct dw_mipi_dsi_plat_data *pdata = dsi->plat_data;
4001 - struct drm_bridge *bridge;
4002 - struct drm_panel *panel;
4005 if (device->lanes > dsi->plat_data->max_data_lanes) {
4006 @@ -329,22 +354,14 @@
4007 dsi->format = device->format;
4008 dsi->mode_flags = device->mode_flags;
4010 - ret = drm_of_find_panel_or_bridge(host->dev->of_node, 1, 0,
4011 - &panel, &bridge);
4012 - if (ret)
4013 - return ret;
4014 + if (!dsi->device_found) {
4015 + ret = dw_mipi_dsi_panel_or_bridge(dsi, host->dev->of_node);
4019 - if (panel) {
4020 - bridge = drm_panel_bridge_add_typed(panel,
4021 - DRM_MODE_CONNECTOR_DSI);
4022 - if (IS_ERR(bridge))
4023 - return PTR_ERR(bridge);
4024 + dsi->device_found = true;
4027 - dsi->panel_bridge = bridge;
4028 -
4029 - drm_bridge_add(&dsi->bridge);
4030 -
4031 if (pdata->host_ops && pdata->host_ops->attach) {
4032 ret = pdata->host_ops->attach(pdata->priv_data, device);
4034 @@ -854,7 +871,8 @@
4038 -static void dw_mipi_dsi_bridge_post_disable(struct drm_bridge *bridge)
4043 const struct dw_mipi_dsi_phy_ops *phy_ops = dsi->plat_data->phy_ops;
4044 @@ -961,7 +979,8 @@
4045 dw_mipi_dsi_mode_set(dsi->slave, adjusted_mode);
4048 -static void dw_mipi_dsi_bridge_enable(struct drm_bridge *bridge)
4054 @@ -981,7 +1000,10 @@
4057 if (pdata->mode_valid)
4058 - mode_status = pdata->mode_valid(pdata->priv_data, mode);
4059 + mode_status = pdata->mode_valid(pdata->priv_data, mode,
4060 + dsi->mode_flags,
4062 + dsi->format);
4066 @@ -999,17 +1021,30 @@
4068 bridge->encoder->encoder_type = DRM_MODE_ENCODER_DSI;
4070 + if (!dsi->device_found) {
4073 + ret = dw_mipi_dsi_panel_or_bridge(dsi, dsi->dev->of_node);
4077 + dsi->device_found = true;
4080 /* Attach the panel-bridge to the dsi bridge */
4081 return drm_bridge_attach(bridge->encoder, dsi->panel_bridge, bridge,
4086 - .mode_set = dw_mipi_dsi_bridge_mode_set,
4087 - .enable = dw_mipi_dsi_bridge_enable,
4088 - .post_disable = dw_mipi_dsi_bridge_post_disable,
4089 - .mode_valid = dw_mipi_dsi_bridge_mode_valid,
4090 - .attach = dw_mipi_dsi_bridge_attach,
4102 @@ -1172,6 +1207,7 @@
4103 ret = mipi_dsi_host_register(&dsi->dsi_host);
4110 @@ -1181,6 +1217,7 @@
4112 dsi->bridge.of_node = pdev->dev.of_node;
4114 + drm_bridge_add(&dsi->bridge);
4118 @@ -1229,15 +1266,7 @@
4122 - int ret;
4123 -
4124 - ret = drm_bridge_attach(encoder, &dsi->bridge, NULL, 0);
4125 - if (ret) {
4126 - DRM_ERROR("Failed to initialize bridge with drm\n");
4127 - return ret;
4128 - }
4129 -
4130 - return ret;
4131 + return drm_bridge_attach(encoder, &dsi->bridge, NULL, 0);
4135 diff -Naur a/drivers/gpu/drm/drm_aperture.c b/drivers/gpu/drm/drm_aperture.c
4136 --- a/drivers/gpu/drm/drm_aperture.c 1970-01-01 08:00:00.000000000 +0800
4137 +++ b/drivers/gpu/drm/drm_aperture.c 2022-05-31 11:56:47.729259361 +0800
4138 @@ -0,0 +1,353 @@
4139 +// SPDX-License-Identifier: MIT
4160 + * graphics drivers, such as EFI-GOP or VESA, early during the boot process.
4162 + * hardware-specific driver. To take over the device the dedicated driver
4164 + * ownership of DRM framebuffer memory and hand-over between drivers.
4172 + * .. code-block:: c
4187 + * primary = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
4224 + * .. code-block:: c
4232 + * return -EINVAL;
4233 + * base = mem->start;
4287 + bool detached = !ap->dev;
4293 + list_del(&ap->lh);
4309 + if (overlap(base, end, ap->base, ap->base + ap->size)) {
4311 + return -EBUSY;
4315 + ap = devm_kzalloc(dev->dev, sizeof(*ap), GFP_KERNEL);
4318 + return -ENOMEM;
4321 + ap->dev = dev;
4322 + ap->base = base;
4323 + ap->size = size;
4324 + ap->detach = detach;
4325 + INIT_LIST_HEAD(&ap->lh);
4327 + list_add(&ap->lh, &drm_apertures);
4331 + return devm_add_action_or_reset(dev->dev, devm_aperture_acquire_release, ap);
4336 + struct platform_device *pdev = to_platform_device(dev->dev);
4340 + * to do for firmware-based DRM drivers, such as EFI, VESA or VGA. After
4344 + * For non-platform devices, a new callback would be required.
4354 + * devm_aperture_acquire_from_firmware - Acquires ownership of a firmware framebuffer
4380 + if (drm_WARN_ON(dev, !dev_is_platform(dev->dev)))
4381 + return -EINVAL;
4397 + struct drm_device *dev = ap->dev;
4402 + if (!overlap(base, end, ap->base, ap->base + ap->size))
4405 + ap->dev = NULL; /* detach from device */
4406 + list_del(&ap->lh);
4408 + ap->detach(dev);
4415 + * drm_aperture_remove_conflicting_framebuffers - remove existing framebuffers in the given range
4436 + return -ENOMEM;
4438 + a->ranges[0].base = base;
4439 + a->ranges[0].size = size;
4441 + ret = remove_conflicting_framebuffers(a, req_driver->name, primary);
4455 + * drm_aperture_remove_conflicting_pci_framebuffers - remove existing framebuffers for PCI devices
4485 + ret = remove_conflicting_pci_framebuffers(pdev, req_driver->name);
4492 diff -Naur a/drivers/gpu/drm/drm_connector.c b/drivers/gpu/drm/drm_connector.c
4493 --- a/drivers/gpu/drm/drm_connector.c 2022-05-27 17:20:15.517900044 +0800
4494 +++ b/drivers/gpu/drm/drm_connector.c 2022-05-31 11:56:47.729259361 +0800
4495 @@ -2144,6 +2144,55 @@
4499 + * drm_connector_attach_hdr_output_metadata_property - attach "HDR_OUTPUT_METADA" property
4510 + struct drm_device *dev = connector->dev;
4511 + struct drm_property *prop = dev->mode_config.hdr_output_metadata_property;
4513 + drm_object_attach_property(&connector->base, prop, 0);
4520 + * drm_connector_atomic_hdr_metadata_equal - checks if the hdr metadata changed
4524 + * This is used by HDR-enabled drivers to test whether the HDR metadata
4534 + struct drm_property_blob *old_blob = old_state->hdr_output_metadata;
4535 + struct drm_property_blob *new_blob = new_state->hdr_output_metadata;
4540 + if (old_blob->length != new_blob->length)
4543 + return !memcmp(old_blob->data, new_blob->data, old_blob->length);
4548 * drm_connector_set_vrr_capable_property - sets the variable refresh rate
4551 diff -Naur a/drivers/gpu/drm/drm_ioctl.c b/drivers/gpu/drm/drm_ioctl.c
4552 --- a/drivers/gpu/drm/drm_ioctl.c 2022-05-27 17:20:15.521900096 +0800
4553 +++ b/drivers/gpu/drm/drm_ioctl.c 2022-05-31 11:56:47.729259361 +0800
4554 @@ -678,9 +678,9 @@
4558 - DRM_IOCTL_DEF(DRM_IOCTL_MODE_CREATE_DUMB, drm_mode_create_dumb_ioctl, 0),
4559 - DRM_IOCTL_DEF(DRM_IOCTL_MODE_MAP_DUMB, drm_mode_mmap_dumb_ioctl, 0),
4560 - DRM_IOCTL_DEF(DRM_IOCTL_MODE_DESTROY_DUMB, drm_mode_destroy_dumb_ioctl, 0),
4567 diff -Naur a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c
4568 --- a/drivers/gpu/drm/drm_vblank.c 2022-05-27 17:20:15.525900147 +0800
4569 +++ b/drivers/gpu/drm/drm_vblank.c 2022-05-31 11:56:47.729259361 +0800
4570 @@ -1725,6 +1725,15 @@
4571 reply->tval_usec = ts.tv_nsec / 1000;
4578 + return dev->irq_enabled;
4586 @@ -1736,7 +1745,7 @@
4590 - if (!dev->irq_enabled)
4592 return -EOPNOTSUPP;
4594 if (vblwait->request.type & _DRM_VBLANK_SIGNAL)
4595 @@ -2011,7 +2020,7 @@
4597 return -EOPNOTSUPP;
4599 - if (!dev->irq_enabled)
4601 return -EOPNOTSUPP;
4603 crtc = drm_crtc_find(dev, file_priv, get_seq->crtc_id);
4604 @@ -2070,7 +2079,7 @@
4606 return -EOPNOTSUPP;
4608 - if (!dev->irq_enabled)
4610 return -EOPNOTSUPP;
4612 crtc = drm_crtc_find(dev, file_priv, queue_seq->crtc_id);
4613 diff -Naur a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
4614 --- a/drivers/gpu/drm/Makefile 2022-05-27 17:20:14.917892304 +0800
4615 +++ b/drivers/gpu/drm/Makefile 2022-05-31 11:56:47.729259361 +0800
4616 @@ -18,7 +18,7 @@
4620 - drm_managed.o drm_vblank_work.o
4623 …drm-$(CONFIG_DRM_LEGACY) += drm_legacy_misc.o drm_bufs.o drm_context.o drm_dma.o drm_scatter.o drm…
4624 drm-$(CONFIG_DRM_LIB_RANDOM) += lib/drm_random.o
4625 diff -Naur a/drivers/gpu/drm/meson/Kconfig b/drivers/gpu/drm/meson/Kconfig
4626 --- a/drivers/gpu/drm/meson/Kconfig 2022-05-27 17:20:15.601901127 +0800
4627 +++ b/drivers/gpu/drm/meson/Kconfig 2022-05-31 11:56:47.729259361 +0800
4628 @@ -6,9 +6,11 @@
4640 @@ -16,3 +18,10 @@
4651 diff -Naur a/drivers/gpu/drm/meson/Makefile b/drivers/gpu/drm/meson/Makefile
4652 --- a/drivers/gpu/drm/meson/Makefile 2022-05-27 17:20:15.601901127 +0800
4653 +++ b/drivers/gpu/drm/meson/Makefile 2022-05-31 11:56:47.729259361 +0800
4654 @@ -1,7 +1,9 @@
4655 # SPDX-License-Identifier: GPL-2.0-only
4656 -meson-drm-y := meson_drv.o meson_plane.o meson_crtc.o meson_venc_cvbs.o
4657 +meson-drm-y := meson_drv.o meson_plane.o meson_cursor.o meson_crtc.o meson_encoder_cvbs.o
4658 meson-drm-y += meson_viu.o meson_vpp.o meson_venc.o meson_vclk.o meson_overlay.o
4659 meson-drm-y += meson_rdma.o meson_osd_afbcd.o
4660 +meson-drm-y += meson_encoder_hdmi.o meson_encoder_dsi.o
4662 obj-$(CONFIG_DRM_MESON) += meson-drm.o
4663 obj-$(CONFIG_DRM_MESON_DW_HDMI) += meson_dw_hdmi.o
4664 +obj-$(CONFIG_DRM_MESON_DW_MIPI_DSI) += meson_dw_mipi_dsi.o
4665 diff -Naur a/drivers/gpu/drm/meson/meson_crtc.c b/drivers/gpu/drm/meson/meson_crtc.c
4666 --- a/drivers/gpu/drm/meson/meson_crtc.c 2022-05-27 17:20:15.601901127 +0800
4667 +++ b/drivers/gpu/drm/meson/meson_crtc.c 2022-05-31 11:56:47.729259361 +0800
4668 @@ -36,6 +36,7 @@
4676 @@ -82,7 +83,7 @@
4680 - struct drm_crtc_state *old_state)
4684 struct drm_crtc_state *crtc_state = crtc->state;
4685 @@ -110,6 +111,20 @@
4687 (crtc_state->mode.vdisplay - 1),
4688 priv->io_base + _REG(VPP_OSD1_BLD_V_SCOPE));
4690 + (crtc_state->mode.hdisplay - 1),
4691 + priv->io_base + _REG(VPP_OSD2_BLD_H_SCOPE));
4693 + (crtc_state->mode.vdisplay - 1),
4694 + priv->io_base + _REG(VPP_OSD2_BLD_V_SCOPE));
4695 + writel_relaxed(crtc_state->mode.hdisplay |
4696 + crtc_state->mode.vdisplay << 16,
4697 + priv->io_base +
4699 + writel_relaxed(crtc_state->mode.hdisplay |
4700 + crtc_state->mode.vdisplay << 16,
4701 + priv->io_base +
4703 writel_relaxed(crtc_state->mode.hdisplay << 16 |
4704 crtc_state->mode.vdisplay,
4705 priv->io_base + _REG(VPP_OUT_H_V_SIZE));
4706 @@ -118,7 +133,7 @@
4710 - struct drm_crtc_state *old_state)
4714 struct drm_crtc_state *crtc_state = crtc->state;
4715 @@ -146,7 +161,7 @@
4719 - struct drm_crtc_state *old_state)
4723 struct meson_drm *priv = meson_crtc->priv;
4724 @@ -158,6 +173,9 @@
4725 priv->viu.osd1_enabled = false;
4726 priv->viu.osd1_commit = false;
4728 + priv->viu.osd2_enabled = false;
4729 + priv->viu.osd2_commit = false;
4731 priv->viu.vd1_enabled = false;
4732 priv->viu.vd1_commit = false;
4734 @@ -171,7 +189,7 @@
4738 - struct drm_crtc_state *old_state)
4742 struct meson_drm *priv = meson_crtc->priv;
4743 @@ -183,11 +201,14 @@
4744 priv->viu.osd1_enabled = false;
4745 priv->viu.osd1_commit = false;
4747 + priv->viu.osd2_enabled = false;
4748 + priv->viu.osd2_commit = false;
4750 priv->viu.vd1_enabled = false;
4751 priv->viu.vd1_commit = false;
4754 - writel_bits_relaxed(VPP_OSD1_POSTBLEND | VPP_VD1_POSTBLEND |
4757 priv->io_base + _REG(VPP_MISC));
4759 @@ -201,7 +222,7 @@
4763 - struct drm_crtc_state *state)
4768 @@ -223,6 +244,7 @@
4769 struct meson_drm *priv = meson_crtc->priv;
4771 priv->viu.osd1_commit = true;
4772 + priv->viu.osd2_commit = true;
4773 priv->viu.vd1_commit = true;
4776 @@ -246,6 +268,12 @@
4777 priv->io_base + _REG(VPP_MISC));
4783 + priv->io_base + _REG(VPP_MISC));
4788 writel_relaxed(priv->viu.osd1_blk2_cfg4,
4789 @@ -274,14 +302,20 @@
4790 writel_relaxed(priv->viu.osd_blend_din0_scope_v,
4791 priv->io_base +
4793 - writel_relaxed(priv->viu.osb_blend0_size,
4795 + priv->io_base + _REG(OSD1_BLEND_SRC_CTRL));
4800 + writel_relaxed(priv->viu.osd_blend_din3_scope_h,
4801 priv->io_base +
4802 - _REG(VIU_OSD_BLEND_BLEND0_SIZE));
4803 - writel_relaxed(priv->viu.osb_blend1_size,
4805 + writel_relaxed(priv->viu.osd_blend_din3_scope_v,
4806 priv->io_base +
4807 - _REG(VIU_OSD_BLEND_BLEND1_SIZE));
4808 - writel_bits_relaxed(3 << 8, 3 << 8,
4809 - priv->io_base + _REG(OSD1_BLEND_SRC_CTRL));
4812 + priv->io_base + _REG(OSD2_BLEND_SRC_CTRL));
4816 @@ -388,6 +422,43 @@
4817 priv->viu.osd1_commit = false;
4820 + if (priv->viu.osd2_enabled && priv->viu.osd2_commit) {
4821 + writel_relaxed(priv->viu.osd2_ctrl_stat,
4822 + priv->io_base + _REG(VIU_OSD2_CTRL_STAT));
4823 + writel_relaxed(priv->viu.osd2_ctrl_stat2,
4824 + priv->io_base + _REG(VIU_OSD2_CTRL_STAT2));
4825 + writel_relaxed(priv->viu.osd2_blk0_cfg[0],
4826 + priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W0));
4827 + writel_relaxed(priv->viu.osd2_blk0_cfg[1],
4828 + priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W1));
4829 + writel_relaxed(priv->viu.osd2_blk0_cfg[2],
4830 + priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W2));
4831 + writel_relaxed(priv->viu.osd2_blk0_cfg[3],
4832 + priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W3));
4833 + writel_relaxed(priv->viu.osd2_blk0_cfg[4],
4834 + priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W4));
4837 + meson_crtc->vsync_forced = priv->viu.osd2_interlace;
4839 + meson_canvas_config(priv->canvas, priv->canvas_id_osd2,
4840 + priv->viu.osd2_addr,
4841 + priv->viu.osd2_stride,
4842 + priv->viu.osd2_height,
4847 + if (meson_crtc->enable_osd2)
4848 + meson_crtc->enable_osd2(priv);
4850 + priv->viu.osd2_commit = false;
4851 + } else if (priv->viu.osd2_enabled && priv->viu.osd2_interlace) {
4852 + u32 reg = readl_relaxed(priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W0)) & ~BIT(0);
4854 + priv->io_base + _REG(VIU_OSD2_BLK0_CFG_W0));
4858 if (priv->viu.vd1_enabled && priv->viu.vd1_commit) {
4860 @@ -685,7 +756,7 @@
4861 meson_crtc->priv = priv;
4862 crtc = &meson_crtc->base;
4863 ret = drm_crtc_init_with_planes(priv->drm, crtc,
4864 - priv->primary_plane, NULL,
4865 + priv->primary_plane, priv->cursor_plane,
4868 dev_err(priv->drm->dev, "Failed to init CRTC\n");
4869 @@ -694,6 +765,7 @@
4872 meson_crtc->enable_osd1 = meson_g12a_crtc_enable_osd1;
4873 + meson_crtc->enable_osd2 = meson_g12a_crtc_enable_osd2;
4874 meson_crtc->enable_vd1 = meson_g12a_crtc_enable_vd1;
4875 meson_crtc->viu_offset = MESON_G12A_VIU_OFFSET;
4876 meson_crtc->enable_osd1_afbc =
4877 @@ -703,6 +775,7 @@
4880 meson_crtc->enable_osd1 = meson_crtc_enable_osd1;
4881 + meson_crtc->enable_osd2 = meson_crtc_enable_osd2;
4882 meson_crtc->enable_vd1 = meson_crtc_enable_vd1;
4884 meson_crtc->enable_osd1_afbc =
4885 diff -Naur a/drivers/gpu/drm/meson/meson_cursor.c b/drivers/gpu/drm/meson/meson_cursor.c
4886 --- a/drivers/gpu/drm/meson/meson_cursor.c 1970-01-01 08:00:00.000000000 +0800
4887 +++ b/drivers/gpu/drm/meson/meson_cursor.c 2022-05-31 11:56:47.729259361 +0800
4888 @@ -0,0 +1,244 @@
4889 +// SPDX-License-Identifier: GPL-2.0-or-later
4919 + struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state->state,
4923 + if (!new_plane_state->crtc)
4926 + crtc_state = drm_atomic_get_crtc_state(state->state,
4927 + new_plane_state->crtc);
4948 + struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state->state,
4951 + struct meson_drm *priv = meson_cursor->priv;
4952 + struct drm_framebuffer *fb = new_state->fb;
4963 + spin_lock_irqsave(&priv->drm->event_lock, flags);
4966 + priv->viu.osd2_ctrl_stat = OSD_ENABLE |
4970 + priv->viu.osd2_ctrl_stat2 = readl(priv->io_base +
4974 + priv->viu.osd2_blk0_cfg[0] = priv->canvas_id_osd2 << OSD_CANVAS_SEL;
4975 + priv->viu.osd2_blk0_cfg[0] |= OSD_ENDIANNESS_LE;
4977 + /* On GXBB, Use the old non-HDR RGB2YUV converter */
4979 + priv->viu.osd2_blk0_cfg[0] |= OSD_OUTPUT_COLOR_RGB;
4981 + switch (fb->format->format) {
4984 + priv->viu.osd2_blk0_cfg[0] |= OSD_BLK_MODE_32 |
4989 + priv->viu.osd2_blk0_cfg[0] |= OSD_BLK_MODE_32 |
4993 + priv->viu.osd2_blk0_cfg[0] |= OSD_BLK_MODE_24 |
4997 + priv->viu.osd2_blk0_cfg[0] |= OSD_BLK_MODE_16 |
5002 + switch (fb->format->format) {
5006 + priv->viu.osd2_ctrl_stat2 |= OSD_REPLACE_EN;
5011 + priv->viu.osd2_ctrl_stat2 &= ~OSD_REPLACE_EN;
5015 + dst_w = new_state->crtc_w;
5016 + dst_h = new_state->crtc_h;
5018 + if (new_state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE)
5019 + priv->viu.osd2_interlace = true;
5021 + priv->viu.osd2_interlace = false;
5028 + priv->viu.osd2_blk0_cfg[1] =
5029 + ((fixed16_to_int(new_state->src.x2) - 1) << 16) |
5030 + fixed16_to_int(new_state->src.x1);
5031 + priv->viu.osd2_blk0_cfg[2] =
5032 + ((fixed16_to_int(new_state->src.y2) - 1) << 16) |
5033 + fixed16_to_int(new_state->src.y1);
5034 + priv->viu.osd2_blk0_cfg[3] = ((dest.x2 - 1) << 16) | dest.x1;
5035 + priv->viu.osd2_blk0_cfg[4] = ((dest.y2 - 1) << 16) | dest.y1;
5038 + priv->viu.osd_blend_din3_scope_h = ((dest.x2 - 1) << 16) | dest.x1;
5039 + priv->viu.osd_blend_din3_scope_v = ((dest.y2 - 1) << 16) | dest.y1;
5040 + priv->viu.osb_blend1_size = dst_h << 16 | dst_w;
5046 + priv->viu.osd2_addr = gem->paddr;
5047 + priv->viu.osd2_stride = fb->pitches[0];
5048 + priv->viu.osd2_height = fb->height;
5049 + priv->viu.osd2_width = fb->width;
5053 + priv->viu.osd2_enabled = true;
5055 + spin_unlock_irqrestore(&priv->drm->event_lock, flags);
5062 + struct meson_drm *priv = meson_cursor->priv;
5067 + priv->io_base + _REG(OSD2_BLEND_SRC_CTRL));
5070 + priv->io_base + _REG(VPP_MISC));
5072 + priv->viu.osd2_enabled = false;
5109 + meson_cursor = devm_kzalloc(priv->drm->dev, sizeof(*meson_cursor),
5112 + return -ENOMEM;
5114 + meson_cursor->priv = priv;
5115 + cursor = &meson_cursor->base;
5117 + drm_universal_plane_init(priv->drm, cursor, 0xFF,
5129 + priv->cursor_plane = cursor;
5133 diff -Naur a/drivers/gpu/drm/meson/meson_cursor.h b/drivers/gpu/drm/meson/meson_cursor.h
5134 --- a/drivers/gpu/drm/meson/meson_cursor.h 1970-01-01 08:00:00.000000000 +0800
5135 +++ b/drivers/gpu/drm/meson/meson_cursor.h 2022-05-31 11:56:47.729259361 +0800
5136 @@ -0,0 +1,14 @@
5137 +/* SPDX-License-Identifier: GPL-2.0-or-later */
5151 diff -Naur a/drivers/gpu/drm/meson/meson_drv.c b/drivers/gpu/drm/meson/meson_drv.c
5152 --- a/drivers/gpu/drm/meson/meson_drv.c 2022-05-27 17:20:15.601901127 +0800
5153 +++ b/drivers/gpu/drm/meson/meson_drv.c 2022-05-31 11:56:47.729259361 +0800
5154 @@ -15,12 +15,12 @@
5156 #include <linux/soc/amlogic/meson-canvas.h>
5164 -#include <drm/drm_irq.h>
5168 @@ -29,9 +29,12 @@
5175 -#include "meson_venc_cvbs.h"
5182 @@ -93,9 +96,6 @@
5186 - /* IRQ */
5187 - .irq_handler = meson_irq,
5188 -
5192 @@ -156,23 +156,6 @@
5193 writel_relaxed(value, priv->io_base + _REG(VPU_WRARB_MODE_L2C1));
5196 -static void meson_remove_framebuffers(void)
5197 -{
5198 - struct apertures_struct *ap;
5199 -
5200 - ap = alloc_apertures(1);
5201 - if (!ap)
5202 - return;
5203 -
5204 - /* The framebuffer can be located anywhere in RAM */
5205 - ap->ranges[0].base = 0;
5206 - ap->ranges[0].size = ~0;
5207 -
5208 - drm_fb_helper_remove_conflicting_framebuffers(ap, "meson-drm-fb",
5209 - false);
5210 - kfree(ap);
5211 -}
5212 -
5216 @@ -226,8 +209,7 @@
5217 priv->compat = match->compat;
5218 priv->afbcd.ops = match->afbcd_ops;
5220 - res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "vpu");
5221 - regs = devm_ioremap_resource(dev, res);
5226 @@ -264,6 +246,9 @@
5227 ret = meson_canvas_alloc(priv->canvas, &priv->canvas_id_osd1);
5230 + ret = meson_canvas_alloc(priv->canvas, &priv->canvas_id_osd2);
5233 ret = meson_canvas_alloc(priv->canvas, &priv->canvas_id_vd1_0);
5235 meson_canvas_free(priv->canvas, priv->canvas_id_osd1);
5236 @@ -297,8 +282,13 @@
5240 - /* Remove early framebuffers (ie. simplefb) */
5241 - meson_remove_framebuffers();
5252 @@ -322,33 +312,47 @@
5256 - ret = meson_venc_cvbs_create(priv);
5259 - goto free_drm;
5263 ret = component_bind_all(drm->dev, drm);
5265 dev_err(drm->dev, "Couldn't bind all components\n");
5266 - goto free_drm;
5287 - goto free_drm;
5292 - goto free_drm;
5297 - goto free_drm;
5300 - ret = drm_irq_install(drm, priv->vsync_irq);
5301 + ret = request_irq(priv->vsync_irq, meson_irq, 0, drm->driver->name, drm);
5303 - goto free_drm;
5308 @@ -365,7 +369,10 @@
5312 - drm_irq_uninstall(drm);
5313 + free_irq(priv->vsync_irq, drm);
5315 + if (priv->afbcd.ops)
5316 + priv->afbcd.ops->exit(priv);
5320 @@ -393,13 +400,11 @@
5324 - drm_irq_uninstall(drm);
5325 + free_irq(priv->vsync_irq, drm);
5328 - if (priv->afbcd.ops) {
5329 - priv->afbcd.ops->reset(priv);
5330 - meson_rdma_free(priv);
5331 - }
5332 + if (priv->afbcd.ops)
5333 + priv->afbcd.ops->exit(priv);
5337 @@ -442,46 +447,6 @@
5338 return dev->of_node == data;
5341 -/* Possible connectors nodes to ignore */
5342 -static const struct of_device_id connectors_match[] = {
5343 - { .compatible = "composite-video-connector" },
5344 - { .compatible = "svideo-connector" },
5345 - { .compatible = "hdmi-connector" },
5346 - { .compatible = "dvi-connector" },
5347 - {}
5348 -};
5349 -
5350 -static int meson_probe_remote(struct platform_device *pdev,
5351 - struct component_match **match,
5352 - struct device_node *parent,
5353 - struct device_node *remote)
5354 -{
5355 - struct device_node *ep, *remote_node;
5356 - int count = 1;
5357 -
5358 - /* If node is a connector, return and do not add to match table */
5359 - if (of_match_node(connectors_match, remote))
5360 - return 1;
5361 -
5362 - component_match_add(&pdev->dev, match, compare_of, remote);
5363 -
5364 - for_each_endpoint_of_node(remote, ep) {
5365 - remote_node = of_graph_get_remote_port_parent(ep);
5366 - if (!remote_node ||
5367 - remote_node == parent || /* Ignore parent endpoint */
5368 - !of_device_is_available(remote_node)) {
5369 - of_node_put(remote_node);
5370 - continue;
5371 - }
5372 -
5373 - count += meson_probe_remote(pdev, match, remote, remote_node);
5374 -
5375 - of_node_put(remote_node);
5376 - }
5377 -
5378 - return count;
5379 -}
5380 -
5383 struct meson_drm *priv = dev_get_drvdata(&pdev->dev);
5384 @@ -493,6 +458,13 @@
5385 drm_atomic_helper_shutdown(priv->drm);
5390 + { .compatible = "composite-video-connector" },
5391 + { .compatible = "svideo-connector" },
5398 @@ -507,8 +479,21 @@
5402 - count += meson_probe_remote(pdev, &match, np, remote);
5410 + dev_dbg(&pdev->dev, "parent %pOF remote match add %pOF parent %s\n",
5411 + np, remote, dev_name(&pdev->dev));
5413 + component_match_add(&pdev->dev, &match, compare_of, remote);
5421 diff -Naur a/drivers/gpu/drm/meson/meson_drv.h b/drivers/gpu/drm/meson/meson_drv.h
5422 --- a/drivers/gpu/drm/meson/meson_drv.h 2022-05-27 17:20:15.601901127 +0800
5423 +++ b/drivers/gpu/drm/meson/meson_drv.h 2022-05-31 11:56:47.729259361 +0800
5424 @@ -43,12 +43,14 @@
5439 @@ -82,6 +84,21 @@
5461 diff -Naur a/drivers/gpu/drm/meson/meson_dw_hdmi.c b/drivers/gpu/drm/meson/meson_dw_hdmi.c
5462 --- a/drivers/gpu/drm/meson/meson_dw_hdmi.c 2022-05-27 17:20:15.601901127 +0800
5463 +++ b/drivers/gpu/drm/meson/meson_dw_hdmi.c 2022-05-31 11:56:47.729259361 +0800
5464 @@ -22,14 +22,11 @@
5468 -#include <linux/media-bus-format.h>
5474 -#include "meson_vclk.h"
5475 -#include "meson_venc.h"
5477 #define DRIVER_NAME "meson-dw-hdmi"
5478 #define DRIVER_DESC "Amlogic Meson HDMI-TX DRM driver"
5479 @@ -135,8 +132,6 @@
5483 - struct drm_encoder encoder;
5484 - struct drm_bridge bridge;
5488 @@ -148,12 +143,8 @@
5492 - unsigned long output_bus_fmt;
5495 -#define encoder_to_meson_dw_hdmi(x) \
5496 - container_of(x, struct meson_dw_hdmi, encoder)
5497 -#define bridge_to_meson_dw_hdmi(x) \
5498 - container_of(x, struct meson_dw_hdmi, bridge)
5502 @@ -295,14 +286,14 @@
5506 - const struct drm_display_mode *mode)
5510 struct meson_drm *priv = dw_hdmi->priv;
5511 unsigned int pixel_clock = mode->clock;
5514 - if (dw_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
5515 - pixel_clock /= 2;
5518 if (dw_hdmi_is_compatible(dw_hdmi, "amlogic,meson-gxl-dw-hdmi") ||
5519 dw_hdmi_is_compatible(dw_hdmi, "amlogic,meson-gxm-dw-hdmi")) {
5520 @@ -374,68 +365,25 @@
5524 -static void dw_hdmi_set_vclk(struct meson_dw_hdmi *dw_hdmi,
5525 - const struct drm_display_mode *mode)
5526 -{
5527 - struct meson_drm *priv = dw_hdmi->priv;
5528 - int vic = drm_match_cea_mode(mode);
5529 - unsigned int phy_freq;
5530 - unsigned int vclk_freq;
5531 - unsigned int venc_freq;
5532 - unsigned int hdmi_freq;
5533 -
5534 - vclk_freq = mode->clock;
5535 -
5536 - /* For 420, pixel clock is half unlike venc clock */
5537 - if (dw_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
5538 - vclk_freq /= 2;
5539 -
5540 - /* TMDS clock is pixel_clock * 10 */
5541 - phy_freq = vclk_freq * 10;
5542 -
5543 - if (!vic) {
5544 - meson_vclk_setup(priv, MESON_VCLK_TARGET_DMT, phy_freq,
5545 - vclk_freq, vclk_freq, vclk_freq, false);
5546 - return;
5547 - }
5548 -
5549 - /* 480i/576i needs global pixel doubling */
5550 - if (mode->flags & DRM_MODE_FLAG_DBLCLK)
5551 - vclk_freq *= 2;
5552 -
5553 - venc_freq = vclk_freq;
5554 - hdmi_freq = vclk_freq;
5555 -
5556 - /* VENC double pixels for 1080i, 720p and YUV420 modes */
5557 - if (meson_venc_hdmi_venc_repeat(vic) ||
5558 - dw_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
5559 - venc_freq *= 2;
5560 -
5561 - vclk_freq = max(venc_freq, hdmi_freq);
5562 -
5563 - if (mode->flags & DRM_MODE_FLAG_DBLCLK)
5564 - venc_freq /= 2;
5565 -
5566 - DRM_DEBUG_DRIVER("vclk:%d phy=%d venc=%d hdmi=%d enci=%d\n",
5567 - phy_freq, vclk_freq, venc_freq, hdmi_freq,
5568 - priv->venc.hdmi_use_enci);
5569 -
5570 - meson_vclk_setup(priv, MESON_VCLK_TARGET_HDMI, phy_freq, vclk_freq,
5571 - venc_freq, hdmi_freq, priv->venc.hdmi_use_enci);
5572 -}
5573 -
5579 + bool is_hdmi2_sink = display->hdmi.scdc.supported;
5580 struct meson_drm *priv = dw_hdmi->priv;
5582 readl_relaxed(priv->io_base + _REG(VPU_HDMI_SETTING));
5585 DRM_DEBUG_DRIVER("\"%s\" div%d\n", mode->name,
5586 mode->clock > 340000 ? 40 : 10);
5594 regmap_update_bits(priv->hhi, HHI_HDMI_CLK_CNTL, 0xffff, 0x100);
5596 @@ -457,8 +405,7 @@
5597 dw_hdmi->data->top_write(dw_hdmi, HDMITX_TOP_BIST_CNTL, BIT(12));
5600 - if (mode->clock > 340000 &&
5601 - dw_hdmi->output_bus_fmt == MEDIA_BUS_FMT_YUV8_1X24) {
5602 + if (mode->clock > 340000 && !mode_is_420) {
5603 dw_hdmi->data->top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_01,
5605 dw_hdmi->data->top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_23,
5606 @@ -476,7 +423,7 @@
5607 dw_hdmi->data->top_write(dw_hdmi, HDMITX_TOP_TMDS_CLK_PTTN_CNTL, 0x2);
5610 - meson_hdmi_phy_setup_mode(dw_hdmi, mode);
5614 regmap_update_bits(priv->hhi, HHI_HDMI_PHY_CNTL1,
5615 @@ -622,214 +569,15 @@
5616 dw_hdmi_setup_rx_sense(dw_hdmi->hdmi, hpd_connected,
5619 - drm_helper_hpd_irq_event(dw_hdmi->encoder.dev);
5620 + drm_helper_hpd_irq_event(dw_hdmi->bridge->dev);
5621 + drm_bridge_hpd_notify(dw_hdmi->bridge,
5629 -static enum drm_mode_status
5630 -dw_hdmi_mode_valid(struct dw_hdmi *hdmi, void *data,
5631 - const struct drm_display_info *display_info,
5632 - const struct drm_display_mode *mode)
5633 -{
5634 - struct meson_dw_hdmi *dw_hdmi = data;
5635 - struct meson_drm *priv = dw_hdmi->priv;
5636 - bool is_hdmi2_sink = display_info->hdmi.scdc.supported;
5637 - unsigned int phy_freq;
5638 - unsigned int vclk_freq;
5639 - unsigned int venc_freq;
5640 - unsigned int hdmi_freq;
5641 - int vic = drm_match_cea_mode(mode);
5642 - enum drm_mode_status status;
5643 -
5644 - DRM_DEBUG_DRIVER("Modeline " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
5645 -
5646 - /* If sink does not support 540MHz, reject the non-420 HDMI2 modes */
5647 - if (display_info->max_tmds_clock &&
5648 - mode->clock > display_info->max_tmds_clock &&
5649 - !drm_mode_is_420_only(display_info, mode) &&
5650 - !drm_mode_is_420_also(display_info, mode))
5651 - return MODE_BAD;
5652 -
5653 - /* Check against non-VIC supported modes */
5654 - if (!vic) {
5655 - status = meson_venc_hdmi_supported_mode(mode);
5656 - if (status != MODE_OK)
5657 - return status;
5658 -
5659 - return meson_vclk_dmt_supported_freq(priv, mode->clock);
5660 - /* Check against supported VIC modes */
5661 - } else if (!meson_venc_hdmi_supported_vic(vic))
5662 - return MODE_BAD;
5663 -
5664 - vclk_freq = mode->clock;
5665 -
5666 - /* For 420, pixel clock is half unlike venc clock */
5667 - if (drm_mode_is_420_only(display_info, mode) ||
5668 - (!is_hdmi2_sink &&
5669 - drm_mode_is_420_also(display_info, mode)))
5670 - vclk_freq /= 2;
5671 -
5672 - /* TMDS clock is pixel_clock * 10 */
5673 - phy_freq = vclk_freq * 10;
5674 -
5675 - /* 480i/576i needs global pixel doubling */
5676 - if (mode->flags & DRM_MODE_FLAG_DBLCLK)
5677 - vclk_freq *= 2;
5678 -
5679 - venc_freq = vclk_freq;
5680 - hdmi_freq = vclk_freq;
5681 -
5682 - /* VENC double pixels for 1080i, 720p and YUV420 modes */
5683 - if (meson_venc_hdmi_venc_repeat(vic) ||
5684 - drm_mode_is_420_only(display_info, mode) ||
5685 - (!is_hdmi2_sink &&
5686 - drm_mode_is_420_also(display_info, mode)))
5687 - venc_freq *= 2;
5688 -
5689 - vclk_freq = max(venc_freq, hdmi_freq);
5690 -
5691 - if (mode->flags & DRM_MODE_FLAG_DBLCLK)
5692 - venc_freq /= 2;
5693 -
5694 - dev_dbg(dw_hdmi->dev, "%s: vclk:%d phy=%d venc=%d hdmi=%d\n",
5695 - __func__, phy_freq, vclk_freq, venc_freq, hdmi_freq);
5696 -
5697 - return meson_vclk_vic_supported_freq(priv, phy_freq, vclk_freq);
5698 -}
5699 -
5700 -/* Encoder */
5701 -
5702 -static const u32 meson_dw_hdmi_out_bus_fmts[] = {
5703 - MEDIA_BUS_FMT_YUV8_1X24,
5704 - MEDIA_BUS_FMT_UYYVYY8_0_5X24,
5705 -};
5706 -
5707 -static void meson_venc_hdmi_encoder_destroy(struct drm_encoder *encoder)
5708 -{
5709 - drm_encoder_cleanup(encoder);
5710 -}
5711 -
5712 -static const struct drm_encoder_funcs meson_venc_hdmi_encoder_funcs = {
5713 - .destroy = meson_venc_hdmi_encoder_destroy,
5714 -};
5715 -
5716 -static u32 *
5717 -meson_venc_hdmi_encoder_get_inp_bus_fmts(struct drm_bridge *bridge,
5718 - struct drm_bridge_state *bridge_state,
5719 - struct drm_crtc_state *crtc_state,
5720 - struct drm_connector_state *conn_state,
5721 - u32 output_fmt,
5722 - unsigned int *num_input_fmts)
5723 -{
5724 - u32 *input_fmts = NULL;
5725 - int i;
5726 -
5727 - *num_input_fmts = 0;
5728 -
5729 - for (i = 0 ; i < ARRAY_SIZE(meson_dw_hdmi_out_bus_fmts) ; ++i) {
5730 - if (output_fmt == meson_dw_hdmi_out_bus_fmts[i]) {
5731 - *num_input_fmts = 1;
5732 - input_fmts = kcalloc(*num_input_fmts,
5733 - sizeof(*input_fmts),
5734 - GFP_KERNEL);
5735 - if (!input_fmts)
5736 - return NULL;
5737 -
5738 - input_fmts[0] = output_fmt;
5739 -
5740 - break;
5741 - }
5742 - }
5743 -
5744 - return input_fmts;
5745 -}
5746 -
5747 -static int meson_venc_hdmi_encoder_atomic_check(struct drm_bridge *bridge,
5748 - struct drm_bridge_state *bridge_state,
5749 - struct drm_crtc_state *crtc_state,
5750 - struct drm_connector_state *conn_state)
5751 -{
5752 - struct meson_dw_hdmi *dw_hdmi = bridge_to_meson_dw_hdmi(bridge);
5753 -
5754 - dw_hdmi->output_bus_fmt = bridge_state->output_bus_cfg.format;
5755 -
5756 - DRM_DEBUG_DRIVER("output_bus_fmt %lx\n", dw_hdmi->output_bus_fmt);
5757 -
5758 - return 0;
5759 -}
5760 -
5761 -static void meson_venc_hdmi_encoder_disable(struct drm_bridge *bridge)
5762 -{
5763 - struct meson_dw_hdmi *dw_hdmi = bridge_to_meson_dw_hdmi(bridge);
5764 - struct meson_drm *priv = dw_hdmi->priv;
5765 -
5766 - DRM_DEBUG_DRIVER("\n");
5767 -
5768 - writel_bits_relaxed(0x3, 0,
5769 - priv->io_base + _REG(VPU_HDMI_SETTING));
5770 -
5771 - writel_relaxed(0, priv->io_base + _REG(ENCI_VIDEO_EN));
5772 - writel_relaxed(0, priv->io_base + _REG(ENCP_VIDEO_EN));
5773 -}
5774 -
5775 -static void meson_venc_hdmi_encoder_enable(struct drm_bridge *bridge)
5776 -{
5777 - struct meson_dw_hdmi *dw_hdmi = bridge_to_meson_dw_hdmi(bridge);
5778 - struct meson_drm *priv = dw_hdmi->priv;
5779 -
5780 - DRM_DEBUG_DRIVER("%s\n", priv->venc.hdmi_use_enci ? "VENCI" : "VENCP");
5781 -
5782 - if (priv->venc.hdmi_use_enci)
5783 - writel_relaxed(1, priv->io_base + _REG(ENCI_VIDEO_EN));
5784 - else
5785 - writel_relaxed(1, priv->io_base + _REG(ENCP_VIDEO_EN));
5786 -}
5787 -
5788 -static void meson_venc_hdmi_encoder_mode_set(struct drm_bridge *bridge,
5789 - const struct drm_display_mode *mode,
5790 - const struct drm_display_mode *adjusted_mode)
5791 -{
5792 - struct meson_dw_hdmi *dw_hdmi = bridge_to_meson_dw_hdmi(bridge);
5793 - struct meson_drm *priv = dw_hdmi->priv;
5794 - int vic = drm_match_cea_mode(mode);
5795 - unsigned int ycrcb_map = VPU_HDMI_OUTPUT_CBYCR;
5796 - bool yuv420_mode = false;
5797 -
5798 - DRM_DEBUG_DRIVER("\"%s\" vic %d\n", mode->name, vic);
5799 -
5800 - if (dw_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24) {
5801 - ycrcb_map = VPU_HDMI_OUTPUT_CRYCB;
5802 - yuv420_mode = true;
5803 - }
5804 -
5805 - /* VENC + VENC-DVI Mode setup */
5806 - meson_venc_hdmi_mode_set(priv, vic, ycrcb_map, yuv420_mode, mode);
5807 -
5808 - /* VCLK Set clock */
5809 - dw_hdmi_set_vclk(dw_hdmi, mode);
5810 -
5811 - if (dw_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
5812 - /* Setup YUV420 to HDMI-TX, no 10bit diphering */
5813 - writel_relaxed(2 | (2 << 2),
5814 - priv->io_base + _REG(VPU_HDMI_FMT_CTRL));
5815 - else
5816 - /* Setup YUV444 to HDMI-TX, no 10bit diphering */
5817 - writel_relaxed(0, priv->io_base + _REG(VPU_HDMI_FMT_CTRL));
5818 -}
5819 -
5820 -static const struct drm_bridge_funcs meson_venc_hdmi_encoder_bridge_funcs = {
5821 - .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
5822 - .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
5823 - .atomic_get_input_bus_fmts = meson_venc_hdmi_encoder_get_inp_bus_fmts,
5824 - .atomic_reset = drm_atomic_helper_bridge_reset,
5825 - .atomic_check = meson_venc_hdmi_encoder_atomic_check,
5826 - .enable = meson_venc_hdmi_encoder_enable,
5827 - .disable = meson_venc_hdmi_encoder_disable,
5828 - .mode_set = meson_venc_hdmi_encoder_mode_set,
5829 -};
5830 -
5834 @@ -876,28 +624,6 @@
5838 -static bool meson_hdmi_connector_is_available(struct device *dev)
5839 -{
5840 - struct device_node *ep, *remote;
5841 -
5842 - /* HDMI Connector is on the second port, first endpoint */
5843 - ep = of_graph_get_endpoint_by_regs(dev->of_node, 1, 0);
5844 - if (!ep)
5845 - return false;
5846 -
5847 - /* If the endpoint node exists, consider it enabled */
5848 - remote = of_graph_get_remote_port(ep);
5849 - if (remote) {
5850 - of_node_put(ep);
5851 - return true;
5852 - }
5853 -
5854 - of_node_put(ep);
5855 - of_node_put(remote);
5856 -
5857 - return false;
5858 -}
5859 -
5862 struct meson_drm *priv = meson_dw_hdmi->priv;
5863 @@ -976,19 +702,11 @@
5865 struct meson_drm *priv = drm->dev_private;
5867 - struct drm_bridge *next_bridge;
5868 - struct drm_encoder *encoder;
5869 - struct resource *res;
5875 - if (!meson_hdmi_connector_is_available(dev)) {
5876 - dev_info(drm->dev, "HDMI Output connector not available\n");
5877 - return -ENODEV;
5878 - }
5879 -
5880 match = of_device_get_match_data(&pdev->dev);
5882 dev_err(&pdev->dev, "failed to get match data\n");
5883 @@ -1004,7 +722,6 @@
5884 meson_dw_hdmi->dev = dev;
5885 meson_dw_hdmi->data = match;
5886 dw_plat_data = &meson_dw_hdmi->dw_plat_data;
5887 - encoder = &meson_dw_hdmi->encoder;
5889 meson_dw_hdmi->hdmi_supply = devm_regulator_get_optional(dev, "hdmi");
5890 if (IS_ERR(meson_dw_hdmi->hdmi_supply)) {
5891 @@ -1042,8 +759,7 @@
5892 return PTR_ERR(meson_dw_hdmi->hdmitx_phy);
5895 - res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
5896 - meson_dw_hdmi->hdmitx = devm_ioremap_resource(dev, res);
5897 + meson_dw_hdmi->hdmitx = devm_platform_ioremap_resource(pdev, 0);
5898 if (IS_ERR(meson_dw_hdmi->hdmitx))
5899 return PTR_ERR(meson_dw_hdmi->hdmitx);
5901 @@ -1076,33 +792,18 @@
5905 - /* Encoder */
5906 -
5907 - ret = drm_encoder_init(drm, encoder, &meson_venc_hdmi_encoder_funcs,
5908 - DRM_MODE_ENCODER_TMDS, "meson_hdmi");
5909 - if (ret) {
5910 - dev_err(priv->dev, "Failed to init HDMI encoder\n");
5911 - return ret;
5912 - }
5913 -
5914 - meson_dw_hdmi->bridge.funcs = &meson_venc_hdmi_encoder_bridge_funcs;
5915 - drm_bridge_attach(encoder, &meson_dw_hdmi->bridge, NULL, 0);
5916 -
5917 - encoder->possible_crtcs = BIT(0);
5918 -
5921 - DRM_DEBUG_DRIVER("encoder initialized\n");
5922 -
5925 dw_plat_data->priv_data = meson_dw_hdmi;
5926 - dw_plat_data->mode_valid = dw_hdmi_mode_valid;
5927 dw_plat_data->phy_ops = &meson_dw_hdmi_phy_ops;
5928 dw_plat_data->phy_name = "meson_dw_hdmi_phy";
5929 dw_plat_data->phy_data = meson_dw_hdmi;
5930 dw_plat_data->input_bus_encoding = V4L2_YCBCR_ENC_709;
5931 dw_plat_data->ycbcr_420_allowed = true;
5932 + dw_plat_data->disable_cec = true;
5933 + dw_plat_data->output_port = 1;
5935 if (dw_hdmi_is_compatible(meson_dw_hdmi, "amlogic,meson-gxl-dw-hdmi") ||
5936 dw_hdmi_is_compatible(meson_dw_hdmi, "amlogic,meson-gxm-dw-hdmi") ||
5937 @@ -1111,15 +812,11 @@
5941 - meson_dw_hdmi->hdmi = dw_hdmi_probe(pdev,
5942 - &meson_dw_hdmi->dw_plat_data);
5943 + meson_dw_hdmi->hdmi = dw_hdmi_probe(pdev, &meson_dw_hdmi->dw_plat_data);
5944 if (IS_ERR(meson_dw_hdmi->hdmi))
5945 return PTR_ERR(meson_dw_hdmi->hdmi);
5947 - next_bridge = of_drm_find_bridge(pdev->dev.of_node);
5948 - if (next_bridge)
5949 - drm_bridge_attach(encoder, next_bridge,
5950 - &meson_dw_hdmi->bridge, 0);
5951 + meson_dw_hdmi->bridge = of_drm_find_bridge(pdev->dev.of_node);
5955 diff -Naur a/drivers/gpu/drm/meson/meson_dw_mipi_dsi.c b/drivers/gpu/drm/meson/meson_dw_mipi_dsi.c
5956 --- a/drivers/gpu/drm/meson/meson_dw_mipi_dsi.c 1970-01-01 08:00:00.000000000 +0800
5957 +++ b/drivers/gpu/drm/meson/meson_dw_mipi_dsi.c 2022-05-31 11:56:47.733259325 +0800
5958 @@ -0,0 +1,364 @@
5959 +// SPDX-License-Identifier: GPL-2.0-or-later
5991 +#define DRIVER_NAME "meson-dw-mipi-dsi"
5992 +#define DRIVER_DESC "Amlogic Meson MIPI-DSI DRM driver"
6017 + mipi_dsi->base + MIPI_DSI_TOP_SW_RESET);
6020 + 0, mipi_dsi->base + MIPI_DSI_TOP_SW_RESET);
6025 + mipi_dsi->base + MIPI_DSI_TOP_CLK_CNTL);
6028 + writel_relaxed(0, mipi_dsi->base + MIPI_DSI_TOP_MEM_PD);
6037 + ret = clk_set_rate(mipi_dsi->px_clk, mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate);
6040 + mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate);
6045 + switch (mipi_dsi->dsi_device->format) {
6056 + return -EINVAL;
6065 + (mipi_dsi->mode->flags & DRM_MODE_FLAG_NHSYNC ?
6067 + (mipi_dsi->mode->flags & DRM_MODE_FLAG_NVSYNC ?
6069 + mipi_dsi->base + MIPI_DSI_TOP_CNTL);
6071 + return phy_configure(mipi_dsi->phy, &mipi_dsi->phy_opts);
6078 + if (phy_power_on(mipi_dsi->phy))
6079 + dev_warn(mipi_dsi->dev, "Failed to power on PHY\n");
6086 + if (phy_power_off(mipi_dsi->phy))
6087 + dev_warn(mipi_dsi->dev, "Failed to power off PHY\n");
6098 + mipi_dsi->mode = mode;
6100 + bpp = mipi_dsi_pixel_format_to_bpp(mipi_dsi->dsi_device->format);
6102 + phy_mipi_dphy_get_default_config(mode->clock * 1000,
6103 + bpp, mipi_dsi->dsi_device->lanes,
6104 + &mipi_dsi->phy_opts.mipi_dphy);
6107 + if (mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate > 600*1000000) {
6108 + mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate = max(800 * 1000000,
6109 + mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate);
6112 + *lane_mbps = mipi_dsi->phy_opts.mipi_dphy.hs_clk_rate / 1000000;
6123 + timing->clk_lp2hs = 37;
6124 + timing->clk_hs2lp = 135;
6125 + timing->data_lp2hs = 50;
6126 + timing->data_hs2lp = 3;
6152 + struct meson_drm *priv = drm->dev_private;
6154 + /* Check before if we are supposed to have a sub-device... */
6155 + if (!mipi_dsi->dsi_device) {
6156 + dw_mipi_dsi_remove(mipi_dsi->dmd);
6157 + return -EPROBE_DEFER;
6160 + mipi_dsi->priv = priv;
6176 + mipi_dsi->dsi_device = device;
6178 + switch (device->format) {
6185 + dev_err(mipi_dsi->dev, "invalid pixel format %d\n", device->format);
6186 + return -EINVAL;
6189 + return phy_init(mipi_dsi->phy);
6197 + if (device == mipi_dsi->dsi_device)
6198 + mipi_dsi->dsi_device = NULL;
6200 + return -EINVAL;
6202 + return phy_exit(mipi_dsi->phy);
6217 + mipi_dsi = devm_kzalloc(&pdev->dev, sizeof(*mipi_dsi), GFP_KERNEL);
6219 + return -ENOMEM;
6221 + mipi_dsi->dev = &pdev->dev;
6224 + mipi_dsi->base = devm_ioremap_resource(&pdev->dev, res);
6225 + if (IS_ERR(mipi_dsi->base))
6226 + return PTR_ERR(mipi_dsi->base);
6228 + mipi_dsi->phy = devm_phy_get(&pdev->dev, "dphy");
6229 + if (IS_ERR(mipi_dsi->phy)) {
6230 + ret = PTR_ERR(mipi_dsi->phy);
6231 + dev_err(&pdev->dev, "failed to get mipi dphy: %d\n", ret);
6235 + mipi_dsi->px_clk = devm_clk_get(&pdev->dev, "px_clk");
6236 + if (IS_ERR(mipi_dsi->px_clk)) {
6237 + dev_err(&pdev->dev, "Unable to get PLL clk\n");
6238 + return PTR_ERR(mipi_dsi->px_clk);
6245 + top_rst = devm_reset_control_get_exclusive(&pdev->dev, "top");
6249 + if (ret != -EPROBE_DEFER)
6250 + dev_err(&pdev->dev, "Unable to get reset control: %d\n", ret);
6255 + ret = clk_prepare_enable(mipi_dsi->px_clk);
6257 + dev_err(&pdev->dev, "Unable to prepare/enable PX clock\n");
6267 + mipi_dsi->pdata.base = mipi_dsi->base;
6268 + mipi_dsi->pdata.max_data_lanes = 4;
6269 + mipi_dsi->pdata.phy_ops = &meson_dw_mipi_dsi_phy_ops;
6270 + mipi_dsi->pdata.host_ops = &meson_dw_mipi_dsi_host_ops;
6271 + mipi_dsi->pdata.priv_data = mipi_dsi;
6274 + mipi_dsi->dmd = dw_mipi_dsi_probe(pdev, &mipi_dsi->pdata);
6275 + if (IS_ERR(mipi_dsi->dmd)) {
6276 + ret = PTR_ERR(mipi_dsi->dmd);
6277 + if (ret != -EPROBE_DEFER)
6278 + dev_err(&pdev->dev,
6283 + return component_add(mipi_dsi->dev, &meson_dw_mipi_dsi_ops);
6286 + clk_disable_unprepare(mipi_dsi->px_clk);
6293 + struct meson_dw_mipi_dsi *mipi_dsi = dev_get_drvdata(&pdev->dev);
6295 + dw_mipi_dsi_remove(mipi_dsi->dmd);
6297 + component_del(mipi_dsi->dev, &meson_dw_mipi_dsi_ops);
6299 + clk_disable_unprepare(mipi_dsi->px_clk);
6305 + { .compatible = "amlogic,meson-g12a-dw-mipi-dsi", },
6323 diff -Naur a/drivers/gpu/drm/meson/meson_dw_mipi_dsi.h b/drivers/gpu/drm/meson/meson_dw_mipi_dsi.h
6324 --- a/drivers/gpu/drm/meson/meson_dw_mipi_dsi.h 1970-01-01 08:00:00.000000000 +0800
6325 +++ b/drivers/gpu/drm/meson/meson_dw_mipi_dsi.h 2022-05-31 11:56:47.733259325 +0800
6326 @@ -0,0 +1,160 @@
6327 +/* SPDX-License-Identifier: GPL-2.0-or-later */
6337 +/* Top-level registers */
6361 + * [2] RW clock_freerun: Apply to auto-clock gate only. Default 0.
6362 + * 0=Default, use auto-clock gating to save power;
6363 + * 1=use free-run clock, disable auto-clock gating, for debug mode.
6365 + * have auto-clock gating. 1=Enable pixclk. Default 0.
6367 + * have auto-clock gating. 1=Enable sysclk. Default 0.
6376 + * 0=16-bit RGB565 config 1;
6377 + * 1=16-bit RGB565 config 2;
6378 + * 2=16-bit RGB565 config 3;
6379 + * 3=18-bit RGB666 config 1;
6380 + * 4=18-bit RGB666 config 2;
6381 + * 5=24-bit RGB888;
6382 + * 6=20-bit YCbCr 4:2:2;
6383 + * 7=24-bit YCbCr 4:2:2;
6384 + * 8=16-bit YCbCr 4:2:2;
6385 + * 9=30-bit RGB;
6386 + * 10=36-bit RGB;
6387 + * 11=12-bit YCbCr 4:2:0.
6390 + * 0=30-bit pixel;
6391 + * 1=24-bit pixel;
6392 + * 2=18-bit pixel, RGB666;
6393 + * 3=16-bit pixel, RGB565.
6487 diff -Naur a/drivers/gpu/drm/meson/meson_encoder_cvbs.c b/drivers/gpu/drm/meson/meson_encoder_cvbs.c
6488 --- a/drivers/gpu/drm/meson/meson_encoder_cvbs.c 1970-01-01 08:00:00.000000000 +0800
6489 +++ b/drivers/gpu/drm/meson/meson_encoder_cvbs.c 2022-05-31 11:56:47.733259325 +0800
6490 @@ -0,0 +1,284 @@
6491 +// SPDX-License-Identifier: GPL-2.0-or-later
6564 + if (drm_mode_match(req_mode, &meson_mode->mode,
6581 + return drm_bridge_attach(bridge->encoder, meson_encoder_cvbs->next_bridge,
6582 + &meson_encoder_cvbs->bridge, flags);
6590 + struct meson_drm *priv = meson_encoder_cvbs->priv;
6597 + mode = drm_mode_duplicate(priv->drm, &meson_mode->mode);
6599 + dev_err(priv->dev, "Failed to create a new display mode\n");
6624 + if (meson_cvbs_get_mode(&crtc_state->mode))
6627 + return -EINVAL;
6634 + struct drm_atomic_state *state = bridge_state->base.state;
6635 + struct meson_drm *priv = encoder_cvbs->priv;
6641 + connector = drm_atomic_get_new_connector_for_encoder(state, bridge->encoder);
6649 + crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
6653 + meson_mode = meson_cvbs_get_mode(&crtc_state->adjusted_mode);
6657 + meson_venci_cvbs_mode_set(priv, meson_mode->enci);
6667 + priv->io_base + _REG(VENC_VDAC_DACSEL0));
6670 + regmap_write(priv->hhi, HHI_VDAC_CNTL0, 1);
6671 + regmap_write(priv->hhi, HHI_VDAC_CNTL1, 0);
6674 + regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0xf0001);
6675 + regmap_write(priv->hhi, HHI_VDAC_CNTL1, 0);
6677 + regmap_write(priv->hhi, HHI_VDAC_CNTL0_G12A, 0x906001);
6678 + regmap_write(priv->hhi, HHI_VDAC_CNTL1_G12A, 0);
6687 + struct meson_drm *priv = meson_encoder_cvbs->priv;
6691 + regmap_write(priv->hhi, HHI_VDAC_CNTL0_G12A, 0);
6692 + regmap_write(priv->hhi, HHI_VDAC_CNTL1_G12A, 0);
6694 + regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0);
6695 + regmap_write(priv->hhi, HHI_VDAC_CNTL1, 8);
6713 + struct drm_device *drm = priv->drm;
6719 + meson_encoder_cvbs = devm_kzalloc(priv->dev, sizeof(*meson_encoder_cvbs), GFP_KERNEL);
6721 + return -ENOMEM;
6724 + remote = of_graph_get_remote_node(priv->dev->of_node, 0, 0);
6726 + dev_info(drm->dev, "CVBS Output connector not available\n");
6730 + meson_encoder_cvbs->next_bridge = of_drm_find_bridge(remote);
6731 + if (!meson_encoder_cvbs->next_bridge) {
6732 + dev_err(priv->dev, "Failed to find CVBS Connector bridge\n");
6733 + return -EPROBE_DEFER;
6737 + meson_encoder_cvbs->bridge.funcs = &meson_encoder_cvbs_bridge_funcs;
6738 + meson_encoder_cvbs->bridge.of_node = priv->dev->of_node;
6739 + meson_encoder_cvbs->bridge.type = DRM_MODE_CONNECTOR_Composite;
6740 + meson_encoder_cvbs->bridge.ops = DRM_BRIDGE_OP_MODES;
6741 + meson_encoder_cvbs->bridge.interlace_allowed = true;
6743 + drm_bridge_add(&meson_encoder_cvbs->bridge);
6745 + meson_encoder_cvbs->priv = priv;
6748 + ret = drm_simple_encoder_init(priv->drm, &meson_encoder_cvbs->encoder,
6751 + dev_err(priv->dev, "Failed to init CVBS encoder: %d\n", ret);
6755 + meson_encoder_cvbs->encoder.possible_crtcs = BIT(0);
6758 + ret = drm_bridge_attach(&meson_encoder_cvbs->encoder, &meson_encoder_cvbs->bridge, NULL,
6761 + dev_err(priv->dev, "Failed to attach bridge: %d\n", ret);
6766 + connector = drm_bridge_connector_init(priv->drm, &meson_encoder_cvbs->encoder);
6768 + dev_err(priv->dev, "Unable to create CVBS bridge connector\n");
6771 + drm_connector_attach_encoder(connector, &meson_encoder_cvbs->encoder);
6775 diff -Naur a/drivers/gpu/drm/meson/meson_encoder_cvbs.h b/drivers/gpu/drm/meson/meson_encoder_cvbs.h
6776 --- a/drivers/gpu/drm/meson/meson_encoder_cvbs.h 1970-01-01 08:00:00.000000000 +0800
6777 +++ b/drivers/gpu/drm/meson/meson_encoder_cvbs.h 2022-05-31 11:56:47.733259325 +0800
6778 @@ -0,0 +1,29 @@
6779 +/* SPDX-License-Identifier: GPL-2.0-or-later */
6808 diff -Naur a/drivers/gpu/drm/meson/meson_encoder_dsi.c b/drivers/gpu/drm/meson/meson_encoder_dsi.c
6809 --- a/drivers/gpu/drm/meson/meson_encoder_dsi.c 1970-01-01 08:00:00.000000000 +0800
6810 +++ b/drivers/gpu/drm/meson/meson_encoder_dsi.c 2022-05-31 11:56:47.733259325 +0800
6811 @@ -0,0 +1,168 @@
6812 +// SPDX-License-Identifier: GPL-2.0-or-later
6852 + return drm_bridge_attach(bridge->encoder, encoder_dsi->next_bridge,
6853 + &encoder_dsi->bridge, flags);
6861 + struct meson_drm *priv = encoder_dsi->priv;
6863 + meson_vclk_setup(priv, MESON_VCLK_TARGET_DSI, mode->clock, 0, 0, 0, false);
6868 + writel_relaxed(0, priv->io_base + _REG(ENCL_VIDEO_EN));
6871 + priv->io_base + _REG(ENCL_VIDEO_MODE_ADV));
6872 + writel_relaxed(0, priv->io_base + _REG(ENCL_TST_EN));
6879 + struct meson_drm *priv = encoder_dsi->priv;
6885 + priv->io_base + _REG(OSD1_HDR2_CTRL));
6886 + dev_info(priv->dev, "set OSD1_HDR2_CTRL to fix green/black color distortion.\n");
6889 + writel_bits_relaxed(BIT(0), 0, priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL));
6891 + writel_relaxed(1, priv->io_base + _REG(ENCL_VIDEO_EN));
6899 + struct meson_drm *priv = meson_encoder_dsi->priv;
6901 + writel_relaxed(0, priv->io_base + _REG(ENCL_VIDEO_EN));
6903 + writel_bits_relaxed(BIT(0), BIT(0), priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL));
6909 + * TOFIX: remove when dw-mipi-dsi moves out of mode_set
6910 + * We should get rid of mode_set, but until dw-mipi-dsi uses it
6928 + meson_encoder_dsi = devm_kzalloc(priv->dev, sizeof(*meson_encoder_dsi), GFP_KERNEL);
6930 + return -ENOMEM;
6933 + remote = of_graph_get_remote_node(priv->dev->of_node, 2, 0);
6935 + dev_err(priv->dev, "DSI transceiver device is disabled");
6939 + meson_encoder_dsi->next_bridge = of_drm_find_bridge(remote);
6940 + if (!meson_encoder_dsi->next_bridge) {
6941 + dev_dbg(priv->dev, "Failed to find DSI transceiver bridge: %d\n", ret);
6942 + return -EPROBE_DEFER;
6946 + meson_encoder_dsi->bridge.funcs = &meson_encoder_dsi_bridge_funcs;
6947 + meson_encoder_dsi->bridge.of_node = priv->dev->of_node;
6948 + meson_encoder_dsi->bridge.type = DRM_MODE_CONNECTOR_DSI;
6950 + drm_bridge_add(&meson_encoder_dsi->bridge);
6952 + meson_encoder_dsi->priv = priv;
6955 + ret = drm_simple_encoder_init(priv->drm, &meson_encoder_dsi->encoder,
6958 + dev_err(priv->dev, "Failed to init DSI encoder: %d\n", ret);
6962 + meson_encoder_dsi->encoder.possible_crtcs = BIT(0);
6965 + ret = drm_bridge_attach(&meson_encoder_dsi->encoder, &meson_encoder_dsi->bridge, NULL, 0);
6967 + dev_err(priv->dev, "Failed to attach bridge: %d\n", ret);
6973 + * encoder->[dsi encoder bridge]->[dw-mipi-dsi bridge]->[panel bridge]->[panel]
6976 + dev_dbg(priv->dev, "DSI encoder initialized\n");
6980 diff -Naur a/drivers/gpu/drm/meson/meson_encoder_dsi.h b/drivers/gpu/drm/meson/meson_encoder_dsi.h
6981 --- a/drivers/gpu/drm/meson/meson_encoder_dsi.h 1970-01-01 08:00:00.000000000 +0800
6982 +++ b/drivers/gpu/drm/meson/meson_encoder_dsi.h 2022-05-31 11:56:47.733259325 +0800
6983 @@ -0,0 +1,12 @@
6984 +/* SPDX-License-Identifier: GPL-2.0-or-later */
6996 diff -Naur a/drivers/gpu/drm/meson/meson_encoder_hdmi.c b/drivers/gpu/drm/meson/meson_encoder_hdmi.c
6997 --- a/drivers/gpu/drm/meson/meson_encoder_hdmi.c 1970-01-01 08:00:00.000000000 +0800
6998 +++ b/drivers/gpu/drm/meson/meson_encoder_hdmi.c 2022-05-31 11:56:47.733259325 +0800
6999 @@ -0,0 +1,455 @@
7000 +// SPDX-License-Identifier: GPL-2.0-or-later
7016 +#include <media/cec-notifier.h>
7026 +#include <linux/media-bus-format.h>
7053 + return drm_bridge_attach(bridge->encoder, encoder_hdmi->next_bridge,
7054 + &encoder_hdmi->bridge, flags);
7061 + cec_notifier_conn_unregister(encoder_hdmi->cec_notifier);
7062 + encoder_hdmi->cec_notifier = NULL;
7068 + struct meson_drm *priv = encoder_hdmi->priv;
7075 + vclk_freq = mode->clock;
7078 + if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
7091 + if (mode->flags & DRM_MODE_FLAG_DBLCLK)
7099 + encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
7104 + if (mode->flags & DRM_MODE_FLAG_DBLCLK)
7107 + dev_dbg(priv->dev, "vclk:%d phy=%d venc=%d hdmi=%d enci=%d\n",
7109 + priv->venc.hdmi_use_enci);
7112 + venc_freq, hdmi_freq, priv->venc.hdmi_use_enci);
7120 + struct meson_drm *priv = encoder_hdmi->priv;
7121 + bool is_hdmi2_sink = display_info->hdmi.scdc.supported;
7129 + dev_dbg(priv->dev, "Modeline " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
7131 + /* If sink does not support 540MHz, reject the non-420 HDMI2 modes */
7132 + if (display_info->max_tmds_clock &&
7133 + mode->clock > display_info->max_tmds_clock &&
7138 + /* Check against non-VIC supported modes */
7144 + return meson_vclk_dmt_supported_freq(priv, mode->clock);
7149 + vclk_freq = mode->clock;
7161 + if (mode->flags & DRM_MODE_FLAG_DBLCLK)
7176 + if (mode->flags & DRM_MODE_FLAG_DBLCLK)
7179 + dev_dbg(priv->dev, "%s: vclk:%d phy=%d venc=%d hdmi=%d\n",
7189 + struct drm_atomic_state *state = bridge_state->base.state;
7191 + struct meson_drm *priv = encoder_hdmi->priv;
7199 + connector = drm_atomic_get_new_connector_for_encoder(state, bridge->encoder);
7207 + crtc_state = drm_atomic_get_new_crtc_state(state, conn_state->crtc);
7211 + mode = &crtc_state->adjusted_mode;
7215 + dev_dbg(priv->dev, "\"%s\" vic %d\n", mode->name, vic);
7217 + if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24) {
7220 + } else if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYVY8_1X16) {
7224 + /* VENC + VENC-DVI Mode setup */
7230 + if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYYVYY8_0_5X24)
7231 + /* Setup YUV420 to HDMI-TX, no 10bit diphering */
7233 + priv->io_base + _REG(VPU_HDMI_FMT_CTRL));
7234 + else if (encoder_hdmi->output_bus_fmt == MEDIA_BUS_FMT_UYVY8_1X16)
7235 + /* Setup YUV422 to HDMI-TX, no 10bit diphering */
7237 + priv->io_base + _REG(VPU_HDMI_FMT_CTRL));
7239 + /* Setup YUV444 to HDMI-TX, no 10bit diphering */
7240 + writel_relaxed(0, priv->io_base + _REG(VPU_HDMI_FMT_CTRL));
7242 + dev_dbg(priv->dev, "%s\n", priv->venc.hdmi_use_enci ? "VENCI" : "VENCP");
7244 + if (priv->venc.hdmi_use_enci)
7245 + writel_relaxed(1, priv->io_base + _REG(ENCI_VIDEO_EN));
7247 + writel_relaxed(1, priv->io_base + _REG(ENCP_VIDEO_EN));
7254 + struct meson_drm *priv = encoder_hdmi->priv;
7257 + priv->io_base + _REG(VPU_HDMI_SETTING));
7259 + writel_relaxed(0, priv->io_base + _REG(ENCI_VIDEO_EN));
7260 + writel_relaxed(0, priv->io_base + _REG(ENCP_VIDEO_EN));
7307 + drm_atomic_get_old_connector_state(conn_state->state, conn_state->connector);
7308 + struct meson_drm *priv = encoder_hdmi->priv;
7310 + encoder_hdmi->output_bus_fmt = bridge_state->output_bus_cfg.format;
7312 + dev_dbg(priv->dev, "output_bus_fmt %lx\n", encoder_hdmi->output_bus_fmt);
7315 + crtc_state->mode_changed = true;
7326 + if (!encoder_hdmi->cec_notifier)
7330 + edid = drm_bridge_get_edid(encoder_hdmi->next_bridge, encoder_hdmi->connector);
7334 + cec_notifier_set_phys_addr_from_edid(encoder_hdmi->cec_notifier, edid);
7336 + cec_notifier_phys_addr_invalidate(encoder_hdmi->cec_notifier);
7360 + meson_encoder_hdmi = devm_kzalloc(priv->dev, sizeof(*meson_encoder_hdmi), GFP_KERNEL);
7362 + return -ENOMEM;
7365 + remote = of_graph_get_remote_node(priv->dev->of_node, 1, 0);
7367 + dev_err(priv->dev, "HDMI transceiver device is disabled");
7371 + meson_encoder_hdmi->next_bridge = of_drm_find_bridge(remote);
7372 + if (!meson_encoder_hdmi->next_bridge) {
7373 + dev_err(priv->dev, "Failed to find HDMI transceiver bridge\n");
7374 + return -EPROBE_DEFER;
7378 + meson_encoder_hdmi->bridge.funcs = &meson_encoder_hdmi_bridge_funcs;
7379 + meson_encoder_hdmi->bridge.of_node = priv->dev->of_node;
7380 + meson_encoder_hdmi->bridge.type = DRM_MODE_CONNECTOR_HDMIA;
7381 + meson_encoder_hdmi->bridge.interlace_allowed = true;
7383 + drm_bridge_add(&meson_encoder_hdmi->bridge);
7385 + meson_encoder_hdmi->priv = priv;
7388 + ret = drm_simple_encoder_init(priv->drm, &meson_encoder_hdmi->encoder,
7391 + dev_err(priv->dev, "Failed to init HDMI encoder: %d\n", ret);
7395 + meson_encoder_hdmi->encoder.possible_crtcs = BIT(0);
7398 + ret = drm_bridge_attach(&meson_encoder_hdmi->encoder, &meson_encoder_hdmi->bridge, NULL,
7401 + dev_err(priv->dev, "Failed to attach bridge: %d\n", ret);
7407 + meson_encoder_hdmi->connector = drm_bridge_connector_init(priv->drm,
7408 + &meson_encoder_hdmi->encoder);
7409 + if (IS_ERR(meson_encoder_hdmi->connector)) {
7410 + dev_err(priv->dev, "Unable to create HDMI bridge connector\n");
7411 + return PTR_ERR(meson_encoder_hdmi->connector);
7413 + drm_connector_attach_encoder(meson_encoder_hdmi->connector,
7414 + &meson_encoder_hdmi->encoder);
7418 + * encoder->[hdmi encoder bridge]->[dw-hdmi bridge]->[display connector bridge]->[display connect…
7425 + drm_atomic_helper_connector_reset(meson_encoder_hdmi->connector);
7430 + drm_connector_attach_hdr_output_metadata_property(meson_encoder_hdmi->connector);
7432 + drm_connector_attach_max_bpc_property(meson_encoder_hdmi->connector, 8, 8);
7435 + meson_encoder_hdmi->connector->ycbcr_420_allowed = true;
7442 + cec_fill_conn_info_from_drm(&conn_info, meson_encoder_hdmi->connector);
7444 + notifier = cec_notifier_conn_register(&pdev->dev, NULL, &conn_info);
7446 + return -ENOMEM;
7448 + meson_encoder_hdmi->cec_notifier = notifier;
7451 + dev_dbg(priv->dev, "HDMI encoder initialized\n");
7455 diff -Naur a/drivers/gpu/drm/meson/meson_encoder_hdmi.h b/drivers/gpu/drm/meson/meson_encoder_hdmi.h
7456 --- a/drivers/gpu/drm/meson/meson_encoder_hdmi.h 1970-01-01 08:00:00.000000000 +0800
7457 +++ b/drivers/gpu/drm/meson/meson_encoder_hdmi.h 2022-05-31 11:56:47.733259325 +0800
7458 @@ -0,0 +1,12 @@
7459 +/* SPDX-License-Identifier: GPL-2.0-or-later */
7471 diff -Naur a/drivers/gpu/drm/meson/meson_osd_afbcd.c b/drivers/gpu/drm/meson/meson_osd_afbcd.c
7472 --- a/drivers/gpu/drm/meson/meson_osd_afbcd.c 2022-05-27 17:20:15.601901127 +0800
7473 +++ b/drivers/gpu/drm/meson/meson_osd_afbcd.c 2022-05-31 11:56:47.733259325 +0800
7474 @@ -79,11 +79,6 @@
7478 -static int meson_gxm_afbcd_init(struct meson_drm *priv)
7479 -{
7480 - return 0;
7481 -}
7482 -
7486 @@ -93,6 +88,16 @@
7503 @@ -172,6 +177,7 @@
7511 @@ -269,6 +275,18 @@
7530 @@ -286,16 +304,10 @@
7534 -static int meson_g12a_afbcd_reset(struct meson_drm *priv)
7537 - meson_rdma_reset(priv);
7538 -
7539 - meson_rdma_writel_sync(priv, VIU_SW_RESET_G12A_AFBC_ARB |
7540 - VIU_SW_RESET_G12A_OSD1_AFBCD,
7541 - VIU_SW_RESET);
7542 - meson_rdma_writel_sync(priv, 0, VIU_SW_RESET);
7543 -
7544 - return 0;
7550 @@ -380,6 +392,7 @@
7558 diff -Naur a/drivers/gpu/drm/meson/meson_osd_afbcd.h b/drivers/gpu/drm/meson/meson_osd_afbcd.h
7559 --- a/drivers/gpu/drm/meson/meson_osd_afbcd.h 2022-05-27 17:20:15.601901127 +0800
7560 +++ b/drivers/gpu/drm/meson/meson_osd_afbcd.h 2022-05-31 11:56:47.733259325 +0800
7561 @@ -14,6 +14,7 @@
7569 diff -Naur a/drivers/gpu/drm/meson/meson_overlay.c b/drivers/gpu/drm/meson/meson_overlay.c
7570 --- a/drivers/gpu/drm/meson/meson_overlay.c 2022-05-27 17:20:15.601901127 +0800
7571 +++ b/drivers/gpu/drm/meson/meson_overlay.c 2022-05-31 11:56:47.733259325 +0800
7572 @@ -10,10 +10,10 @@
7578 -#include <drm/drm_plane_helper.h>
7580 -#include <drm/drm_fb_cma_helper.h>
7585 @@ -167,16 +167,20 @@
7589 + struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state->state,
7593 - if (!state->crtc)
7594 + if (!new_plane_state->crtc)
7597 - crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
7598 + crtc_state = drm_atomic_get_crtc_state(state->state,
7599 + new_plane_state->crtc);
7603 - return drm_atomic_helper_check_plane_state(state, crtc_state,
7609 @@ -464,11 +468,12 @@
7613 - struct drm_plane_state *old_state)
7617 - struct drm_plane_state *state = plane->state;
7618 - struct drm_framebuffer *fb = state->fb;
7619 + struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state->state,
7621 + struct drm_framebuffer *fb = new_state->fb;
7622 struct meson_drm *priv = meson_overlay->priv;
7625 @@ -476,7 +481,7 @@
7629 - interlace_mode = state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE;
7630 + interlace_mode = new_state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE;
7632 spin_lock_irqsave(&priv->drm->event_lock, flags);
7634 @@ -717,7 +722,7 @@
7638 - struct drm_plane_state *old_state)
7642 struct meson_drm *priv = meson_overlay->priv;
7643 diff -Naur a/drivers/gpu/drm/meson/meson_plane.c b/drivers/gpu/drm/meson/meson_plane.c
7644 --- a/drivers/gpu/drm/meson/meson_plane.c 2022-05-27 17:20:15.601901127 +0800
7645 +++ b/drivers/gpu/drm/meson/meson_plane.c 2022-05-31 11:56:47.733259325 +0800
7646 @@ -73,12 +73,15 @@
7650 + struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state->state,
7654 - if (!state->crtc)
7655 + if (!new_plane_state->crtc)
7658 - crtc_state = drm_atomic_get_crtc_state(state->state, state->crtc);
7659 + crtc_state = drm_atomic_get_crtc_state(state->state,
7660 + new_plane_state->crtc);
7664 @@ -87,7 +90,8 @@
7665 * - Upscaling up to 5x, vertical and horizontal
7666 * - Final coordinates must match crtc size
7668 - return drm_atomic_helper_check_plane_state(state, crtc_state,
7674 @@ -126,13 +130,14 @@
7678 - struct drm_plane_state *old_state)
7682 - struct drm_plane_state *state = plane->state;
7683 - struct drm_rect dest = drm_plane_state_dest(state);
7684 + struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state->state,
7687 struct meson_drm *priv = meson_plane->priv;
7688 - struct drm_framebuffer *fb = state->fb;
7689 + struct drm_framebuffer *fb = new_state->fb;
7693 @@ -245,7 +250,7 @@
7697 - if (state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) {
7698 + if (new_state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) {
7702 @@ -255,10 +260,10 @@
7703 hsc_ini_rpt_p0_num = (hf_bank_len / 2) - 1;
7704 vsc_ini_rpt_p0_num = (vf_bank_len / 2) - 1;
7706 - src_w = fixed16_to_int(state->src_w);
7707 - src_h = fixed16_to_int(state->src_h);
7708 - dst_w = state->crtc_w;
7709 - dst_h = state->crtc_h;
7710 + src_w = fixed16_to_int(new_state->src_w);
7711 + src_h = fixed16_to_int(new_state->src_h);
7712 + dst_w = new_state->crtc_w;
7713 + dst_h = new_state->crtc_h;
7717 @@ -267,7 +272,7 @@
7721 - if (state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) {
7722 + if (new_state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) {
7726 @@ -276,7 +281,7 @@
7730 - if (state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE)
7731 + if (new_state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE)
7735 @@ -308,7 +313,7 @@
7739 - if (state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE)
7740 + if (new_state->crtc->mode.flags & DRM_MODE_FLAG_INTERLACE)
7741 priv->viu.osd_sc_v_ctrl0 |=
7744 @@ -343,11 +348,11 @@
7747 priv->viu.osd1_blk0_cfg[1] =
7748 - ((fixed16_to_int(state->src.x2) - 1) << 16) |
7749 - fixed16_to_int(state->src.x1);
7750 + ((fixed16_to_int(new_state->src.x2) - 1) << 16) |
7751 + fixed16_to_int(new_state->src.x1);
7752 priv->viu.osd1_blk0_cfg[2] =
7753 - ((fixed16_to_int(state->src.y2) - 1) << 16) |
7754 - fixed16_to_int(state->src.y1);
7755 + ((fixed16_to_int(new_state->src.y2) - 1) << 16) |
7756 + fixed16_to_int(new_state->src.y1);
7757 priv->viu.osd1_blk0_cfg[3] = ((dest.x2 - 1) << 16) | dest.x1;
7758 priv->viu.osd1_blk0_cfg[4] = ((dest.y2 - 1) << 16) | dest.y1;
7760 @@ -355,7 +360,6 @@
7761 priv->viu.osd_blend_din0_scope_h = ((dest.x2 - 1) << 16) | dest.x1;
7762 priv->viu.osd_blend_din0_scope_v = ((dest.y2 - 1) << 16) | dest.y1;
7763 priv->viu.osb_blend0_size = dst_h << 16 | dst_w;
7764 - priv->viu.osb_blend1_size = dst_h << 16 | dst_w;
7768 @@ -391,7 +395,7 @@
7772 - struct drm_plane_state *old_state)
7776 struct meson_drm *priv = meson_plane->priv;
7777 diff -Naur a/drivers/gpu/drm/meson/meson_registers.h b/drivers/gpu/drm/meson/meson_registers.h
7778 --- a/drivers/gpu/drm/meson/meson_registers.h 2022-05-27 17:20:15.601901127 +0800
7779 +++ b/drivers/gpu/drm/meson/meson_registers.h 2022-05-31 11:56:47.733259325 +0800
7780 @@ -812,6 +812,7 @@
7788 @@ -1192,7 +1193,11 @@
7800 @@ -1219,11 +1224,14 @@
7815 @@ -1300,13 +1308,28 @@
7844 @@ -1363,6 +1386,8 @@
7853 diff -Naur a/drivers/gpu/drm/meson/meson_vclk.c b/drivers/gpu/drm/meson/meson_vclk.c
7854 --- a/drivers/gpu/drm/meson/meson_vclk.c 2022-05-27 17:20:15.601901127 +0800
7855 +++ b/drivers/gpu/drm/meson/meson_vclk.c 2022-05-31 11:56:47.733259325 +0800
7856 @@ -55,6 +55,8 @@
7865 @@ -83,6 +85,7 @@
7873 @@ -131,7 +134,7 @@
7877 -void meson_vid_pll_set(struct meson_drm *priv, unsigned int div)
7882 @@ -357,6 +360,8 @@
7891 @@ -467,6 +472,18 @@
7910 @@ -487,9 +504,9 @@
7914 -void meson_hdmi_pll_set_params(struct meson_drm *priv, unsigned int m,
7915 - unsigned int frac, unsigned int od1,
7916 - unsigned int od2, unsigned int od3)
7923 @@ -873,6 +890,10 @@
7934 @@ -1024,6 +1045,47 @@
7935 regmap_update_bits(priv->hhi, HHI_VID_CLK_CNTL, VCLK_EN, VCLK_EN);
7946 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_CNTL, VCLK2_EN, 0);
7949 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_DIV, VCLK2_DIV_MASK, 2 - 1);
7952 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_CNTL,
7956 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_CNTL, VCLK2_EN, VCLK2_EN);
7959 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_DIV,
7963 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_DIV, VCLK2_DIV_EN | VCLK2_DIV_RESET,
7967 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_CNTL, VCLK2_DIV1_EN, VCLK2_DIV1_EN);
7970 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_CNTL, VCLK2_SOFT_RESET, VCLK2_SOFT_RESET);
7971 + regmap_update_bits(priv->hhi, HHI_VIID_CLK_CNTL, VCLK2_SOFT_RESET, 0);
7974 + regmap_update_bits(priv->hhi, HHI_VID_CLK_CNTL2, CTS_ENCL_EN, CTS_ENCL_EN);
7982 @@ -1050,6 +1112,9 @@
7992 diff -Naur a/drivers/gpu/drm/meson/meson_vclk.h b/drivers/gpu/drm/meson/meson_vclk.h
7993 --- a/drivers/gpu/drm/meson/meson_vclk.h 2022-05-27 17:20:15.601901127 +0800
7994 +++ b/drivers/gpu/drm/meson/meson_vclk.h 2022-05-31 11:56:47.733259325 +0800
7995 @@ -17,6 +17,7 @@
8003 diff -Naur a/drivers/gpu/drm/meson/meson_venc.c b/drivers/gpu/drm/meson/meson_venc.c
8004 --- a/drivers/gpu/drm/meson/meson_venc.c 2022-05-27 17:20:15.601901127 +0800
8005 +++ b/drivers/gpu/drm/meson/meson_venc.c 2022-05-31 11:56:47.733259325 +0800
8006 @@ -6,6 +6,7 @@
8014 @@ -45,7 +46,7 @@
8018 - * 1080i interlaced pixels, and was initialy desined to encode pixels for
8023 @@ -866,10 +867,11 @@
8027 - if (mode->hdisplay < 640 || mode->hdisplay > 1920)
8029 + if (mode->hdisplay < 640 || mode->hdisplay > 2560)
8032 - if (mode->vdisplay < 480 || mode->vdisplay > 1200)
8033 + if (mode->vdisplay < 480 || mode->vdisplay > 1600)
8037 @@ -890,8 +892,8 @@
8041 -void meson_venc_hdmi_get_dmt_vmode(const struct drm_display_mode *mode,
8042 - union meson_hdmi_venc_mode *dmt_mode)
8048 @@ -1557,6 +1559,205 @@
8078 + priv->io_base + _REG(L_GAMMA_CNTL_PORT));
8080 + ret = readl_relaxed_poll_timeout(priv->io_base + _REG(L_GAMMA_CNTL_PORT),
8087 + priv->io_base + _REG(L_GAMMA_ADDR_PORT));
8090 + ret = readl_relaxed_poll_timeout(priv->io_base + _REG(L_GAMMA_CNTL_PORT),
8096 + writel_relaxed(data[i], priv->io_base + _REG(L_GAMMA_DATA_PORT));
8099 + ret = readl_relaxed_poll_timeout(priv->io_base + _REG(L_GAMMA_CNTL_PORT),
8106 + priv->io_base + _REG(L_GAMMA_ADDR_PORT));
8116 + priv->io_base + _REG(L_GAMMA_CNTL_PORT));
8135 + max_pxcnt = mode->htotal - 1;
8136 + max_lncnt = mode->vtotal - 1;
8137 + havon_begin = mode->htotal - mode->hsync_start;
8138 + havon_end = havon_begin + mode->hdisplay - 1;
8139 + vavon_bline = mode->vtotal - mode->vsync_start;
8140 + vavon_eline = vavon_bline + mode->vdisplay - 1;
8142 + hso_end = mode->hsync_end - mode->hsync_start;
8146 + vso_eline = mode->vsync_end - mode->vsync_start;
8150 + writel_relaxed(0, priv->io_base + _REG(ENCL_VIDEO_EN));
8152 + writel_relaxed(ENCL_PX_LN_CNT_SHADOW_EN, priv->io_base + _REG(ENCL_VIDEO_MODE));
8155 + ENCL_SEL_GAMMA_RGB_IN, priv->io_base + _REG(ENCL_VIDEO_MODE_ADV));
8158 + priv->io_base + _REG(ENCL_VIDEO_FILT_CTRL));
8159 + writel_relaxed(max_pxcnt, priv->io_base + _REG(ENCL_VIDEO_MAX_PXCNT));
8160 + writel_relaxed(max_lncnt, priv->io_base + _REG(ENCL_VIDEO_MAX_LNCNT));
8161 + writel_relaxed(havon_begin, priv->io_base + _REG(ENCL_VIDEO_HAVON_BEGIN));
8162 + writel_relaxed(havon_end, priv->io_base + _REG(ENCL_VIDEO_HAVON_END));
8163 + writel_relaxed(vavon_bline, priv->io_base + _REG(ENCL_VIDEO_VAVON_BLINE));
8164 + writel_relaxed(vavon_eline, priv->io_base + _REG(ENCL_VIDEO_VAVON_ELINE));
8166 + writel_relaxed(hso_begin, priv->io_base + _REG(ENCL_VIDEO_HSO_BEGIN));
8167 + writel_relaxed(hso_end, priv->io_base + _REG(ENCL_VIDEO_HSO_END));
8168 + writel_relaxed(vso_begin, priv->io_base + _REG(ENCL_VIDEO_VSO_BEGIN));
8169 + writel_relaxed(vso_end, priv->io_base + _REG(ENCL_VIDEO_VSO_END));
8170 + writel_relaxed(vso_bline, priv->io_base + _REG(ENCL_VIDEO_VSO_BLINE));
8171 + writel_relaxed(vso_eline, priv->io_base + _REG(ENCL_VIDEO_VSO_ELINE));
8173 + priv->io_base + _REG(ENCL_VIDEO_RGBIN_CTRL));
8176 + writel_relaxed(0, priv->io_base + _REG(ENCL_TST_MDSEL));
8177 + writel_relaxed(0, priv->io_base + _REG(ENCL_TST_Y));
8178 + writel_relaxed(0, priv->io_base + _REG(ENCL_TST_CB));
8179 + writel_relaxed(0, priv->io_base + _REG(ENCL_TST_CR));
8180 + writel_relaxed(1, priv->io_base + _REG(ENCL_TST_EN));
8182 + priv->io_base + _REG(ENCL_VIDEO_MODE_ADV));
8184 + writel_relaxed(1, priv->io_base + _REG(ENCL_VIDEO_EN));
8186 + writel_relaxed(0, priv->io_base + _REG(L_RGB_BASE_ADDR));
8187 + writel_relaxed(0x400, priv->io_base + _REG(L_RGB_COEFF_ADDR)); /* Magic value */
8189 + writel_relaxed(L_DITH_CNTL_DITH10_EN, priv->io_base + _REG(L_DITH_CNTL_ADDR));
8192 + writel_relaxed(havon_begin, priv->io_base + _REG(L_OEH_HS_ADDR));
8193 + writel_relaxed(havon_end + 1, priv->io_base + _REG(L_OEH_HE_ADDR));
8194 + writel_relaxed(vavon_bline, priv->io_base + _REG(L_OEH_VS_ADDR));
8195 + writel_relaxed(vavon_eline, priv->io_base + _REG(L_OEH_VE_ADDR));
8198 + writel_relaxed(havon_begin, priv->io_base + _REG(L_OEV1_HS_ADDR));
8199 + writel_relaxed(havon_end + 1, priv->io_base + _REG(L_OEV1_HE_ADDR));
8200 + writel_relaxed(vavon_bline, priv->io_base + _REG(L_OEV1_VS_ADDR));
8201 + writel_relaxed(vavon_eline, priv->io_base + _REG(L_OEV1_VE_ADDR));
8204 + if (mode->flags & DRM_MODE_FLAG_PHSYNC) {
8205 + writel_relaxed(hso_end, priv->io_base + _REG(L_STH1_HS_ADDR));
8206 + writel_relaxed(hso_begin, priv->io_base + _REG(L_STH1_HE_ADDR));
8208 + writel_relaxed(hso_begin, priv->io_base + _REG(L_STH1_HS_ADDR));
8209 + writel_relaxed(hso_end, priv->io_base + _REG(L_STH1_HE_ADDR));
8211 + writel_relaxed(0, priv->io_base + _REG(L_STH1_VS_ADDR));
8212 + writel_relaxed(max_lncnt, priv->io_base + _REG(L_STH1_VE_ADDR));
8215 + writel_relaxed(vso_begin, priv->io_base + _REG(L_STV1_HS_ADDR));
8216 + writel_relaxed(vso_end, priv->io_base + _REG(L_STV1_HE_ADDR));
8217 + if (mode->flags & DRM_MODE_FLAG_PVSYNC) {
8218 + writel_relaxed(vso_eline, priv->io_base + _REG(L_STV1_VS_ADDR));
8219 + writel_relaxed(vso_bline, priv->io_base + _REG(L_STV1_VE_ADDR));
8221 + writel_relaxed(vso_bline, priv->io_base + _REG(L_STV1_VS_ADDR));
8222 + writel_relaxed(vso_eline, priv->io_base + _REG(L_STV1_VE_ADDR));
8226 + writel_relaxed(havon_begin, priv->io_base + _REG(L_DE_HS_ADDR));
8227 + writel_relaxed(havon_end + 1, priv->io_base + _REG(L_DE_HE_ADDR));
8228 + writel_relaxed(vavon_bline, priv->io_base + _REG(L_DE_VS_ADDR));
8229 + writel_relaxed(vavon_eline, priv->io_base + _REG(L_DE_VE_ADDR));
8232 + writel_relaxed(hso_begin, priv->io_base + _REG(L_HSYNC_HS_ADDR));
8233 + writel_relaxed(hso_end, priv->io_base + _REG(L_HSYNC_HE_ADDR));
8234 + writel_relaxed(0, priv->io_base + _REG(L_HSYNC_VS_ADDR));
8235 + writel_relaxed(max_lncnt, priv->io_base + _REG(L_HSYNC_VE_ADDR));
8238 + writel_relaxed(vso_begin, priv->io_base + _REG(L_VSYNC_HS_ADDR));
8239 + writel_relaxed(vso_end, priv->io_base + _REG(L_VSYNC_HE_ADDR));
8240 + writel_relaxed(vso_bline, priv->io_base + _REG(L_VSYNC_VS_ADDR));
8241 + writel_relaxed(vso_eline, priv->io_base + _REG(L_VSYNC_VE_ADDR));
8243 + writel_relaxed(0, priv->io_base + _REG(L_INV_CNT_ADDR));
8245 + priv->io_base + _REG(L_TCON_MISC_SEL_ADDR));
8247 + priv->venc.current_mode = MESON_VENC_MODE_MIPI_DSI;
8254 @@ -1747,8 +1948,15 @@
8258 - writel_relaxed(VENC_INTCTRL_ENCI_LNRST_INT_EN,
8259 - priv->io_base + _REG(VENC_INTCTRL));
8260 + switch (priv->venc.current_mode) {
8263 + priv->io_base + _REG(VENC_INTCTRL));
8267 + priv->io_base + _REG(VENC_INTCTRL));
8269 regmap_update_bits(priv->hhi, HHI_GCLK_MPEG2, BIT(25), BIT(25));
8272 diff -Naur a/drivers/gpu/drm/meson/meson_venc_cvbs.c b/drivers/gpu/drm/meson/meson_venc_cvbs.c
8273 --- a/drivers/gpu/drm/meson/meson_venc_cvbs.c 2022-05-27 17:20:15.601901127 +0800
8274 +++ b/drivers/gpu/drm/meson/meson_venc_cvbs.c 1970-01-01 08:00:00.000000000 +0800
8275 @@ -1,293 +0,0 @@
8276 -// SPDX-License-Identifier: GPL-2.0-or-later
8277 -/*
8278 - * Copyright (C) 2016 BayLibre, SAS
8279 - * Author: Neil Armstrong <narmstrong@baylibre.com>
8280 - * Copyright (C) 2015 Amlogic, Inc. All rights reserved.
8281 - * Copyright (C) 2014 Endless Mobile
8282 - *
8283 - * Written by:
8284 - * Jasper St. Pierre <jstpierre@mecheye.net>
8285 - */
8286 -
8287 -#include <linux/export.h>
8288 -#include <linux/of_graph.h>
8289 -
8290 -#include <drm/drm_atomic_helper.h>
8291 -#include <drm/drm_device.h>
8292 -#include <drm/drm_edid.h>
8293 -#include <drm/drm_probe_helper.h>
8294 -#include <drm/drm_print.h>
8295 -
8296 -#include "meson_registers.h"
8297 -#include "meson_vclk.h"
8298 -#include "meson_venc_cvbs.h"
8299 -
8300 -/* HHI VDAC Registers */
8301 -#define HHI_VDAC_CNTL0 0x2F4 /* 0xbd offset in data sheet */
8302 -#define HHI_VDAC_CNTL0_G12A 0x2EC /* 0xbd offset in data sheet */
8303 -#define HHI_VDAC_CNTL1 0x2F8 /* 0xbe offset in data sheet */
8304 -#define HHI_VDAC_CNTL1_G12A 0x2F0 /* 0xbe offset in data sheet */
8305 -
8306 -struct meson_venc_cvbs {
8307 - struct drm_encoder encoder;
8308 - struct drm_connector connector;
8309 - struct meson_drm *priv;
8310 -};
8311 -#define encoder_to_meson_venc_cvbs(x) \
8312 - container_of(x, struct meson_venc_cvbs, encoder)
8313 -
8314 -#define connector_to_meson_venc_cvbs(x) \
8315 - container_of(x, struct meson_venc_cvbs, connector)
8316 -
8317 -/* Supported Modes */
8318 -
8319 -struct meson_cvbs_mode meson_cvbs_modes[MESON_CVBS_MODES_COUNT] = {
8320 - { /* PAL */
8321 - .enci = &meson_cvbs_enci_pal,
8322 - .mode = {
8323 - DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500,
8324 - 720, 732, 795, 864, 0, 576, 580, 586, 625, 0,
8325 - DRM_MODE_FLAG_INTERLACE),
8326 - .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3,
8327 - },
8328 - },
8329 - { /* NTSC */
8330 - .enci = &meson_cvbs_enci_ntsc,
8331 - .mode = {
8332 - DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500,
8333 - 720, 739, 801, 858, 0, 480, 488, 494, 525, 0,
8334 - DRM_MODE_FLAG_INTERLACE),
8335 - .picture_aspect_ratio = HDMI_PICTURE_ASPECT_4_3,
8336 - },
8337 - },
8338 -};
8339 -
8340 -static const struct meson_cvbs_mode *
8341 -meson_cvbs_get_mode(const struct drm_display_mode *req_mode)
8342 -{
8343 - int i;
8344 -
8345 - for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
8346 - struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
8347 -
8348 - if (drm_mode_match(req_mode, &meson_mode->mode,
8349 - DRM_MODE_MATCH_TIMINGS |
8350 - DRM_MODE_MATCH_CLOCK |
8351 - DRM_MODE_MATCH_FLAGS |
8352 - DRM_MODE_MATCH_3D_FLAGS))
8353 - return meson_mode;
8354 - }
8355 -
8356 - return NULL;
8357 -}
8358 -
8359 -/* Connector */
8360 -
8361 -static void meson_cvbs_connector_destroy(struct drm_connector *connector)
8362 -{
8363 - drm_connector_cleanup(connector);
8364 -}
8365 -
8366 -static enum drm_connector_status
8367 -meson_cvbs_connector_detect(struct drm_connector *connector, bool force)
8368 -{
8369 - /* FIXME: Add load-detect or jack-detect if possible */
8370 - return connector_status_connected;
8371 -}
8372 -
8373 -static int meson_cvbs_connector_get_modes(struct drm_connector *connector)
8374 -{
8375 - struct drm_device *dev = connector->dev;
8376 - struct drm_display_mode *mode;
8377 - int i;
8378 -
8379 - for (i = 0; i < MESON_CVBS_MODES_COUNT; ++i) {
8380 - struct meson_cvbs_mode *meson_mode = &meson_cvbs_modes[i];
8381 -
8382 - mode = drm_mode_duplicate(dev, &meson_mode->mode);
8383 - if (!mode) {
8384 - DRM_ERROR("Failed to create a new display mode\n");
8385 - return 0;
8386 - }
8387 -
8388 - drm_mode_probed_add(connector, mode);
8389 - }
8390 -
8391 - return i;
8392 -}
8393 -
8394 -static int meson_cvbs_connector_mode_valid(struct drm_connector *connector,
8395 - struct drm_display_mode *mode)
8396 -{
8397 - /* Validate the modes added in get_modes */
8398 - return MODE_OK;
8399 -}
8400 -
8401 -static const struct drm_connector_funcs meson_cvbs_connector_funcs = {
8402 - .detect = meson_cvbs_connector_detect,
8403 - .fill_modes = drm_helper_probe_single_connector_modes,
8404 - .destroy = meson_cvbs_connector_destroy,
8405 - .reset = drm_atomic_helper_connector_reset,
8406 - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
8407 - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
8408 -};
8409 -
8410 -static const
8411 -struct drm_connector_helper_funcs meson_cvbs_connector_helper_funcs = {
8412 - .get_modes = meson_cvbs_connector_get_modes,
8413 - .mode_valid = meson_cvbs_connector_mode_valid,
8414 -};
8415 -
8416 -/* Encoder */
8417 -
8418 -static void meson_venc_cvbs_encoder_destroy(struct drm_encoder *encoder)
8419 -{
8420 - drm_encoder_cleanup(encoder);
8421 -}
8422 -
8423 -static const struct drm_encoder_funcs meson_venc_cvbs_encoder_funcs = {
8424 - .destroy = meson_venc_cvbs_encoder_destroy,
8425 -};
8426 -
8427 -static int meson_venc_cvbs_encoder_atomic_check(struct drm_encoder *encoder,
8428 - struct drm_crtc_state *crtc_state,
8429 - struct drm_connector_state *conn_state)
8430 -{
8431 - if (meson_cvbs_get_mode(&crtc_state->mode))
8432 - return 0;
8433 -
8434 - return -EINVAL;
8435 -}
8436 -
8437 -static void meson_venc_cvbs_encoder_disable(struct drm_encoder *encoder)
8438 -{
8439 - struct meson_venc_cvbs *meson_venc_cvbs =
8440 - encoder_to_meson_venc_cvbs(encoder);
8441 - struct meson_drm *priv = meson_venc_cvbs->priv;
8442 -
8443 - /* Disable CVBS VDAC */
8444 - if (meson_vpu_is_compatible(priv, VPU_COMPATIBLE_G12A)) {
8445 - regmap_write(priv->hhi, HHI_VDAC_CNTL0_G12A, 0);
8446 - regmap_write(priv->hhi, HHI_VDAC_CNTL1_G12A, 0);
8447 - } else {
8448 - regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0);
8449 - regmap_write(priv->hhi, HHI_VDAC_CNTL1, 8);
8450 - }
8451 -}
8452 -
8453 -static void meson_venc_cvbs_encoder_enable(struct drm_encoder *encoder)
8454 -{
8455 - struct meson_venc_cvbs *meson_venc_cvbs =
8456 - encoder_to_meson_venc_cvbs(encoder);
8457 - struct meson_drm *priv = meson_venc_cvbs->priv;
8458 -
8459 - /* VDAC0 source is not from ATV */
8460 - writel_bits_relaxed(VENC_VDAC_SEL_ATV_DMD, 0,
8461 - priv->io_base + _REG(VENC_VDAC_DACSEL0));
8462 -
8463 - if (meson_vpu_is_compatible(priv, VPU_COMPATIBLE_GXBB)) {
8464 - regmap_write(priv->hhi, HHI_VDAC_CNTL0, 1);
8465 - regmap_write(priv->hhi, HHI_VDAC_CNTL1, 0);
8466 - } else if (meson_vpu_is_compatible(priv, VPU_COMPATIBLE_GXM) ||
8467 - meson_vpu_is_compatible(priv, VPU_COMPATIBLE_GXL)) {
8468 - regmap_write(priv->hhi, HHI_VDAC_CNTL0, 0xf0001);
8469 - regmap_write(priv->hhi, HHI_VDAC_CNTL1, 0);
8470 - } else if (meson_vpu_is_compatible(priv, VPU_COMPATIBLE_G12A)) {
8471 - regmap_write(priv->hhi, HHI_VDAC_CNTL0_G12A, 0x906001);
8472 - regmap_write(priv->hhi, HHI_VDAC_CNTL1_G12A, 0);
8473 - }
8474 -}
8475 -
8476 -static void meson_venc_cvbs_encoder_mode_set(struct drm_encoder *encoder,
8477 - struct drm_display_mode *mode,
8478 - struct drm_display_mode *adjusted_mode)
8479 -{
8480 - const struct meson_cvbs_mode *meson_mode = meson_cvbs_get_mode(mode);
8481 - struct meson_venc_cvbs *meson_venc_cvbs =
8482 - encoder_to_meson_venc_cvbs(encoder);
8483 - struct meson_drm *priv = meson_venc_cvbs->priv;
8484 -
8485 - if (meson_mode) {
8486 - meson_venci_cvbs_mode_set(priv, meson_mode->enci);
8487 -
8488 - /* Setup 27MHz vclk2 for ENCI and VDAC */
8489 - meson_vclk_setup(priv, MESON_VCLK_TARGET_CVBS,
8490 - MESON_VCLK_CVBS, MESON_VCLK_CVBS,
8491 - MESON_VCLK_CVBS, MESON_VCLK_CVBS,
8492 - true);
8493 - }
8494 -}
8495 -
8496 -static const struct drm_encoder_helper_funcs
8497 - meson_venc_cvbs_encoder_helper_funcs = {
8498 - .atomic_check = meson_venc_cvbs_encoder_atomic_check,
8499 - .disable = meson_venc_cvbs_encoder_disable,
8500 - .enable = meson_venc_cvbs_encoder_enable,
8501 - .mode_set = meson_venc_cvbs_encoder_mode_set,
8502 -};
8503 -
8504 -static bool meson_venc_cvbs_connector_is_available(struct meson_drm *priv)
8505 -{
8506 - struct device_node *remote;
8507 -
8508 - remote = of_graph_get_remote_node(priv->dev->of_node, 0, 0);
8509 - if (!remote)
8510 - return false;
8511 -
8512 - of_node_put(remote);
8513 - return true;
8514 -}
8515 -
8516 -int meson_venc_cvbs_create(struct meson_drm *priv)
8517 -{
8518 - struct drm_device *drm = priv->drm;
8519 - struct meson_venc_cvbs *meson_venc_cvbs;
8520 - struct drm_connector *connector;
8521 - struct drm_encoder *encoder;
8522 - int ret;
8523 -
8524 - if (!meson_venc_cvbs_connector_is_available(priv)) {
8525 - dev_info(drm->dev, "CVBS Output connector not available\n");
8526 - return 0;
8527 - }
8528 -
8529 - meson_venc_cvbs = devm_kzalloc(priv->dev, sizeof(*meson_venc_cvbs),
8530 - GFP_KERNEL);
8531 - if (!meson_venc_cvbs)
8532 - return -ENOMEM;
8533 -
8534 - meson_venc_cvbs->priv = priv;
8535 - encoder = &meson_venc_cvbs->encoder;
8536 - connector = &meson_venc_cvbs->connector;
8537 -
8538 - /* Connector */
8539 -
8540 - drm_connector_helper_add(connector,
8541 - &meson_cvbs_connector_helper_funcs);
8542 -
8543 - ret = drm_connector_init(drm, connector, &meson_cvbs_connector_funcs,
8544 - DRM_MODE_CONNECTOR_Composite);
8545 - if (ret) {
8546 - dev_err(priv->dev, "Failed to init CVBS connector\n");
8547 - return ret;
8548 - }
8549 -
8550 - connector->interlace_allowed = 1;
8551 -
8552 - /* Encoder */
8553 -
8554 - drm_encoder_helper_add(encoder, &meson_venc_cvbs_encoder_helper_funcs);
8555 -
8556 - ret = drm_encoder_init(drm, encoder, &meson_venc_cvbs_encoder_funcs,
8557 - DRM_MODE_ENCODER_TVDAC, "meson_venc_cvbs");
8558 - if (ret) {
8559 - dev_err(priv->dev, "Failed to init CVBS encoder\n");
8560 - return ret;
8561 - }
8562 -
8563 - encoder->possible_crtcs = BIT(0);
8564 -
8565 - drm_connector_attach_encoder(connector, encoder);
8566 -
8567 - return 0;
8568 -}
8569 diff -Naur a/drivers/gpu/drm/meson/meson_venc_cvbs.h b/drivers/gpu/drm/meson/meson_venc_cvbs.h
8570 --- a/drivers/gpu/drm/meson/meson_venc_cvbs.h 2022-05-27 17:20:15.601901127 +0800
8571 +++ b/drivers/gpu/drm/meson/meson_venc_cvbs.h 1970-01-01 08:00:00.000000000 +0800
8572 @@ -1,29 +0,0 @@
8573 -/* SPDX-License-Identifier: GPL-2.0-or-later */
8574 -/*
8575 - * Copyright (C) 2016 BayLibre, SAS
8576 - * Author: Neil Armstrong <narmstrong@baylibre.com>
8577 - * Copyright (C) 2014 Endless Mobile
8578 - *
8579 - * Written by:
8580 - * Jasper St. Pierre <jstpierre@mecheye.net>
8581 - */
8582 -
8583 -#ifndef __MESON_VENC_CVBS_H
8584 -#define __MESON_VENC_CVBS_H
8585 -
8586 -#include "meson_drv.h"
8587 -#include "meson_venc.h"
8588 -
8589 -struct meson_cvbs_mode {
8590 - struct meson_cvbs_enci_mode *enci;
8591 - struct drm_display_mode mode;
8592 -};
8593 -
8594 -#define MESON_CVBS_MODES_COUNT 2
8595 -
8596 -/* Modes supported by the CVBS output */
8597 -extern struct meson_cvbs_mode meson_cvbs_modes[MESON_CVBS_MODES_COUNT];
8598 -
8599 -int meson_venc_cvbs_create(struct meson_drm *priv);
8600 -
8601 -#endif /* __MESON_VENC_CVBS_H */
8602 diff -Naur a/drivers/gpu/drm/meson/meson_venc.h b/drivers/gpu/drm/meson/meson_venc.h
8603 --- a/drivers/gpu/drm/meson/meson_venc.h 2022-05-27 17:20:15.601901127 +0800
8604 +++ b/drivers/gpu/drm/meson/meson_venc.h 2022-05-31 11:56:47.733259325 +0800
8605 @@ -21,6 +21,7 @@
8613 @@ -47,6 +48,9 @@
8623 @@ -63,6 +67,8 @@
8632 diff -Naur a/drivers/gpu/drm/meson/meson_viu.c b/drivers/gpu/drm/meson/meson_viu.c
8633 --- a/drivers/gpu/drm/meson/meson_viu.c 2022-05-27 17:20:15.601901127 +0800
8634 +++ b/drivers/gpu/drm/meson/meson_viu.c 2022-05-31 11:56:47.733259325 +0800
8635 @@ -78,32 +78,52 @@
8639 -static void meson_viu_set_g12a_osd1_matrix(struct meson_drm *priv,
8640 - int *m, bool csc_on)
8646 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_PRE_OFFSET0_1));
8648 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_PRE_OFFSET0_1));
8650 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_PRE_OFFSET2));
8652 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_PRE_OFFSET2));
8654 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_COEF00_01));
8656 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_COEF00_01));
8658 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_COEF02_10));
8660 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_COEF02_10));
8662 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_COEF11_12));
8664 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_COEF11_12));
8666 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_COEF20_21));
8668 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_COEF20_21));
8670 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_COEF22));
8672 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_COEF22));
8675 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_OFFSET0_1));
8677 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_OFFSET0_1));
8679 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_OFFSET2));
8681 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_OFFSET2));
8684 priv->io_base + _REG(VPP_WRAP_OSD1_MATRIX_EN_CTRL));
8686 + priv->io_base + _REG(VPP_WRAP_OSD2_MATRIX_EN_CTRL));
8690 @@ -114,21 +134,36 @@
8693 priv->io_base + _REG(VIU_OSD1_MATRIX_PRE_OFFSET0_1));
8695 + priv->io_base + _REG(VIU_OSD2_MATRIX_PRE_OFFSET0_1));
8697 priv->io_base + _REG(VIU_OSD1_MATRIX_PRE_OFFSET2));
8699 + priv->io_base + _REG(VIU_OSD2_MATRIX_PRE_OFFSET2));
8701 priv->io_base + _REG(VIU_OSD1_MATRIX_COEF00_01));
8703 + priv->io_base + _REG(VIU_OSD2_MATRIX_COEF00_01));
8705 priv->io_base + _REG(VIU_OSD1_MATRIX_COEF02_10));
8707 + priv->io_base + _REG(VIU_OSD2_MATRIX_COEF02_10));
8709 priv->io_base + _REG(VIU_OSD1_MATRIX_COEF11_12));
8711 + priv->io_base + _REG(VIU_OSD2_MATRIX_COEF11_12));
8713 priv->io_base + _REG(VIU_OSD1_MATRIX_COEF20_21));
8715 + priv->io_base + _REG(VIU_OSD2_MATRIX_COEF20_21));
8719 priv->io_base +
8722 + priv->io_base +
8725 priv->io_base +
8727 @@ -137,14 +172,21 @@
8729 writel(m[17] & 0x1fff, priv->io_base +
8731 - } else
8733 writel((m[11] & 0x1fff) << 16, priv->io_base +
8735 + writel((m[11] & 0x1fff) << 16, priv->io_base +
8740 priv->io_base + _REG(VIU_OSD1_MATRIX_OFFSET0_1));
8742 + priv->io_base + _REG(VIU_OSD2_MATRIX_OFFSET0_1));
8744 priv->io_base + _REG(VIU_OSD1_MATRIX_OFFSET2));
8746 + priv->io_base + _REG(VIU_OSD2_MATRIX_OFFSET2));
8749 priv->io_base + _REG(VIU_OSD1_MATRIX_COLMOD_COEF42));
8750 @@ -154,8 +196,12 @@
8753 priv->io_base + _REG(VIU_OSD1_MATRIX_CTRL));
8755 + priv->io_base + _REG(VIU_OSD2_MATRIX_CTRL));
8757 priv->io_base + _REG(VIU_OSD1_MATRIX_CTRL));
8759 + priv->io_base + _REG(VIU_OSD2_MATRIX_CTRL));
8763 @@ -426,7 +472,7 @@
8767 - meson_viu_set_g12a_osd1_matrix(priv, RGB709_to_YUV709l_coeff,
8770 /* fix green/pink color distortion from vendor u-boot */
8772 @@ -469,14 +515,13 @@
8773 priv->io_base + _REG(VD2_IF0_LUMA_FIFO_SIZE));
8776 - writel_relaxed(VIU_OSD_BLEND_REORDER(0, 1) |
8777 - VIU_OSD_BLEND_REORDER(1, 0) |
8778 - VIU_OSD_BLEND_REORDER(2, 0) |
8779 - VIU_OSD_BLEND_REORDER(3, 0) |
8780 - VIU_OSD_BLEND_DIN_EN(1) |
8781 - VIU_OSD_BLEND1_DIN3_BYPASS_TO_DOUT1 |
8782 - VIU_OSD_BLEND1_DOUT_BYPASS_TO_BLEND2 |
8783 - VIU_OSD_BLEND_DIN0_BYPASS_TO_DOUT0 |
8784 + /* setup bypass to have OSD1->DOUT0 + OSD2->DOUT1 */
8793 priv->io_base + _REG(VIU_OSD_BLEND_CTRL));
8794 diff -Naur a/drivers/gpu/drm/meson/meson_vpp.h b/drivers/gpu/drm/meson/meson_vpp.h
8795 --- a/drivers/gpu/drm/meson/meson_vpp.h 2022-05-27 17:20:15.601901127 +0800
8796 +++ b/drivers/gpu/drm/meson/meson_vpp.h 2022-05-31 11:56:47.733259325 +0800
8797 @@ -12,6 +12,8 @@
8806 diff -Naur a/drivers/gpu/drm/panel/Kconfig b/drivers/gpu/drm/panel/Kconfig
8807 --- a/drivers/gpu/drm/panel/Kconfig 2022-05-27 17:20:15.689902262 +0800
8808 +++ b/drivers/gpu/drm/panel/Kconfig 2022-05-31 11:56:47.733259325 +0800
8809 @@ -69,6 +69,15 @@
8819 + ICN6211 controller for 800x480 LCD panels with MIPI-DSI-RGB
8825 @@ -500,4 +509,13 @@
8837 + (800x480) Chipone ICN6211-based DSI panel
8839 diff -Naur a/drivers/gpu/drm/panel/Makefile b/drivers/gpu/drm/panel/Makefile
8840 --- a/drivers/gpu/drm/panel/Makefile 2022-05-27 17:20:15.689902262 +0800
8841 +++ b/drivers/gpu/drm/panel/Makefile 2022-05-31 11:56:47.733259325 +0800
8842 @@ -3,6 +3,7 @@
8843 obj-$(CONFIG_DRM_PANEL_ASUS_Z00T_TM5P5_NT35596) += panel-asus-z00t-tm5p5-n35596.o
8844 obj-$(CONFIG_DRM_PANEL_BOE_HIMAX8279D) += panel-boe-himax8279d.o
8845 obj-$(CONFIG_DRM_PANEL_BOE_TV101WUM_NL6) += panel-boe-tv101wum-nl6.o
8846 +obj-$(CONFIG_DRM_PANEL_CHIPONE_ICN6211) += panel-chipone-icn6211.o
8847 obj-$(CONFIG_DRM_PANEL_LVDS) += panel-lvds.o
8848 obj-$(CONFIG_DRM_PANEL_SIMPLE) += panel-simple.o
8849 obj-$(CONFIG_DRM_PANEL_ELIDA_KD35T133) += panel-elida-kd35t133.o
8850 @@ -53,3 +54,4 @@
8851 obj-$(CONFIG_DRM_PANEL_TRULY_NT35597_WQXGA) += panel-truly-nt35597.o
8852 obj-$(CONFIG_DRM_PANEL_VISIONOX_RM69299) += panel-visionox-rm69299.o
8853 obj-$(CONFIG_DRM_PANEL_XINPENG_XPP055C272) += panel-xinpeng-xpp055c272.o
8854 +obj-$(CONFIG_DRM_PANEL_WAVESHARE_TL070HDV03CT) += panel-waveshare-tl070hdv03ct.o
8855 diff -Naur a/drivers/gpu/drm/panel/panel-chipone-icn6211.c b/drivers/gpu/drm/panel/panel-chipone-ic…
8856 --- a/drivers/gpu/drm/panel/panel-chipone-icn6211.c 1970-01-01 08:00:00.000000000 +0800
8857 +++ b/drivers/gpu/drm/panel/panel-chipone-icn6211.c 2022-05-31 11:56:47.737259290 +0800
8858 @@ -0,0 +1,639 @@
8859 +// SPDX-License-Identifier: GPL-2.0
8863 + * - Waveshare 4.3" MIPI-DSI panel
8872 +#include <linux/media-bus-format.h>
8889 +#define DRV_NAME "panel-chipone-icn6211"
8928 +/* DSI D-PHY Layer Registers */
9006 +/* DBI-B Host Registers */
9041 + return i2c_smbus_read_byte_data(ts->i2c, reg);
9049 + ret = i2c_smbus_write_byte_data(ts->i2c, reg, val);
9051 + dev_err(&ts->i2c->dev, "I2C write failed: %d\n", ret);
9101 + struct mipi_dsi_device *dsi = to_mipi_dsi_device(ctx->dev);
9105 + return -1;
9108 + if (ctx->enabled) {
9109 + dev_info(ctx->dev, "panel enabled\n");
9113 + dev_info(ctx->dev, "panel enable\n");
9143 + icn6211_i2c->brightness = 255;
9150 + ctx->enabled = true;
9160 + return -1;
9163 + dev_info(ctx->dev, "panel disable\n");
9168 + ctx->enabled = false;
9180 + if (!ctx->prepared)
9183 + if (ctx->reset_gpio != NULL)
9184 + gpiod_set_value_cansleep(ctx->reset_gpio, 0);
9186 + ctx->prepared = false;
9195 + struct mipi_dsi_device *dsi = to_mipi_dsi_device(ctx->dev);
9198 + return -1;
9201 + if (ctx->prepared)
9206 + dev_err(panel->dev, "failed to turn on peripheral: %d\n", ret);
9210 + ctx->prepared = true;
9223 + connector->status = connector_status_disconnected;
9227 + mode = drm_mode_duplicate(connector->dev, ctx->desc->mode);
9229 + dev_err(ctx->dev, "Failed to add mode %ux%u@%u\n",
9230 + ctx->desc->mode->hdisplay, ctx->desc->mode->vdisplay,
9231 + drm_mode_vrefresh(ctx->desc->mode));
9232 + return -ENOMEM;
9237 + mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
9238 + connector->display_info.bpc = 8;
9239 + connector->display_info.width_mm = mode->width_mm;
9240 + connector->display_info.height_mm = mode->height_mm;
9243 + drm_display_info_set_bus_formats(&connector->display_info,
9259 + struct device *dev = &dsi->dev;
9265 + return -ENOMEM;
9269 + ctx->dev = dev;
9270 + ctx->desc = of_device_get_match_data(dev);
9272 + dsi->mode_flags = ctx->desc->mode_flags;
9273 + dsi->format = ctx->desc->format;
9274 + dsi->lanes = ctx->desc->lanes;
9276 + drm_panel_init(&ctx->panel, dev, &icn6211_drm_funcs, DRM_MODE_CONNECTOR_DSI);
9278 + drm_panel_add(&ctx->panel);
9283 + drm_panel_remove(&ctx->panel);
9288 + ctx->desc->mode->hdisplay, ctx->desc->mode->vdisplay,
9289 + drm_mode_vrefresh(ctx->desc->mode),
9290 + mipi_dsi_pixel_format_to_bpp(dsi->format), dsi->lanes);
9300 + ret = drm_panel_unprepare(&ctx->panel);
9302 + dev_err(&dsi->dev, "Failed to unprepare panel: %d\n", ret);
9304 + ret = drm_panel_disable(&ctx->panel);
9306 + dev_err(&dsi->dev, "Failed to disable panel: %d\n", ret);
9318 + dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret);
9320 + drm_panel_remove(&ctx->panel);
9349 + brightness = icn6211_i2c->brightness;
9376 + if (0 != icn6211_i2c->brightness) {
9381 + if (0 == icn6211_i2c->brightness) {
9390 + icn6211_i2c->brightness = brightness;
9412 + struct device *dev = &i2c->dev;
9420 + return -ENOMEM;
9425 + icn6211_i2c->i2c = i2c;
9431 + return -ENODEV;
9442 + return -ENODEV;
9469 + { .compatible = "chipone,icn6211-i2c" },
9476 + .name = "panel-icn6211-i2c",
9498 diff -Naur a/drivers/gpu/drm/panel/panel-waveshare-tl070hdv03ct.c b/drivers/gpu/drm/panel/panel-wav…
9499 --- a/drivers/gpu/drm/panel/panel-waveshare-tl070hdv03ct.c 1970-01-01 08:00:00.000000000 +0800
9500 +++ b/drivers/gpu/drm/panel/panel-waveshare-tl070hdv03ct.c 2022-06-18 17:44:02.425470938 +0800
9501 @@ -0,0 +1,402 @@
9502 +// SPDX-License-Identifier: GPL-2.0-only
9580 + struct mipi_dsi_device *dsi = icn->dsi;
9581 + const struct drm_display_mode *mode = icn->mode;
9592 + ICN6211_DSI(dsi, ICN_SET_HACTIVE_LI, mode->hdisplay & 0xff);
9594 + ICN6211_DSI(dsi, ICN_SET_VACTIVE_LI, mode->vdisplay & 0xff);
9601 + ((mode->hdisplay >> 8) & 0xf) |
9602 + (((mode->vdisplay >> 8) & 0xf) << 4));
9604 + ICN6211_DSI(dsi, ICN_SET_HFP_LI, mode->hsync_start - mode->hdisplay);
9606 + ICN6211_DSI(dsi, ICN_SET_HSYNC_LI, mode->hsync_end - mode->hsync_start);
9608 + ICN6211_DSI(dsi, ICN_SET_HBP_LI, mode->htotal - mode->hsync_end);
9612 + ICN6211_DSI(dsi, ICN_SET_VFP, mode->vsync_start - mode->vdisplay);
9614 + ICN6211_DSI(dsi, ICN_SET_VSYNC, mode->vsync_end - mode->vsync_start);
9616 + ICN6211_DSI(dsi, ICN_SET_VBP, mode->vtotal - mode->vsync_end);
9624 + if (dsi->lanes < 4 && dsi->lanes > 0) {
9625 + ICN6211_DSI(dsi, ICN_SET_LANES, 0x28 + dsi->lanes - 1);
9658 + return mipi_dsi_turn_on_peripheral(ws->dsi);
9666 + if (!ws->enabled)
9669 + mipi_ret = mipi_dsi_shutdown_peripheral(ws->dsi);
9671 + ws->enabled = false;
9680 + if (!ws->prepared)
9683 + regulator_disable(ws->supply);
9684 + ws->earliest_wake = ktime_add_ms(ktime_get_real(), MIN_POWEROFF_MS);
9685 + ws->prepared = false;
9696 + if (ws->prepared)
9699 + if (!IS_ERR(ws->supply)) {
9701 + * If the user re-enabled the panel before the required off-time then
9702 + * we need to wait the remaining period before re-enabling regulator
9704 + enablewait = ktime_ms_delta(ws->earliest_wake, ktime_get_real());
9713 + ret = regulator_enable(ws->supply);
9718 + * A minimum delay of 250ms is required after power-up until commands
9726 + dev_err(panel->dev, "failed to set panel on: %d\n", ret);
9732 + ws->prepared = true;
9739 + regulator_disable(ws->supply);
9748 + if (ws->enabled)
9751 + ws->enabled = true;
9775 + mode = drm_mode_duplicate(connector->dev, &default_mode);
9777 + dev_err(panel->dev, "failed to add mode %ux%u@%u\n",
9780 + return -ENOMEM;
9787 + connector->display_info.width_mm = mode->width_mm;
9788 + connector->display_info.height_mm = mode->height_mm;
9809 + struct device *dev = &ws->dsi->dev;
9812 + ws->mode = &default_mode;
9814 + ws->supply = devm_regulator_get(dev, "power");
9815 + if (IS_ERR(ws->supply)) {
9820 + drm_panel_init(&ws->base, &ws->dsi->dev,
9823 + ret = drm_panel_of_backlight(&ws->base);
9827 + drm_panel_add(&ws->base);
9834 + if (ws->base.dev)
9835 + drm_panel_remove(&ws->base);
9843 + dsi->lanes = LANES_NUM;
9844 + dsi->format = MIPI_DSI_FMT_RGB888;
9845 + dsi->mode_flags = MIPI_DSI_MODE_VIDEO_BURST | MIPI_DSI_MODE_LPM
9848 + ws = devm_kzalloc(&dsi->dev, sizeof(*ws), GFP_KERNEL);
9850 + return -ENOMEM;
9854 + ws->dsi = dsi;
9870 + ret = drm_panel_disable(&ws->base);
9872 + dev_err(&dsi->dev, "failed to disable panel: %d\n", ret);
9876 + dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", ret);
9887 + drm_panel_disable(&ws->base);
9892 + .name = "panel-waveshare-tl070hdv03ct",
9902 +MODULE_DESCRIPTION("Waveshare TL070HDV03CT (800x480) Chipone ICN6211-based DSI panel driver");
9904 diff -Naur a/drivers/gpu/drm/panfrost/panfrost_devfreq.c b/drivers/gpu/drm/panfrost/panfrost_devfre…
9905 --- a/drivers/gpu/drm/panfrost/panfrost_devfreq.c 2022-05-27 17:20:15.693902314 +0800
9906 +++ b/drivers/gpu/drm/panfrost/panfrost_devfreq.c 2022-05-31 11:56:47.737259290 +0800
9907 @@ -81,6 +81,7 @@
9915 @@ -134,8 +135,16 @@
9923 + pfdevfreq->gov_data.upthreshold = 45;
9924 + pfdevfreq->gov_data.downdifferential = 5;
9927 - DEVFREQ_GOV_SIMPLE_ONDEMAND, NULL);
9929 + &pfdevfreq->gov_data);
9933 diff -Naur a/drivers/gpu/drm/panfrost/panfrost_devfreq.h b/drivers/gpu/drm/panfrost/panfrost_devfre…
9934 --- a/drivers/gpu/drm/panfrost/panfrost_devfreq.h 2022-05-27 17:20:15.693902314 +0800
9935 +++ b/drivers/gpu/drm/panfrost/panfrost_devfreq.h 2022-05-31 11:56:47.737259290 +0800
9936 @@ -4,6 +4,7 @@
9944 @@ -17,6 +18,7 @@
9952 diff -Naur a/drivers/gpu/drm/panfrost/panfrost_job.c b/drivers/gpu/drm/panfrost/panfrost_job.c
9953 --- a/drivers/gpu/drm/panfrost/panfrost_job.c 2022-05-27 17:20:15.693902314 +0800
9954 +++ b/drivers/gpu/drm/panfrost/panfrost_job.c 2022-05-31 11:56:47.737259290 +0800
9955 @@ -157,7 +157,7 @@
9957 panfrost_devfreq_record_busy(&pfdev->pfdevfreq);
9959 - ret = pm_runtime_get_sync(pfdev->dev);
9960 + ret = pm_runtime_resume_and_get(pfdev->dev);
9964 diff -Naur a/drivers/gpu/drm/panfrost/panfrost_mmu.c b/drivers/gpu/drm/panfrost/panfrost_mmu.c
9965 --- a/drivers/gpu/drm/panfrost/panfrost_mmu.c 2022-05-27 17:20:15.693902314 +0800
9966 +++ b/drivers/gpu/drm/panfrost/panfrost_mmu.c 2022-05-31 11:56:47.737259290 +0800
9967 @@ -632,22 +632,20 @@
9971 - int i, ret;
9974 - for (i = 0; status; i++) {
9975 - u32 mask = BIT(i) | BIT(i + 16);
9977 + u32 as = ffs(status | (status >> 16)) - 1;
9985 - if (!(status & mask))
9986 - continue;
9987 -
9988 - fault_status = mmu_read(pfdev, AS_FAULTSTATUS(i));
9989 - addr = mmu_read(pfdev, AS_FAULTADDRESS_LO(i));
9990 - addr |= (u64)mmu_read(pfdev, AS_FAULTADDRESS_HI(i)) << 32;
9997 @@ -658,8 +656,8 @@
10000 ret = -1;
10001 - if ((status & mask) == BIT(i) && (exception_type & 0xF8) == 0xC0)
10002 - ret = panfrost_mmu_map_fault_addr(pfdev, i, addr);
10008 @@ -671,7 +669,7 @@
10012 - i, addr,
10017 @@ -680,6 +678,10 @@
10028 diff -Naur a/drivers/iio/dac/ad5770r.c b/drivers/iio/dac/ad5770r.c
10029 --- a/drivers/iio/dac/ad5770r.c 2022-06-30 21:35:01.796331169 +0800
10030 +++ b/drivers/iio/dac/ad5770r.c 2022-05-27 17:20:15.869904585 +0800
10031 @@ -522,7 +522,7 @@
10032 return -EINVAL;
10034 device_for_each_child_node(&st->spi->dev, child) {
10035 - ret = fwnode_property_read_u32(child, "reg", &num);
10040 diff -Naur a/drivers/irqchip/irq-meson-gpio.c b/drivers/irqchip/irq-meson-gpio.c
10041 --- a/drivers/irqchip/irq-meson-gpio.c 2022-05-27 17:20:16.021906545 +0800
10042 +++ b/drivers/irqchip/irq-meson-gpio.c 2022-05-31 11:56:47.737259290 +0800
10043 @@ -15,6 +15,7 @@
10051 @@ -136,6 +137,7 @@
10059 @@ -436,8 +438,8 @@
10063 -static int __init meson_gpio_irq_parse_dt(struct device_node *node,
10064 - struct meson_gpio_irq_controller *ctl)
10070 @@ -463,63 +465,84 @@
10074 -static int __init meson_gpio_irq_of_init(struct device_node *node,
10075 - struct device_node *parent)
10078 - struct irq_domain *domain, *parent_domain;
10079 + struct device_node *node = pdev->dev.of_node, *parent;
10087 - pr_err("missing parent interrupt node\n");
10088 + dev_err(&pdev->dev, "missing parent interrupt node\n");
10089 return -ENODEV;
10094 - pr_err("unable to obtain parent domain\n");
10095 + dev_err(&pdev->dev, "unable to obtain parent domain\n");
10096 return -ENXIO;
10099 - ctl = kzalloc(sizeof(*ctl), GFP_KERNEL);
10100 + ctl = devm_kzalloc(&pdev->dev, sizeof(*ctl), GFP_KERNEL);
10102 return -ENOMEM;
10104 spin_lock_init(&ctl->lock);
10106 - ctl->base = of_iomap(node, 0);
10107 - if (!ctl->base) {
10108 - ret = -ENOMEM;
10109 - goto free_ctl;
10110 - }
10112 + ctl->base = devm_ioremap_resource(&pdev->dev, res);
10113 + if (IS_ERR(ctl->base))
10114 + return PTR_ERR(ctl->base);
10118 - goto free_channel_irqs;
10121 - domain = irq_domain_create_hierarchy(parent_domain, 0,
10122 - ctl->params->nr_hwirq,
10123 - of_node_to_fwnode(node),
10124 - &meson_gpio_irq_domain_ops,
10125 - ctl);
10126 - if (!domain) {
10127 - pr_err("failed to add domain\n");
10128 - ret = -ENODEV;
10129 - goto free_channel_irqs;
10130 + ctl->domain = irq_domain_create_hierarchy(parent_domain, 0,
10131 + ctl->params->nr_hwirq,
10135 + if (!ctl->domain) {
10136 + dev_err(&pdev->dev, "failed to add domain\n");
10137 + return -ENODEV;
10140 - pr_info("%d to %d gpio interrupt mux initialized\n",
10141 - ctl->params->nr_hwirq, NUM_CHANNEL);
10144 + dev_info(&pdev->dev, "%d to %d gpio interrupt mux initialized\n",
10145 + ctl->params->nr_hwirq, NUM_CHANNEL);
10150 -free_channel_irqs:
10151 - iounmap(ctl->base);
10152 -free_ctl:
10153 - kfree(ctl);
10158 - return ret;
10159 + irq_domain_remove(ctl->domain);
10164 -IRQCHIP_DECLARE(meson_gpio_intc, "amlogic,meson-gpio-intc",
10165 - meson_gpio_irq_of_init);
10167 + { .compatible = "amlogic,meson-gpio-intc", },
10176 + .name = "meson-gpio-intc",
10184 +MODULE_ALIAS("platform:meson-gpio-intc");
10185 diff -Naur a/drivers/media/usb/dvb-usb/dibusb-common.c b/drivers/media/usb/dvb-usb/dibusb-common.c
10186 --- a/drivers/media/usb/dvb-usb/dibusb-common.c 2022-06-30 21:35:01.804331335 +0800
10187 +++ b/drivers/media/usb/dvb-usb/dibusb-common.c 2022-05-27 17:20:16.249909485 +0800
10188 @@ -223,7 +223,7 @@
10192 - buf = kzalloc(2, GFP_KERNEL);
10195 return -ENOMEM;
10197 diff -Naur a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c
10198 --- a/drivers/mmc/core/block.c 2022-05-27 17:20:16.361910930 +0800
10199 +++ b/drivers/mmc/core/block.c 2022-05-31 11:56:47.737259290 +0800
10200 @@ -44,7 +44,9 @@
10204 -
10211 @@ -2897,6 +2899,9 @@
10221 @@ -2931,9 +2936,17 @@
10226 + aml_emmc_partition_ops(card, md->disk);
10229 list_for_each_entry(part_md, &md->part, part) {
10233 + if (part_md->area_type == MMC_BLK_DATA_AREA_BOOT)
10234 + add_fake_boot_partition(part_md->disk, "bootloader%d", idx++);
10239 diff -Naur a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
10240 --- a/drivers/mmc/core/core.c 2022-05-27 17:20:16.361910930 +0800
10241 +++ b/drivers/mmc/core/core.c 2022-05-31 11:56:47.737259290 +0800
10242 @@ -215,6 +215,7 @@
10250 @@ -224,7 +225,7 @@
10254 -
10259 @@ -1909,6 +1910,7 @@
10267 diff -Naur a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
10268 --- a/drivers/mmc/core/sd.c 2022-05-27 17:20:16.361910930 +0800
10269 +++ b/drivers/mmc/core/sd.c 2022-05-31 11:56:47.737259290 +0800
10270 @@ -1254,6 +1254,26 @@
10280 + if (mmc_card_suspended(host->card))
10284 + mmc_card_set_suspended(host->card);
10286 + pm_runtime_disable(&host->card->dev);
10287 + pm_runtime_set_suspended(&host->card->dev);
10297 @@ -1331,7 +1351,7 @@
10301 - .shutdown = mmc_sd_suspend,
10306 diff -Naur a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
10307 --- a/drivers/mmc/host/Kconfig 2022-06-29 08:47:07.175383518 +0800
10308 +++ b/drivers/mmc/host/Kconfig 2022-05-27 17:20:16.365910981 +0800
10309 @@ -503,7 +503,7 @@
10313 - depends on ISA_DMA_API && !M68K
10318 diff -Naur a/drivers/mmc/host/meson-gx-mmc.c b/drivers/mmc/host/meson-gx-mmc.c
10319 --- a/drivers/mmc/host/meson-gx-mmc.c 2022-05-27 17:20:16.369911033 +0800
10320 +++ b/drivers/mmc/host/meson-gx-mmc.c 2022-06-30 15:31:31.230991607 +0800
10321 @@ -27,6 +27,7 @@
10327 #define DRIVER_NAME "meson-gx-mmc"
10329 @@ -38,6 +39,7 @@
10337 @@ -136,6 +138,7 @@
10345 @@ -415,7 +418,7 @@
10349 - clk_reg |= FIELD_PREP(CLK_CORE_PHASE_MASK, CLK_PHASE_180);
10350 + clk_reg |= FIELD_PREP(CLK_CORE_PHASE_MASK, host->data->clk_core_phase);
10353 writel(clk_reg, host->regs + SD_EMMC_CLOCK);
10354 @@ -1120,6 +1123,43 @@
10364 + mmc->rescan_entered = 0;
10366 + /*mmc->host_rescan_disable = false;*/
10370 + ret = flush_work(&(mmc->detect.work));
10377 + mmc_get_card(sdio_host->card, NULL);
10379 + if (sdio_host->card) {
10381 + sdio_host->bus_ops->hw_reset(sdio_host);
10389 + mmc_put_card(sdio_host->card, NULL);
10398 @@ -1276,6 +1316,11 @@
10403 + if (mmc->pm_caps & MMC_PM_KEEP_POWER) {
10407 mmc->ops = &meson_mmc_ops;
10410 @@ -1325,6 +1370,7 @@
10418 @@ -1332,6 +1378,7 @@
10426 diff -Naur a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/s…
10427 --- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c 2022-05-27 17:20:16.737915780 +0800
10428 +++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c 2022-05-31 11:56:47.737259290 +0800
10429 @@ -21,6 +21,39 @@
10439 + return c - '0';
10441 + return (c - 'A') + 10;
10443 + return (c - 'a') + 10;
10458 + pr_info("uboot setup mac-addr: %02x:%02x:%02x:%02x:%02x:%02x\n",
10467 * dwmac1000_validate_mcast_bins - validates the number of Multicast filter bins
10469 @@ -406,7 +439,15 @@
10471 return ERR_PTR(-ENOMEM);
10483 if (PTR_ERR(*mac) == -EPROBE_DEFER)
10485 diff -Naur a/drivers/phy/amlogic/Kconfig b/drivers/phy/amlogic/Kconfig
10486 --- a/drivers/phy/amlogic/Kconfig 2022-05-27 17:20:17.085920267 +0800
10487 +++ b/drivers/phy/amlogic/Kconfig 2022-05-31 11:56:48.077256291 +0800
10488 @@ -49,6 +49,18 @@
10507 @@ -66,7 +78,20 @@
10528 diff -Naur a/drivers/phy/amlogic/Makefile b/drivers/phy/amlogic/Makefile
10529 --- a/drivers/phy/amlogic/Makefile 2022-05-27 17:20:17.085920267 +0800
10530 +++ b/drivers/phy/amlogic/Makefile 2022-05-31 11:56:48.077256291 +0800
10531 @@ -3,5 +3,7 @@
10532 obj-$(CONFIG_PHY_MESON_GXL_USB2) += phy-meson-gxl-usb2.o
10533 obj-$(CONFIG_PHY_MESON_G12A_USB2) += phy-meson-g12a-usb2.o
10534 obj-$(CONFIG_PHY_MESON_G12A_USB3_PCIE) += phy-meson-g12a-usb3-pcie.o
10535 +obj-$(CONFIG_PHY_MESON_G12A_MIPI_DPHY_ANALOG) += phy-meson-g12a-mipi-dphy-analog.o
10536 obj-$(CONFIG_PHY_MESON_AXG_PCIE) += phy-meson-axg-pcie.o
10537 obj-$(CONFIG_PHY_MESON_AXG_MIPI_PCIE_ANALOG) += phy-meson-axg-mipi-pcie-analog.o
10538 +obj-$(CONFIG_PHY_MESON_AXG_MIPI_DPHY) += phy-meson-axg-mipi-dphy.o
10539 diff -Naur a/drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c b/drivers/phy/amlogic/phy-meson-axg-mipi…
10540 --- a/drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c 1970-01-01 08:00:00.000000000 +0800
10541 +++ b/drivers/phy/amlogic/phy-meson-axg-mipi-dphy.c 2022-05-31 11:56:48.077256291 +0800
10542 @@ -0,0 +1,415 @@
10543 +// SPDX-License-Identifier: GPL-2.0
10729 + ret = phy_init(priv->analog);
10733 + ret = reset_control_reset(priv->reset);
10746 + ret = phy_mipi_dphy_config_validate(&opts->mipi_dphy);
10750 + ret = phy_configure(priv->analog, opts);
10754 + memcpy(&priv->config, opts, sizeof(priv->config));
10765 + ret = phy_power_on(priv->analog);
10770 + regmap_write(priv->regmap, MIPI_DSI_PHY_CTRL, 0x1);
10771 + regmap_write(priv->regmap, MIPI_DSI_PHY_CTRL,
10777 + regmap_update_bits(priv->regmap, MIPI_DSI_PHY_CTRL, BIT(9), BIT(9));
10780 + regmap_update_bits(priv->regmap, MIPI_DSI_PHY_CTRL, BIT(12), BIT(12));
10781 + regmap_update_bits(priv->regmap, MIPI_DSI_PHY_CTRL, BIT(31), BIT(31));
10782 + regmap_update_bits(priv->regmap, MIPI_DSI_PHY_CTRL, BIT(31), 0);
10785 + temp = (1000000 * 100) / (priv->config.hs_clk_rate / 1000);
10788 + regmap_write(priv->regmap, MIPI_DSI_CLK_TIM,
10789 + DIV_ROUND_UP(priv->config.clk_trail, temp) |
10790 + (DIV_ROUND_UP(priv->config.clk_post +
10791 + priv->config.hs_trail, temp) << 8) |
10792 + (DIV_ROUND_UP(priv->config.clk_zero, temp) << 16) |
10793 + (DIV_ROUND_UP(priv->config.clk_prepare, temp) << 24));
10794 + regmap_write(priv->regmap, MIPI_DSI_CLK_TIM1,
10795 + DIV_ROUND_UP(priv->config.clk_pre, temp));
10797 + regmap_write(priv->regmap, MIPI_DSI_HS_TIM,
10798 + DIV_ROUND_UP(priv->config.hs_exit, temp) |
10799 + (DIV_ROUND_UP(priv->config.hs_trail, temp) << 8) |
10800 + (DIV_ROUND_UP(priv->config.hs_zero, temp) << 16) |
10801 + (DIV_ROUND_UP(priv->config.hs_prepare, temp) << 24));
10803 + regmap_write(priv->regmap, MIPI_DSI_LP_TIM,
10804 + DIV_ROUND_UP(priv->config.lpx, temp) |
10805 + (DIV_ROUND_UP(priv->config.ta_sure, temp) << 8) |
10806 + (DIV_ROUND_UP(priv->config.ta_go, temp) << 16) |
10807 + (DIV_ROUND_UP(priv->config.ta_get, temp) << 24));
10809 + regmap_write(priv->regmap, MIPI_DSI_ANA_UP_TIM, 0x0100);
10810 + regmap_write(priv->regmap, MIPI_DSI_INIT_TIM,
10811 + DIV_ROUND_UP(priv->config.init * NSEC_PER_MSEC, temp));
10812 + regmap_write(priv->regmap, MIPI_DSI_WAKEUP_TIM,
10813 + DIV_ROUND_UP(priv->config.wakeup * NSEC_PER_MSEC, temp));
10814 + regmap_write(priv->regmap, MIPI_DSI_LPOK_TIM, 0x7C);
10815 + regmap_write(priv->regmap, MIPI_DSI_ULPS_CHECK, 0x927C);
10816 + regmap_write(priv->regmap, MIPI_DSI_LP_WCHDOG, 0x1000);
10817 + regmap_write(priv->regmap, MIPI_DSI_TURN_WCHDOG, 0x1000);
10820 + switch (priv->config.lanes) {
10822 + regmap_write(priv->regmap, MIPI_DSI_CHAN_CTRL, 0xe);
10825 + regmap_write(priv->regmap, MIPI_DSI_CHAN_CTRL, 0xc);
10828 + regmap_write(priv->regmap, MIPI_DSI_CHAN_CTRL, 0x8);
10832 + regmap_write(priv->regmap, MIPI_DSI_CHAN_CTRL, 0);
10837 + regmap_update_bits(priv->regmap, MIPI_DSI_PHY_CTRL, BIT(1), BIT(1));
10846 + regmap_write(priv->regmap, MIPI_DSI_CHAN_CTRL, 0xf);
10847 + regmap_write(priv->regmap, MIPI_DSI_PHY_CTRL, BIT(31));
10849 + phy_power_off(priv->analog);
10859 + ret = phy_exit(priv->analog);
10863 + return reset_control_reset(priv->reset);
10877 + struct device *dev = &pdev->dev;
10887 + return -ENOMEM;
10889 + priv->dev = dev;
10897 + priv->regmap = devm_regmap_init_mmio(dev, base,
10899 + if (IS_ERR(priv->regmap))
10900 + return PTR_ERR(priv->regmap);
10902 + priv->clk = devm_clk_get(dev, "pclk");
10903 + if (IS_ERR(priv->clk))
10904 + return PTR_ERR(priv->clk);
10906 + priv->reset = devm_reset_control_get(dev, "phy");
10907 + if (IS_ERR(priv->reset))
10908 + return PTR_ERR(priv->reset);
10910 + priv->analog = devm_phy_get(dev, "analog");
10911 + if (IS_ERR(priv->analog))
10912 + return PTR_ERR(priv->analog);
10914 + ret = clk_prepare_enable(priv->clk);
10918 + ret = reset_control_deassert(priv->reset);
10925 + if (ret != -EPROBE_DEFER)
10941 + { .compatible = "amlogic,axg-mipi-dphy", },
10949 + .name = "phy-meson-axg-mipi-dphy",
10958 diff -Naur a/drivers/phy/amlogic/phy-meson-g12a-mipi-dphy-analog.c b/drivers/phy/amlogic/phy-meson-…
10959 --- a/drivers/phy/amlogic/phy-meson-g12a-mipi-dphy-analog.c 1970-01-01 08:00:00.000000000 +0800
10960 +++ b/drivers/phy/amlogic/phy-meson-g12a-mipi-dphy-analog.c 2022-05-31 11:56:48.077256291 +0800
10961 @@ -0,0 +1,181 @@
10962 +// SPDX-License-Identifier: GPL-2.0
10978 +#include <dt-bindings/phy/phy.h>
11011 + ret = phy_mipi_dphy_config_validate(&opts->mipi_dphy);
11015 + memcpy(&priv->config, opts, sizeof(priv->config));
11025 + regmap_write(priv->regmap, HHI_MIPI_CNTL0,
11029 + regmap_write(priv->regmap, HHI_MIPI_CNTL1,
11033 + regmap_write(priv->regmap, HHI_MIPI_CNTL2,
11040 + switch (/*priv->config.lanes*/lanes) {
11057 + regmap_update_bits(priv->regmap, HHI_MIPI_CNTL2,
11068 + regmap_write(priv->regmap, HHI_MIPI_CNTL0, 0);
11069 + regmap_write(priv->regmap, HHI_MIPI_CNTL1, 0);
11070 + regmap_write(priv->regmap, HHI_MIPI_CNTL2, 0);
11085 + struct device *dev = &pdev->dev;
11087 + struct device_node *np = dev->of_node;
11093 + return -ENOMEM;
11096 + map = syscon_node_to_regmap(of_get_parent(dev->of_node));
11103 + priv->regmap = map;
11105 + priv->phy = devm_phy_create(dev, np, &phy_g12a_mipi_dphy_analog_ops);
11106 + if (IS_ERR(priv->phy)) {
11107 + ret = PTR_ERR(priv->phy);
11108 + if (ret != -EPROBE_DEFER)
11113 + phy_set_drvdata(priv->phy, priv);
11125 + .compatible = "amlogic,g12a-mipi-dphy-analog",
11134 + .name = "phy-meson-g12a-mipi-dphy-analog",
11141 +MODULE_DESCRIPTION("Meson G12A MIPI Analog D-PHY driver");
11143 diff -Naur a/drivers/pinctrl/meson/pinctrl-meson.c b/drivers/pinctrl/meson/pinctrl-meson.c
11144 --- a/drivers/pinctrl/meson/pinctrl-meson.c 2022-05-27 17:20:17.113920629 +0800
11145 +++ b/drivers/pinctrl/meson/pinctrl-meson.c 2022-06-29 09:32:26.735042911 +0800
11146 @@ -56,6 +56,24 @@
11147 #include "../pinctrl-utils.h"
11148 #include "pinctrl-meson.h"
11156 + return -EINVAL;
11158 + mem = devm_kzalloc(&pdev->dev, size * n, GFP_KERNEL);
11160 + return -ENOMEM;
11171 @@ -152,6 +170,7 @@
11173 return pc->data->num_funcs;
11179 @@ -160,6 +179,7 @@
11181 return pc->data->funcs[selector].name;
11187 @@ -172,6 +192,7 @@
11195 @@ -248,11 +269,11 @@
11199 - ret = meson_pinconf_set_output(pc, pin, true);
11204 - return meson_pinconf_set_drive(pc, pin, high);
11209 @@ -355,6 +376,7 @@
11217 @@ -383,6 +405,9 @@
11225 ret = -ENOTSUPP;
11227 @@ -598,9 +623,42 @@
11239 + return -EINVAL;
11241 + if (bank->irq_first < 0) {
11242 + dev_warn(pc->dev, "no support irq for pin[%d]\n", gpio);
11243 + return -EINVAL;
11246 + if (!pc->of_irq) {
11247 + dev_err(pc->dev, "invalid device node of gpio INTC\n");
11248 + return -EINVAL;
11251 + hwirq = gpio - bank->first + bank->irq_first;
11253 + fwspec.fwnode = of_node_to_fwnode(pc->of_irq);
11268 pc->chip.label = pc->data->name;
11269 pc->chip.parent = pc->dev;
11270 @@ -612,6 +670,13 @@
11271 pc->chip.direction_output = meson_gpio_direction_output;
11272 pc->chip.get = meson_gpio_get;
11273 pc->chip.set = meson_gpio_set;
11274 + pc->chip.to_irq = meson_gpio_to_irq;
11275 + pc->chip.set_config = gpiochip_generic_config;
11276 + names = kcalloc(pc->desc.npins, sizeof(char *), GFP_KERNEL);
11277 + pins = pc->desc.pins;
11278 + for (i = 0; i < pc->desc.npins; i++)
11280 + pc->chip.names = (const char * const *)names;
11281 pc->chip.base = -1;
11282 pc->chip.ngpio = pc->data->num_pins;
11283 pc->chip.can_sleep = false;
11284 @@ -619,6 +684,16 @@
11285 pc->chip.of_gpio_n_cells = 2;
11287 ret = gpiochip_add_data(&pc->chip, pc);
11289 + /* pin->chip.names will be assigned to each gpio discriptor' name
11291 + * use sysfs to export gpio, pc->chip.name need to be cleared also see
11292 + * gpiod_export->device_create_with_groups.
11296 + pc->chip.names = NULL;
11299 dev_err(pc->dev, "can't add gpio chip %s\n",
11300 pc->data->name);
11301 @@ -681,6 +756,13 @@
11304 pc->of_node = gpio_np;
11305 + pc->of_irq = of_find_compatible_node(NULL,
11307 + "amlogic,meson-gpio-intc-ext");
11308 + if (!pc->of_irq)
11309 + pc->of_irq = of_find_compatible_node(NULL,
11311 + "amlogic,meson-gpio-intc");
11313 pc->reg_mux = meson_map_resource(pc, gpio_np, "mux");
11314 if (IS_ERR_OR_NULL(pc->reg_mux)) {
11315 @@ -750,6 +832,16 @@
11319 + ret = meson_memory_duplicate(pdev, (void **)&pc->data->groups, pc->data->num_groups,
11324 + ret = meson_memory_duplicate(pdev, (void **)&pc->data->funcs, pc->data->num_funcs,
11329 pc->desc.name = "pinctrl-meson";
11330 pc->desc.owner = THIS_MODULE;
11331 pc->desc.pctlops = &meson_pctrl_ops;
11332 @@ -766,3 +858,4 @@
11337 diff -Naur a/drivers/pinctrl/meson/pinctrl-meson.h b/drivers/pinctrl/meson/pinctrl-meson.h
11338 --- a/drivers/pinctrl/meson/pinctrl-meson.h 2022-05-27 17:20:17.113920629 +0800
11339 +++ b/drivers/pinctrl/meson/pinctrl-meson.h 2022-06-29 09:29:37.636093034 +0800
11340 @@ -130,6 +130,7 @@
11348 diff -Naur a/drivers/soc/amlogic/meson-canvas.c b/drivers/soc/amlogic/meson-canvas.c
11349 --- a/drivers/soc/amlogic/meson-canvas.c 2022-05-27 17:20:17.405924394 +0800
11350 +++ b/drivers/soc/amlogic/meson-canvas.c 2022-05-31 11:56:48.077256291 +0800
11351 @@ -148,6 +148,24 @@
11359 + spin_lock_irqsave(&canvas->lock, flags);
11360 + if (!canvas->used[canvas_index]) {
11361 + canvas->used[canvas_index] = 1;
11362 + spin_unlock_irqrestore(&canvas->lock, flags);
11365 + spin_unlock_irqrestore(&canvas->lock, flags);
11367 + dev_err(canvas->dev, "Canvas (%u) is busy\n", canvas_index);
11368 + return -EBUSY;
11376 diff -Naur a/drivers/staging/media/meson/vdec/codec_h264.c b/drivers/staging/media/meson/vdec/codec…
11377 --- a/drivers/staging/media/meson/vdec/codec_h264.c 2022-05-27 17:20:17.521925890 +0800
11378 +++ b/drivers/staging/media/meson/vdec/codec_h264.c 2022-05-31 11:56:48.081256256 +0800
11379 @@ -353,7 +353,8 @@
11383 - amvdec_src_change(sess, frame_width, frame_height, h264->max_refs + 5);
11385 + h264->max_refs + 5, 8);
11389 diff -Naur a/drivers/staging/media/meson/vdec/codec_hevc.c b/drivers/staging/media/meson/vdec/codec…
11390 --- a/drivers/staging/media/meson/vdec/codec_hevc.c 1970-01-01 08:00:00.000000000 +0800
11391 +++ b/drivers/staging/media/meson/vdec/codec_hevc.c 2022-05-31 11:56:48.081256256 +0800
11392 @@ -0,0 +1,1440 @@
11393 +// SPDX-License-Identifier: GPL-2.0+
11399 +#include <media/v4l2-mem2mem.h>
11400 +#include <media/videobuf2-dma-contig.h>
11672 + /* Whether we detected the bitstream as 10-bit */
11681 + hevc = sess->priv;
11685 + mutex_lock(&hevc->lock);
11686 + ret = hevc->frames_num;
11687 + mutex_unlock(&hevc->lock);
11696 + struct codec_hevc *hevc = sess->priv;
11697 + union rpm_param *params = &hevc->rpm_param;
11699 + (params->p.num_ref_idx_l0_active > MAX_REF_ACTIVE) ?
11700 + MAX_REF_ACTIVE : params->p.num_ref_idx_l0_active;
11702 + (params->p.num_ref_idx_l1_active > MAX_REF_ACTIVE) ?
11703 + MAX_REF_ACTIVE : params->p.num_ref_idx_l1_active;
11706 + u16 *mod_list = params->p.modification_list;
11713 + frame->ref_poc_list[0][frame->cur_slice_idx][i] = 0;
11714 + frame->ref_poc_list[1][frame->cur_slice_idx][i] = 0;
11718 + u16 cur_rps = params->p.CUR_RPS[i];
11719 + int delt = cur_rps & ((1 << (RPS_USED_BIT - 1)) - 1);
11727 + if ((cur_rps >> (RPS_USED_BIT - 1)) & 1) {
11729 + frame->poc - ((1 << (RPS_USED_BIT - 1)) - delt);
11732 + ref_picset1[num_pos] = frame->poc + delt;
11744 + if (params->p.modification_flag & 0x1)
11749 + frame->ref_poc_list[0][frame->cur_slice_idx][i] =
11750 + cidx >= num_neg ? ref_picset1[cidx - num_neg] :
11754 + if (params->p.slice_type != B_SLICE)
11757 + if (params->p.modification_flag & 0x2) {
11760 + if (params->p.modification_flag & 0x1)
11765 + frame->ref_poc_list[1][frame->cur_slice_idx][i] =
11766 + (cidx >= num_pos) ? ref_picset0[cidx - num_pos]
11772 + frame->ref_poc_list[1][frame->cur_slice_idx][i] =
11773 + cidx >= num_pos ? ref_picset0[cidx - num_pos] :
11779 + frame->ref_num[0] = num_ref_idx_l0_active;
11780 + frame->ref_num[1] = num_ref_idx_l1_active;
11782 + dev_dbg(sess->core->dev,
11784 + frame->poc, frame->cur_slice_idx, params->p.slice_type,
11785 + frame->ref_num[0], frame->ref_num[1]);
11790 + struct hevc_frame *frame = hevc->cur_frame;
11791 + u32 slice_type = frame->cur_slice_type;
11792 + u32 slice_idx = frame->cur_slice_idx;
11795 + hevc->ldc_flag = 0;
11800 + hevc->ldc_flag = 1;
11801 + for (i = 0; (i < frame->ref_num[0]) && hevc->ldc_flag; i++) {
11802 + if (frame->ref_poc_list[0][slice_idx][i] > frame->poc) {
11803 + hevc->ldc_flag = 0;
11811 + for (i = 0; (i < frame->ref_num[1]) && hevc->ldc_flag; i++) {
11812 + if (frame->ref_poc_list[1][slice_idx][i] > frame->poc) {
11813 + hevc->ldc_flag = 0;
11822 + union rpm_param *param = &hevc->rpm_param;
11825 + u32 curr_poc = hevc->curr_poc;
11827 + list_for_each_entry(frame, &hevc->ref_frames_list, list) {
11831 + if (!frame->referenced)
11836 + if (param->p.CUR_RPS[i] & 0x8000)
11839 + delt = param->p.CUR_RPS[i] &
11840 + ((1 << (RPS_USED_BIT - 1)) - 1);
11841 + if (param->p.CUR_RPS[i] & (1 << (RPS_USED_BIT - 1))) {
11842 + poc_tmp = curr_poc -
11843 + ((1 << (RPS_USED_BIT - 1)) - delt);
11846 + if (poc_tmp == frame->poc) {
11852 + frame->referenced = is_referenced;
11862 + list_for_each_entry(tmp, &hevc->ref_frames_list, list) {
11863 + if (tmp->poc < poc) {
11865 + poc = tmp->poc;
11876 + struct codec_hevc *hevc = sess->priv;
11879 + if (hevc->curr_poc &&
11880 + (tmp->referenced ||
11881 + tmp->num_reorder_pic >= hevc->frames_num))
11884 + dev_dbg(sess->core->dev, "DONE frame poc %u; vbuf %u\n",
11885 + tmp->poc, tmp->vbuf->vb2_buf.index);
11886 + amvdec_dst_buf_done_offset(sess, tmp->vbuf, tmp->offset,
11888 + list_del(&tmp->list);
11890 + hevc->frames_num--;
11899 + struct amvdec_core *core = sess->core;
11900 + u32 revision = core->platform->revision;
11904 + hevc->workspace_vaddr = dma_alloc_coherent(core->dev, SIZE_WORKSPACE,
11906 + if (!hevc->workspace_vaddr)
11907 + return -ENOMEM;
11909 + hevc->workspace_paddr = wkaddr;
11919 + if (codec_hevc_use_mmu(revision, sess->pixfmt_cap, hevc->is_10bit)) {
11927 + hevc->common.mmu_map_paddr);
11930 + hevc->common.mmu_map_paddr);
11952 + struct amvdec_core *core = sess->core;
11960 + return -ENOMEM;
11962 + INIT_LIST_HEAD(&hevc->ref_frames_list);
11963 + hevc->curr_poc = INVALID_POC;
11970 + if (core->platform->revision >= VDEC_REVISION_G12A)
12021 + hevc->aux_vaddr = dma_alloc_coherent(core->dev, SIZE_AUX,
12022 + &hevc->aux_paddr, GFP_KERNEL);
12023 + if (!hevc->aux_vaddr) {
12024 + dev_err(core->dev, "Failed to request HEVC AUX\n");
12025 + ret = -ENOMEM;
12029 + amvdec_write_dos(core, HEVC_AUX_ADR, hevc->aux_paddr);
12032 + mutex_init(&hevc->lock);
12033 + sess->priv = hevc;
12044 + struct codec_hevc *hevc = sess->priv;
12047 + while (!list_empty(&hevc->ref_frames_list)) {
12049 + amvdec_dst_buf_done(sess, tmp->vbuf, V4L2_FIELD_NONE);
12050 + list_del(&tmp->list);
12052 + hevc->frames_num--;
12058 + struct codec_hevc *hevc = sess->priv;
12059 + struct amvdec_core *core = sess->core;
12061 + mutex_lock(&hevc->lock);
12064 + if (hevc->workspace_vaddr)
12065 + dma_free_coherent(core->dev, SIZE_WORKSPACE,
12066 + hevc->workspace_vaddr,
12067 + hevc->workspace_paddr);
12069 + if (hevc->aux_vaddr)
12070 + dma_free_coherent(core->dev, SIZE_AUX,
12071 + hevc->aux_vaddr, hevc->aux_paddr);
12073 + codec_hevc_free_fbc_buffers(sess, &hevc->common);
12074 + mutex_unlock(&hevc->lock);
12075 + mutex_destroy(&hevc->lock);
12085 + list_for_each_entry(tmp, &hevc->ref_frames_list, list) {
12086 + if (tmp->poc == poc)
12096 + struct amvdec_core *core = sess->core;
12098 + struct codec_hevc *hevc = sess->priv;
12100 + union rpm_param *params = &hevc->rpm_param;
12106 + vbuf = v4l2_m2m_dst_buf_remove(sess->m2m_ctx);
12108 + dev_err(sess->core->dev, "No dst buffer available\n");
12112 + new_frame->vbuf = vbuf;
12113 + new_frame->referenced = 1;
12114 + new_frame->poc = hevc->curr_poc;
12115 + new_frame->cur_slice_type = params->p.slice_type;
12116 + new_frame->num_reorder_pic = params->p.sps_num_reorder_pics_0;
12117 + new_frame->offset = amvdec_read_dos(core, HEVC_SHIFT_BYTE_COUNT);
12119 + list_add_tail(&new_frame->list, &hevc->ref_frames_list);
12120 + hevc->frames_num++;
12128 + struct amvdec_core *core = sess->core;
12129 + struct codec_hevc *hevc = sess->priv;
12130 + struct vb2_buffer *vb = &frame->vbuf->vb2_buf;
12131 + union rpm_param *param = &hevc->rpm_param;
12133 + (hevc->height + hevc->lcu_size - 1) / hevc->lcu_size;
12134 + u32 sao_mem_unit = (hevc->lcu_size == 16 ? 9 :
12135 + hevc->lcu_size == 32 ? 14 : 24) << 4;
12137 + u32 misc_flag0 = param->p.misc_flag0;
12144 + ilog2(hevc->lcu_size);
12148 + hevc->width | (hevc->height << 16));
12150 + (hevc->lcu_x_num - 1) | (hevc->lcu_y_num - 1) << 16);
12152 + if (codec_hevc_use_downsample(sess->pixfmt_cap, hevc->is_10bit) ||
12153 + codec_hevc_use_mmu(core->platform->revision, sess->pixfmt_cap,
12154 + hevc->is_10bit))
12156 + hevc->common.fbc_buffer_paddr[vb->index];
12161 + if (codec_hevc_use_fbc(sess->pixfmt_cap, hevc->is_10bit)) {
12167 + if (sess->pixfmt_cap == V4L2_PIX_FMT_NV12M) {
12178 + if (codec_hevc_use_mmu(core->platform->revision, sess->pixfmt_cap,
12179 + hevc->is_10bit)) {
12181 + if (codec_hevc_use_downsample(sess->pixfmt_cap, hevc->is_10bit))
12182 + header_adr = hevc->common.mmu_header_paddr[vb->index];
12194 + if (frame->cur_slice_idx == 0) {
12195 + if (core->platform->revision >= VDEC_REVISION_G12A) {
12196 + if (core->platform->revision >= VDEC_REVISION_SM1)
12202 + if (codec_hevc_use_fbc(sess->pixfmt_cap,
12203 + hevc->is_10bit))
12207 + if (sess->pixfmt_cap == V4L2_PIX_FMT_NV12M)
12211 + if (hevc->width >= 1280)
12219 + hevc->width | (hevc->height << 16));
12226 + val |= (param->p.pps_cb_qp_offset & 0x1f) << 4;
12227 + val |= (param->p.pps_cr_qp_offset & 0x1f) << 9;
12228 + val |= (hevc->lcu_size == 64) ? 0 :
12229 + ((hevc->lcu_size == 32) ? 1 : 2);
12234 + val |= 0xff0; /* Set endianness for 2-bytes swaps (nv12) */
12235 + if (core->platform->revision < VDEC_REVISION_G12A) {
12236 + if (!codec_hevc_use_fbc(sess->pixfmt_cap, hevc->is_10bit))
12243 + if (!codec_hevc_use_fbc(sess->pixfmt_cap, hevc->is_10bit)) {
12264 + val |= (param->p.slice_beta_offset_div2 & 0xf) << 3;
12265 + val |= (param->p.slice_tc_offset_div2 & 0xf) << 7;
12274 + val |= (param->p.pps_beta_offset_div2 & 0xf) << 3;
12275 + val |= (param->p.pps_tc_offset_div2 & 0xf) << 7;
12306 + hevc->workspace_paddr + SAO_ABV_OFFSET);
12309 + hevc->workspace_paddr + SAO_VB_OFFSET);
12315 + return hevc->workspace_paddr + MPRED_MV_OFFSET +
12316 + (frame->vbuf->vb2_buf.index * MPRED_MV_BUF_SIZE);
12322 + union rpm_param *param = &hevc->rpm_param;
12323 + u32 slice_type = param->p.slice_type;
12324 + u32 lcu_size_log2 = ilog2(hevc->lcu_size);
12333 + (param->p.log2_parallel_merge_level << 24);
12338 + if (param->p.collocated_from_l0_flag)
12341 + if (param->p.slice_temporal_mvp_enable_flag)
12344 + if (hevc->ldc_flag)
12347 + if (param->p.dependent_slice_segment_flag)
12350 + if (param->p.slice_segment_address == 0)
12356 + val = (5 - param->p.five_minus_max_num_merge_cand) |
12369 + union rpm_param *param = &hevc->rpm_param;
12370 + u32 lcu_size_log2 = ilog2(hevc->lcu_size);
12381 + (hevc->slice_addr * mv_mem_unit);
12383 + (hevc->slice_addr * mv_mem_unit);
12385 + (hevc->lcu_total * mv_mem_unit);
12392 + if (param->p.slice_segment_address == 0) {
12394 + hevc->workspace_paddr + MPRED_ABV_OFFSET);
12410 + struct amvdec_core *core = sess->core;
12411 + struct codec_hevc *hevc = sess->priv;
12412 + u32 *ref_num = frame->ref_num;
12413 + u32 *ref_poc_l0 = frame->ref_poc_list[0][frame->cur_slice_idx];
12414 + u32 *ref_poc_l1 = frame->ref_poc_list[1][frame->cur_slice_idx];
12422 + hevc->width | (hevc->height << 16));
12424 + val = ((hevc->lcu_x_num - 1) | (hevc->lcu_y_num - 1) << 16);
12429 + amvdec_write_dos(core, HEVC_MPRED_REF_EN_L0, (1 << ref_num[0]) - 1);
12430 + amvdec_write_dos(core, HEVC_MPRED_REF_EN_L1, (1 << ref_num[1]) - 1);
12432 + amvdec_write_dos(core, HEVC_MPRED_CUR_POC, hevc->curr_poc);
12433 + amvdec_write_dos(core, HEVC_MPRED_COL_POC, hevc->col_poc);
12446 + struct amvdec_core *core = sess->core;
12447 + struct codec_hevc *hevc = sess->priv;
12452 + if (!codec_hevc_use_fbc(sess->pixfmt_cap, hevc->is_10bit)) {
12453 + l0_cnt = hevc->cur_frame->ref_num[0];
12454 + l1_cnt = hevc->cur_frame->ref_num[1];
12457 + if (hevc->cur_frame->cur_slice_type == I_SLICE) {
12462 + if (hevc->cur_frame->cur_slice_type == P_SLICE) {
12500 + /* enable mcrcc progressive-mode */
12507 + struct codec_hevc *hevc = sess->priv;
12509 + struct amvdec_core *core = sess->core;
12518 + dev_warn(core->dev, "Couldn't find ref. frame %u\n",
12523 + if (codec_hevc_use_fbc(sess->pixfmt_cap, hevc->is_10bit)) {
12524 + buf_id_y = buf_id_uv = ref_frame->vbuf->vb2_buf.index;
12526 + buf_id_y = ref_frame->vbuf->vb2_buf.index * 2;
12540 + struct amvdec_core *core = sess->core;
12542 + if (frame->cur_slice_type == I_SLICE)
12546 + codec_hevc_set_ref_list(sess, frame->ref_num[0],
12547 + frame->ref_poc_list[0][frame->cur_slice_idx]);
12549 + if (frame->cur_slice_type == P_SLICE)
12554 + codec_hevc_set_ref_list(sess, frame->ref_num[1],
12555 + frame->ref_poc_list[1][frame->cur_slice_idx]);
12560 + struct hevc_frame *cur_frame = hevc->cur_frame;
12561 + union rpm_param *param = &hevc->rpm_param;
12563 + u32 col_ref = param->p.collocated_ref_idx;
12564 + u32 col_from_l0 = param->p.collocated_from_l0_flag;
12565 + u32 cur_slice_idx = cur_frame->cur_slice_idx;
12567 + if (cur_frame->cur_slice_type == B_SLICE)
12568 + list_no = 1 - col_from_l0;
12570 + if (col_ref >= cur_frame->ref_num[list_no])
12571 + hevc->col_poc = INVALID_POC;
12573 + hevc->col_poc = cur_frame->ref_poc_list[list_no]
12577 + if (cur_frame->cur_slice_type == I_SLICE)
12580 + if (hevc->col_poc != INVALID_POC)
12581 + hevc->col_frame = codec_hevc_get_frame_by_poc(hevc,
12582 + hevc->col_poc);
12584 + hevc->col_frame = hevc->cur_frame;
12587 + if (!hevc->col_frame)
12588 + hevc->col_frame = hevc->cur_frame;
12593 + struct codec_hevc *hevc = sess->priv;
12594 + union rpm_param *param = &hevc->rpm_param;
12595 + u32 nal_unit_type = param->p.m_nalUnitType;
12596 + u32 temporal_id = param->p.m_temporalId & 0x7;
12598 + 1 << (param->p.log2_max_pic_order_cnt_lsb_minus4 + 4);
12602 + int poc_lsb = param->p.POClsb;
12606 + hevc->curr_poc = 0;
12607 + if ((temporal_id - 1) == 0)
12608 + hevc->prev_tid0_poc = hevc->curr_poc;
12613 + prev_poc_lsb = hevc->prev_tid0_poc % max_poc_lsb;
12614 + prev_poc_msb = hevc->prev_tid0_poc - prev_poc_lsb;
12617 + ((prev_poc_lsb - poc_lsb) >= (max_poc_lsb / 2)))
12620 + ((poc_lsb - prev_poc_lsb) > (max_poc_lsb / 2)))
12621 + poc_msb = prev_poc_msb - max_poc_lsb;
12630 + hevc->curr_poc = (poc_msb + poc_lsb);
12631 + if ((temporal_id - 1) == 0)
12632 + hevc->prev_tid0_poc = hevc->curr_poc;
12637 + struct codec_hevc *hevc = sess->priv;
12638 + union rpm_param *param = &hevc->rpm_param;
12640 + if (param->p.first_slice_segment_in_pic_flag == 0) {
12641 + hevc->slice_segment_addr = param->p.slice_segment_address;
12642 + if (!param->p.dependent_slice_segment_flag)
12643 + hevc->slice_addr = hevc->slice_segment_addr;
12645 + hevc->slice_segment_addr = 0;
12646 + hevc->slice_addr = 0;
12654 + struct codec_hevc *hevc = sess->priv;
12655 + struct amvdec_core *core = sess->core;
12656 + union rpm_param *param = &hevc->rpm_param;
12657 + u32 slice_segment_address = param->p.slice_segment_address;
12664 + hevc->cur_frame = codec_hevc_prepare_new_frame(sess);
12665 + if (!hevc->cur_frame)
12666 + return -1;
12668 + hevc->cur_frame->cur_slice_idx++;
12671 + codec_hevc_update_frame_refs(sess, hevc->cur_frame);
12674 + if (codec_hevc_use_mmu(core->platform->revision, sess->pixfmt_cap,
12675 + hevc->is_10bit))
12676 + codec_hevc_fill_mmu_map(sess, &hevc->common,
12677 + &hevc->cur_frame->vbuf->vb2_buf,
12678 + hevc->is_10bit);
12679 + codec_hevc_set_mc(sess, hevc->cur_frame);
12681 + codec_hevc_set_mpred(sess, hevc->cur_frame, hevc->col_frame);
12682 + codec_hevc_set_sao(sess, hevc->cur_frame);
12696 + union rpm_param *param = &hevc->rpm_param;
12702 + if (param->p.slice_segment_address ||
12703 + !param->p.pic_width_in_luma_samples ||
12704 + !param->p.pic_height_in_luma_samples)
12707 + if (param->p.bit_depth)
12710 + hevc->width = param->p.pic_width_in_luma_samples;
12711 + hevc->height = param->p.pic_height_in_luma_samples;
12712 + dst_width = hevc->width;
12713 + dst_height = hevc->height;
12715 + lcu_size = 1 << (param->p.log2_min_coding_block_size_minus3 +
12716 + 3 + param->p.log2_diff_max_min_coding_block_size);
12718 + hevc->lcu_x_num = (hevc->width + lcu_size - 1) / lcu_size;
12719 + hevc->lcu_y_num = (hevc->height + lcu_size - 1) / lcu_size;
12720 + hevc->lcu_total = hevc->lcu_x_num * hevc->lcu_y_num;
12722 + if (param->p.conformance_window_flag) {
12725 + switch (param->p.chroma_format_idc) {
12733 + dst_width -= sub_width *
12734 + (param->p.conf_win_left_offset +
12735 + param->p.conf_win_right_offset);
12736 + dst_height -= sub_height *
12737 + (param->p.conf_win_top_offset +
12738 + param->p.conf_win_bottom_offset);
12741 + if (dst_width != hevc->dst_width ||
12742 + dst_height != hevc->dst_height ||
12743 + lcu_size != hevc->lcu_size ||
12744 + is_10bit != hevc->is_10bit)
12747 + hevc->dst_width = dst_width;
12748 + hevc->dst_height = dst_height;
12749 + hevc->lcu_size = lcu_size;
12750 + hevc->is_10bit = is_10bit;
12761 + struct codec_hevc *hevc = sess->priv;
12762 + u16 *rpm_vaddr = hevc->workspace_vaddr + RPM_OFFSET;
12767 + hevc->rpm_param.l.data[i + j] = rpm_vaddr[i + 3 - j];
12772 + struct codec_hevc *hevc = sess->priv;
12774 + if (codec_hevc_setup_buffers(sess, &hevc->common, hevc->is_10bit)) {
12779 + codec_hevc_setup_decode_head(sess, hevc->is_10bit);
12787 + struct amvdec_core *core = sess->core;
12788 + struct codec_hevc *hevc = sess->priv;
12794 + mutex_lock(&hevc->lock);
12796 + dev_err(core->dev_dec, "Unrecognized dec_status: %08X\n",
12802 + sess->keyframe_found = 1;
12805 + amvdec_src_change(sess, hevc->dst_width, hevc->dst_height, 16,
12806 + hevc->is_10bit ? 10 : 8);
12815 + mutex_unlock(&hevc->lock);
12833 diff -Naur a/drivers/staging/media/meson/vdec/codec_hevc_common.c b/drivers/staging/media/meson/vde…
12834 --- a/drivers/staging/media/meson/vdec/codec_hevc_common.c 2022-05-27 17:20:17.521925890 +0800
12835 +++ b/drivers/staging/media/meson/vdec/codec_hevc_common.c 2022-05-31 11:56:48.081256256 +0800
12836 @@ -30,8 +30,11 @@
12839 struct amvdec_core *core = sess->core;
12840 - u32 body_size = amvdec_am21c_body_size(sess->width, sess->height);
12841 - u32 head_size = amvdec_am21c_head_size(sess->width, sess->height);
12842 + u32 use_mmu = codec_hevc_use_mmu(core->platform->revision,
12843 + sess->pixfmt_cap, is_10bit);
12844 + u32 body_size = amvdec_amfbc_body_size(sess->width, sess->height,
12846 + u32 head_size = amvdec_amfbc_head_size(sess->width, sess->height);
12848 if (!codec_hevc_use_fbc(sess->pixfmt_cap, is_10bit)) {
12849 /* Enable 2-plane reference read mode */
12850 @@ -39,9 +42,17 @@
12854 + /* enable mem saving mode for 8-bit */
12860 if (codec_hevc_use_mmu(core->platform->revision,
12861 sess->pixfmt_cap, is_10bit))
12868 @@ -73,7 +84,7 @@
12870 idx = vb->index;
12872 - if (codec_hevc_use_downsample(sess->pixfmt_cap, is_10bit))
12873 + if (codec_hevc_use_fbc(sess->pixfmt_cap, is_10bit))
12874 buf_y_paddr = comm->fbc_buffer_paddr[idx];
12877 @@ -114,8 +125,8 @@
12879 struct amvdec_core *core = sess->core;
12881 - u32 revision = core->platform->revision;
12882 u32 pixfmt_cap = sess->pixfmt_cap;
12883 + const u32 revision = core->platform->revision;
12887 @@ -127,12 +138,14 @@
12889 u32 idx = vb->index;
12891 - if (codec_hevc_use_mmu(revision, pixfmt_cap, is_10bit))
12892 - buf_y_paddr = comm->mmu_header_paddr[idx];
12893 - else if (codec_hevc_use_downsample(pixfmt_cap, is_10bit))
12894 - buf_y_paddr = comm->fbc_buffer_paddr[idx];
12895 - else
12898 + buf_y_paddr = comm->mmu_header_paddr[idx];
12900 + buf_y_paddr = comm->fbc_buffer_paddr[idx];
12907 @@ -150,60 +163,64 @@
12911 -void codec_hevc_free_fbc_buffers(struct amvdec_session *sess,
12915 struct device *dev = sess->core->dev;
12916 - u32 am21_size = amvdec_am21c_size(sess->width, sess->height);
12920 - if (comm->fbc_buffer_vaddr[i]) {
12921 - dma_free_coherent(dev, am21_size,
12922 - comm->fbc_buffer_vaddr[i],
12923 - comm->fbc_buffer_paddr[i]);
12924 - comm->fbc_buffer_vaddr[i] = NULL;
12925 + if (comm->mmu_header_vaddr[i]) {
12927 + comm->mmu_header_vaddr[i],
12928 + comm->mmu_header_paddr[i]);
12929 + comm->mmu_header_vaddr[i] = NULL;
12933 -EXPORT_SYMBOL_GPL(codec_hevc_free_fbc_buffers);
12936 -static int codec_hevc_alloc_fbc_buffers(struct amvdec_session *sess,
12940 struct device *dev = sess->core->dev;
12942 - u32 am21_size = amvdec_am21c_size(sess->width, sess->height);
12944 v4l2_m2m_for_each_dst_buf(sess->m2m_ctx, buf) {
12945 u32 idx = buf->vb.vb2_buf.index;
12947 - void *vaddr = dma_alloc_coherent(dev, am21_size, &paddr,
12948 - GFP_KERNEL);
12952 - codec_hevc_free_fbc_buffers(sess, comm);
12954 return -ENOMEM;
12957 - comm->fbc_buffer_vaddr[idx] = vaddr;
12958 - comm->fbc_buffer_paddr[idx] = paddr;
12959 + comm->mmu_header_vaddr[idx] = vaddr;
12960 + comm->mmu_header_paddr[idx] = paddr;
12966 -void codec_hevc_free_mmu_headers(struct amvdec_session *sess,
12970 struct device *dev = sess->core->dev;
12971 + u32 use_mmu = codec_hevc_use_mmu(sess->core->platform->revision,
12972 + sess->pixfmt_cap,
12973 + sess->bitdepth == 10 ? 1 : 0);
12974 + u32 am21_size = amvdec_amfbc_size(sess->width, sess->height,
12975 + sess->bitdepth == 10 ? 1 : 0,
12980 - if (comm->mmu_header_vaddr[i]) {
12981 - dma_free_coherent(dev, MMU_COMPRESS_HEADER_SIZE,
12982 - comm->mmu_header_vaddr[i],
12983 - comm->mmu_header_paddr[i]);
12984 - comm->mmu_header_vaddr[i] = NULL;
12985 + if (comm->fbc_buffer_vaddr[i]) {
12987 + comm->fbc_buffer_vaddr[i],
12988 + comm->fbc_buffer_paddr[i]);
12989 + comm->fbc_buffer_vaddr[i] = NULL;
12993 @@ -213,33 +230,47 @@
12994 comm->mmu_map_paddr);
12995 comm->mmu_map_vaddr = NULL;
13000 -EXPORT_SYMBOL_GPL(codec_hevc_free_mmu_headers);
13003 -static int codec_hevc_alloc_mmu_headers(struct amvdec_session *sess,
13007 struct device *dev = sess->core->dev;
13009 + const u32 revision = sess->core->platform->revision;
13010 + const u32 is_10bit = sess->bitdepth == 10 ? 1 : 0;
13011 + u32 use_mmu = codec_hevc_use_mmu(revision, sess->pixfmt_cap,
13013 + u32 am21_size = amvdec_amfbc_size(sess->width, sess->height,
13017 - comm->mmu_map_vaddr = dma_alloc_coherent(dev, MMU_MAP_SIZE,
13018 - &comm->mmu_map_paddr,
13019 - GFP_KERNEL);
13020 - if (!comm->mmu_map_vaddr)
13021 - return -ENOMEM;
13024 v4l2_m2m_for_each_dst_buf(sess->m2m_ctx, buf) {
13025 u32 idx = buf->vb.vb2_buf.index;
13027 - void *vaddr = dma_alloc_coherent(dev, MMU_COMPRESS_HEADER_SIZE,
13028 - &paddr, GFP_KERNEL);
13032 - codec_hevc_free_mmu_headers(sess, comm);
13034 return -ENOMEM;
13037 - comm->mmu_header_vaddr[idx] = vaddr;
13038 - comm->mmu_header_paddr[idx] = paddr;
13039 + comm->fbc_buffer_vaddr[idx] = vaddr;
13040 + comm->fbc_buffer_paddr[idx] = paddr;
13043 + if (codec_hevc_use_mmu(revision, sess->pixfmt_cap, is_10bit) &&
13044 + codec_hevc_use_downsample(sess->pixfmt_cap, is_10bit)) {
13053 @@ -250,21 +281,24 @@
13056 struct amvdec_core *core = sess->core;
13057 + struct device *dev = core->dev;
13060 - if (codec_hevc_use_downsample(sess->pixfmt_cap, is_10bit)) {
13061 - ret = codec_hevc_alloc_fbc_buffers(sess, comm);
13062 - if (ret)
13063 - return ret;
13064 + if (codec_hevc_use_mmu(core->platform->revision,
13065 + sess->pixfmt_cap, is_10bit)) {
13066 + comm->mmu_map_vaddr = dma_alloc_coherent(dev, MMU_MAP_SIZE,
13067 + &comm->mmu_map_paddr,
13069 + if (!comm->mmu_map_vaddr)
13070 + return -ENOMEM;
13073 if (codec_hevc_use_mmu(core->platform->revision,
13074 - sess->pixfmt_cap, is_10bit)) {
13075 - ret = codec_hevc_alloc_mmu_headers(sess, comm);
13076 - if (ret) {
13077 - codec_hevc_free_fbc_buffers(sess, comm);
13078 + sess->pixfmt_cap, is_10bit) ||
13079 + codec_hevc_use_downsample(sess->pixfmt_cap, is_10bit)) {
13083 - }
13086 if (core->platform->revision == VDEC_REVISION_GXBB)
13087 @@ -278,19 +312,19 @@
13091 - struct vb2_buffer *vb)
13095 - u32 size = amvdec_am21c_size(sess->width, sess->height);
13096 + u32 use_mmu = codec_hevc_use_mmu(sess->core->platform->revision,
13097 + sess->pixfmt_cap, is_10bit);
13098 + u32 size = amvdec_amfbc_size(sess->width, sess->height, is_10bit,
13101 u32 *mmu_map = comm->mmu_map_vaddr;
13105 - if (sess->pixfmt_cap == V4L2_PIX_FMT_NV12M)
13106 - first_page = comm->fbc_buffer_paddr[vb->index] >> PAGE_SHIFT;
13107 - else
13108 - first_page = vb2_dma_contig_plane_dma_addr(vb, 0) >> PAGE_SHIFT;
13109 -
13110 + first_page = comm->fbc_buffer_paddr[vb->index] >> PAGE_SHIFT;
13114 diff -Naur a/drivers/staging/media/meson/vdec/codec_hevc_common.h b/drivers/staging/media/meson/vde…
13115 --- a/drivers/staging/media/meson/vdec/codec_hevc_common.h 2022-05-27 17:20:17.525925941 +0800
13116 +++ b/drivers/staging/media/meson/vdec/codec_hevc_common.h 2022-05-31 11:56:48.081256256 +0800
13117 @@ -66,6 +66,7 @@
13121 - struct vb2_buffer *vb);
13126 diff -Naur a/drivers/staging/media/meson/vdec/codec_hevc.h b/drivers/staging/media/meson/vdec/codec…
13127 --- a/drivers/staging/media/meson/vdec/codec_hevc.h 1970-01-01 08:00:00.000000000 +0800
13128 +++ b/drivers/staging/media/meson/vdec/codec_hevc.h 2022-05-31 11:56:48.081256256 +0800
13129 @@ -0,0 +1,13 @@
13130 +/* SPDX-License-Identifier: GPL-2.0+ */
13143 diff -Naur a/drivers/staging/media/meson/vdec/codec_vp9.c b/drivers/staging/media/meson/vdec/codec_…
13144 --- a/drivers/staging/media/meson/vdec/codec_vp9.c 2022-05-27 17:20:17.525925941 +0800
13145 +++ b/drivers/staging/media/meson/vdec/codec_vp9.c 2022-05-31 11:56:48.081256256 +0800
13146 @@ -458,12 +458,6 @@
13150 - /* In case of downsampling (decoding with FBC but outputting in NV12M),
13151 - * we need to allocate additional buffers for FBC.
13152 - */
13153 - void *fbc_buffer_vaddr[MAX_REF_PIC_NUM];
13154 - dma_addr_t fbc_buffer_paddr[MAX_REF_PIC_NUM];
13155 -
13159 @@ -901,11 +895,8 @@
13163 - if (codec_hevc_use_fbc(sess->pixfmt_cap, vp9->is_10bit)) {
13164 - val = amvdec_read_dos(core, HEVC_SAO_CTRL5) & ~0xff0200;
13165 - amvdec_write_dos(core, HEVC_SAO_CTRL5, val);
13166 + if (codec_hevc_use_fbc(sess->pixfmt_cap, vp9->is_10bit))
13168 - }
13170 if (sess->pixfmt_cap == V4L2_PIX_FMT_NV12M) {
13172 @@ -920,8 +911,12 @@
13174 if (codec_hevc_use_mmu(core->platform->revision, sess->pixfmt_cap,
13175 vp9->is_10bit)) {
13176 - amvdec_write_dos(core, HEVC_CM_HEADER_START_ADDR,
13177 - vp9->common.mmu_header_paddr[vb->index]);
13179 + if (codec_hevc_use_downsample(sess->pixfmt_cap, vp9->is_10bit))
13180 + header_adr = vp9->common.mmu_header_paddr[vb->index];
13187 @@ -1147,6 +1142,8 @@
13190 struct amvdec_core *core = sess->core;
13191 + u32 use_mmu = codec_hevc_use_mmu(core->platform->revision,
13192 + sess->pixfmt_cap, vp9->is_10bit);
13196 @@ -1166,8 +1163,9 @@
13197 vp9->frame_refs[i]->height != vp9->height)
13200 - sz = amvdec_am21c_body_size(vp9->frame_refs[i]->width,
13201 - vp9->frame_refs[i]->height);
13202 + sz = amvdec_amfbc_body_size(vp9->frame_refs[i]->width,
13203 + vp9->frame_refs[i]->height,
13204 + vp9->is_10bit, use_mmu);
13207 vp9->frame_refs[i]->width);
13208 @@ -1283,7 +1281,8 @@
13209 if (codec_hevc_use_mmu(core->platform->revision, sess->pixfmt_cap,
13210 vp9->is_10bit))
13211 codec_hevc_fill_mmu_map(sess, &vp9->common,
13212 - &vp9->cur_frame->vbuf->vb2_buf);
13213 + &vp9->cur_frame->vbuf->vb2_buf,
13214 + vp9->is_10bit);
13216 intra_only = param->p.show_frame ? 0 : param->p.intra_only;
13218 @@ -2132,7 +2131,8 @@
13222 - amvdec_src_change(sess, vp9->width, vp9->height, 16);
13223 + amvdec_src_change(sess, vp9->width, vp9->height, 16,
13224 + vp9->is_10bit ? 10 : 8);
13227 vp9->cur_frame = NULL;
13228 diff -Naur a/drivers/staging/media/meson/vdec/esparser.c b/drivers/staging/media/meson/vdec/esparse…
13229 --- a/drivers/staging/media/meson/vdec/esparser.c 2022-05-27 17:20:17.525925941 +0800
13230 +++ b/drivers/staging/media/meson/vdec/esparser.c 2022-05-31 11:56:48.081256256 +0800
13231 @@ -309,12 +309,12 @@
13235 - if (sess->fmt_out->pixfmt == V4L2_PIX_FMT_VP9) {
13236 + if (sess->fmt_out->pixfmt == V4L2_PIX_FMT_VP9 || sess->fmt_out->pixfmt ==V4L2_PIX_FMT_HEVC) {
13237 if (codec_ops->num_pending_bufs)
13238 num_dst_bufs = codec_ops->num_pending_bufs(sess);
13240 num_dst_bufs += v4l2_m2m_num_dst_bufs_ready(sess->m2m_ctx);
13241 - if (sess->fmt_out->pixfmt == V4L2_PIX_FMT_VP9)
13242 + if (sess->fmt_out->pixfmt == V4L2_PIX_FMT_VP9 || sess->fmt_out->pixfmt ==V4L2_PIX_FMT_HEVC)
13243 num_dst_bufs -= 3;
13246 diff -Naur a/drivers/staging/media/meson/vdec/hevc_regs.h b/drivers/staging/media/meson/vdec/hevc_r…
13247 --- a/drivers/staging/media/meson/vdec/hevc_regs.h 2022-05-27 17:20:17.525925941 +0800
13248 +++ b/drivers/staging/media/meson/vdec/hevc_regs.h 2022-05-31 11:56:48.081256256 +0800
13249 @@ -205,6 +205,7 @@
13257 diff -Naur a/drivers/staging/media/meson/vdec/Makefile b/drivers/staging/media/meson/vdec/Makefile
13258 --- a/drivers/staging/media/meson/vdec/Makefile 2022-05-27 17:20:17.521925890 +0800
13259 +++ b/drivers/staging/media/meson/vdec/Makefile 2022-05-31 11:56:48.081256256 +0800
13260 @@ -3,6 +3,6 @@
13262 meson-vdec-objs = esparser.o vdec.o vdec_helpers.o vdec_platform.o
13263 meson-vdec-objs += vdec_1.o vdec_hevc.o
13264 -meson-vdec-objs += codec_mpeg12.o codec_h264.o codec_hevc_common.o codec_vp9.o
13265 +meson-vdec-objs += codec_mpeg12.o codec_h264.o codec_hevc_common.o codec_hevc.o codec_vp9.o
13267 obj-$(CONFIG_VIDEO_MESON_VDEC) += meson-vdec.o
13268 diff -Naur a/drivers/staging/media/meson/vdec/vdec.c b/drivers/staging/media/meson/vdec/vdec.c
13269 --- a/drivers/staging/media/meson/vdec/vdec.c 2022-05-27 17:20:17.525925941 +0800
13270 +++ b/drivers/staging/media/meson/vdec/vdec.c 2022-05-31 11:56:48.085256221 +0800
13271 @@ -1131,6 +1131,6 @@
13275 -MODULE_DESCRIPTION("Meson video decoder driver for GXBB/GXL/GXM");
13279 diff -Naur a/drivers/staging/media/meson/vdec/vdec.h b/drivers/staging/media/meson/vdec/vdec.h
13280 --- a/drivers/staging/media/meson/vdec/vdec.h 2022-05-27 17:20:17.525925941 +0800
13281 +++ b/drivers/staging/media/meson/vdec/vdec.h 2022-05-31 11:56:48.085256221 +0800
13282 @@ -234,6 +234,7 @@
13290 diff -Naur a/drivers/staging/media/meson/vdec/vdec_helpers.c b/drivers/staging/media/meson/vdec/vde…
13291 --- a/drivers/staging/media/meson/vdec/vdec_helpers.c 2022-05-27 17:20:17.525925941 +0800
13292 +++ b/drivers/staging/media/meson/vdec/vdec_helpers.c 2022-05-31 11:56:48.085256221 +0800
13293 @@ -50,32 +50,40 @@
13297 -/* 4 KiB per 64x32 block */
13298 -u32 amvdec_am21c_body_size(u32 width, u32 height)
13306 - return SZ_4K * width_64 * height_32;
13316 -EXPORT_SYMBOL_GPL(amvdec_am21c_body_size);
13320 -u32 amvdec_am21c_head_size(u32 width, u32 height)
13328 -EXPORT_SYMBOL_GPL(amvdec_am21c_head_size);
13331 -u32 amvdec_am21c_size(u32 width, u32 height)
13334 - return ALIGN(amvdec_am21c_body_size(width, height) +
13335 - amvdec_am21c_head_size(width, height), SZ_64K);
13339 -EXPORT_SYMBOL_GPL(amvdec_am21c_size);
13344 @@ -436,7 +444,7 @@
13348 - u32 height, u32 dpb_size)
13353 @@ -444,25 +452,27 @@
13355 v4l2_ctrl_s_ctrl(sess->ctrl_min_buf_capture, dpb_size);
13357 + sess->bitdepth = bitdepth;
13361 - * usecase. If so, keep decoding with it and do not send the event
13364 if (sess->streamon_cap &&
13365 sess->width == width &&
13366 sess->height == height &&
13367 dpb_size <= sess->num_dst_bufs) {
13368 sess->fmt_out->codec_ops->resume(sess);
13369 - return;
13371 + sess->status = STATUS_NEEDS_RESUME;
13372 + sess->changed_format = 0;
13375 - sess->changed_format = 0;
13376 sess->width = width;
13377 sess->height = height;
13378 - sess->status = STATUS_NEEDS_RESUME;
13380 - dev_dbg(sess->core->dev, "Res. changed (%ux%u), DPB size %u\n",
13381 - width, height, dpb_size);
13382 + dev_dbg(sess->core->dev, "Res. changed (%ux%u), DPB %u, bitdepth %u\n",
13384 v4l2_event_queue_fh(&sess->fh, &ev);
13387 diff -Naur a/drivers/staging/media/meson/vdec/vdec_helpers.h b/drivers/staging/media/meson/vdec/vde…
13388 --- a/drivers/staging/media/meson/vdec/vdec_helpers.h 2022-05-27 17:20:17.525925941 +0800
13389 +++ b/drivers/staging/media/meson/vdec/vdec_helpers.h 2022-05-31 11:56:48.085256221 +0800
13390 @@ -27,9 +27,10 @@
13394 -u32 amvdec_am21c_body_size(u32 width, u32 height);
13395 -u32 amvdec_am21c_head_size(u32 width, u32 height);
13396 -u32 amvdec_am21c_size(u32 width, u32 height);
13403 * amvdec_dst_buf_done_idx() - Signal that a buffer is done decoding
13404 @@ -76,9 +77,10 @@
13411 - u32 height, u32 dpb_size);
13415 * amvdec_abort() - Abort the current decoding session
13416 diff -Naur a/drivers/staging/media/meson/vdec/vdec_platform.c b/drivers/staging/media/meson/vdec/vd…
13417 --- a/drivers/staging/media/meson/vdec/vdec_platform.c 2022-05-27 17:20:17.525925941 +0800
13418 +++ b/drivers/staging/media/meson/vdec/vdec_platform.c 2022-05-31 11:56:48.085256221 +0800
13419 @@ -11,6 +11,7 @@
13427 @@ -65,6 +66,18 @@
13446 @@ -115,6 +128,18 @@
13465 @@ -153,6 +178,18 @@
13484 @@ -202,6 +239,18 @@
13503 diff -Naur a/drivers/thermal/amlogic_thermal.c b/drivers/thermal/amlogic_thermal.c
13504 --- a/drivers/thermal/amlogic_thermal.c 2022-05-27 17:20:17.609927025 +0800
13505 +++ b/drivers/thermal/amlogic_thermal.c 2022-05-31 11:56:48.085256221 +0800
13506 @@ -29,6 +29,7 @@
13514 @@ -291,6 +292,9 @@
13518 + if (devm_thermal_add_hwmon_sysfs(pdata->tzd))
13519 + dev_warn(&pdev->dev, "failed to add hwmon sysfs attributes\n");
13524 diff -Naur a/drivers/tty/serial/meson_uart.c b/drivers/tty/serial/meson_uart.c
13525 --- a/drivers/tty/serial/meson_uart.c 2022-05-27 17:20:17.641927438 +0800
13526 +++ b/drivers/tty/serial/meson_uart.c 2022-05-31 11:56:48.085256200 +0800
13527 @@ -2,15 +2,19 @@
13531 - * Copyright (C) 2014 Carlo Caione <carlo@caione.org>
13545 -#include <linux/iopoll.h>
13549 @@ -19,6 +23,7 @@
13557 @@ -31,15 +36,9 @@
13561 -#define AML_UART_TWO_WIRE_EN BIT(15)
13562 -#define AML_UART_STOP_BIT_LEN_MASK (0x03 << 16)
13563 -#define AML_UART_STOP_BIT_1SB (0x00 << 16)
13564 -#define AML_UART_STOP_BIT_2SB (0x01 << 16)
13565 -#define AML_UART_PARITY_TYPE BIT(18)
13566 -#define AML_UART_PARITY_EN BIT(19)
13569 -#define AML_UART_CLEAR_ERR BIT(24)
13574 @@ -55,10 +54,20 @@
13578 -#define AML_UART_XMIT_BUSY BIT(25)
13582 - AML_UART_TX_FIFO_WERR)
13597 @@ -68,17 +77,28 @@
13604 -#define AML_UART_PORT_NUM 12
13607 -#define AML_UART_DEV_NAME "ttyAML"
13609 -#define AML_UART_POLL_USEC 5
13610 -#define AML_UART_TIMEOUT_USEC 10000
13617 -static struct uart_port *meson_ports[AML_UART_PORT_NUM];
13631 @@ -93,27 +113,27 @@
13635 - val = readl(port->membase + AML_UART_STATUS);
13636 - val &= (AML_UART_TX_EMPTY | AML_UART_XMIT_BUSY);
13637 - return (val == AML_UART_TX_EMPTY) ? TIOCSER_TEMT : 0;
13638 + val = readl_relaxed(port->membase + AML_UART_STATUS);
13645 -
13646 - val = readl(port->membase + AML_UART_CONTROL);
13647 - val &= ~AML_UART_TX_INT_EN;
13648 - writel(val, port->membase + AML_UART_CONTROL);
13649 + if (port->line == 0)
13651 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
13653 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13660 - val = readl(port->membase + AML_UART_CONTROL);
13661 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
13663 - writel(val, port->membase + AML_UART_CONTROL);
13664 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13668 @@ -121,14 +141,16 @@
13672 - free_irq(port->irq, port);
13673 + if (port->line == 0)
13676 spin_lock_irqsave(&port->lock, flags);
13678 - val = readl(port->membase + AML_UART_CONTROL);
13679 - val &= ~AML_UART_RX_EN;
13680 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
13683 - writel(val, port->membase + AML_UART_CONTROL);
13685 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13687 spin_unlock_irqrestore(&port->lock, flags);
13689 @@ -137,115 +159,147 @@
13691 struct circ_buf *xmit = &port->state->xmit;
13693 - u32 val;
13694 -
13695 - if (uart_tx_stopped(port)) {
13696 - meson_uart_stop_tx(port);
13697 - return;
13698 - }
13699 -
13700 - while (!(readl(port->membase + AML_UART_STATUS) & AML_UART_TX_FULL)) {
13701 - if (port->x_char) {
13702 - writel(port->x_char, port->membase + AML_UART_WFIFO);
13703 - port->icount.tx++;
13704 - port->x_char = 0;
13705 - continue;
13706 - }
13710 - if (uart_circ_empty(xmit))
13711 + spin_lock_irqsave(&mup->wr_lock, flags);
13713 + if (readl_relaxed(port->membase + AML_UART_STATUS)
13717 ch = xmit->buf[xmit->tail];
13718 - writel(ch, port->membase + AML_UART_WFIFO);
13719 - xmit->tail = (xmit->tail+1) & (SERIAL_XMIT_SIZE - 1);
13720 + writel_relaxed(ch, port->membase + AML_UART_WFIFO);
13721 + xmit->tail = (xmit->tail + 1) & (SERIAL_XMIT_SIZE - 1);
13722 port->icount.tx++;
13724 + spin_unlock_irqrestore(&mup->wr_lock, flags);
13729 + struct circ_buf *xmit = &port->state->xmit;
13734 - if (!uart_circ_empty(xmit)) {
13735 - val = readl(port->membase + AML_UART_CONTROL);
13736 - val |= AML_UART_TX_INT_EN;
13737 - writel(val, port->membase + AML_UART_CONTROL);
13738 + spin_lock(&port->lock);
13739 + if (port->x_char) {
13740 + writel_relaxed(port->x_char, port->membase + AML_UART_WFIFO);
13741 + port->icount.tx++;
13742 + port->x_char = 0;
13749 + spin_lock(&mup->wr_lock);
13750 + while (!uart_circ_empty(xmit) && count-- > 0) {
13751 + if (readl_relaxed(port->membase + AML_UART_STATUS)
13754 + ch = xmit->buf[xmit->tail];
13755 + writel_relaxed(ch, port->membase + AML_UART_WFIFO);
13756 + xmit->tail = (xmit->tail + 1) & (SERIAL_XMIT_SIZE - 1);
13757 + port->icount.tx++;
13759 + spin_unlock(&mup->wr_lock);
13765 + spin_unlock(&port->lock);
13772 struct tty_port *tport = &port->state->port;
13774 - u32 ostatus, status, ch, mode;
13777 + spin_lock(&port->lock);
13780 port->icount.rx++;
13781 - ostatus = status = readl(port->membase + AML_UART_STATUS);
13782 + status = readl_relaxed(port->membase + AML_UART_STATUS);
13785 - if (status & AML_UART_TX_FIFO_WERR)
13787 port->icount.overrun++;
13789 port->icount.frame++;
13791 port->icount.frame++;
13793 - mode = readl(port->membase + AML_UART_CONTROL);
13794 + mode = readl_relaxed(port->membase + AML_UART_CONTROL);
13796 - writel(mode, port->membase + AML_UART_CONTROL);
13797 + writel_relaxed(mode, port->membase + AML_UART_CONTROL);
13801 - writel(mode, port->membase + AML_UART_CONTROL);
13802 + writel_relaxed(mode, port->membase + AML_UART_CONTROL);
13804 status &= port->read_status_mask;
13805 - if (status & AML_UART_FRAME_ERR)
13813 - ch = readl(port->membase + AML_UART_RFIFO);
13814 + ch = readl_relaxed(port->membase + AML_UART_RFIFO);
13817 - if ((ostatus & AML_UART_FRAME_ERR) && (ch == 0)) {
13818 - port->icount.brk++;
13819 - flag = TTY_BREAK;
13820 - if (uart_handle_break(port))
13821 - continue;
13822 - }
13823 -
13824 - if (uart_handle_sysrq_char(port, ch))
13825 - continue;
13826 -
13827 - if ((status & port->ignore_status_mask) == 0)
13828 - tty_insert_flip_char(tport, ch, flag);
13832 + port->icount.brk++;
13837 - if (status & AML_UART_TX_FIFO_WERR)
13838 - tty_insert_flip_char(tport, 0, TTY_OVERRUN);
13839 + if (port->sysrq)
13842 - } while (!(readl(port->membase + AML_UART_STATUS) & AML_UART_RX_EMPTY));
13851 + * if ((status & port->ignore_status_mask) == 0)
13857 + } while (!(readl_relaxed(port->membase + AML_UART_STATUS) & AML_UART_RX_EMPTY));
13858 spin_unlock(&port->lock);
13861 - spin_lock(&port->lock);
13870 spin_lock(&port->lock);
13871 -
13872 - if (!(readl(port->membase + AML_UART_STATUS) & AML_UART_RX_EMPTY))
13873 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
13874 + spin_unlock(&port->lock);
13875 + if (!(readl_relaxed(port->membase + AML_UART_STATUS) & AML_UART_RX_EMPTY))
13878 - if (!(readl(port->membase + AML_UART_STATUS) & AML_UART_TX_FULL)) {
13879 - if (readl(port->membase + AML_UART_CONTROL) & AML_UART_TX_INT_EN)
13880 - meson_uart_start_tx(port);
13881 - }
13882 -
13883 - spin_unlock(&port->lock);
13884 + if ((val & AML_UART_TX_EN) && (!(readl_relaxed(port->membase + AML_UART_STATUS) &
13890 @@ -255,40 +309,25 @@
13891 return (port->type == PORT_MESON) ? "meson_uart" : NULL;
13894 -static void meson_uart_reset(struct uart_port *port)
13895 -{
13896 - u32 val;
13897 -
13898 - val = readl(port->membase + AML_UART_CONTROL);
13899 - val |= (AML_UART_RX_RST | AML_UART_TX_RST | AML_UART_CLEAR_ERR);
13900 - writel(val, port->membase + AML_UART_CONTROL);
13901 -
13902 - val &= ~(AML_UART_RX_RST | AML_UART_TX_RST | AML_UART_CLEAR_ERR);
13903 - writel(val, port->membase + AML_UART_CONTROL);
13904 -}
13905 -
13911 - val = readl(port->membase + AML_UART_CONTROL);
13912 - val |= AML_UART_CLEAR_ERR;
13913 - writel(val, port->membase + AML_UART_CONTROL);
13914 - val &= ~AML_UART_CLEAR_ERR;
13915 - writel(val, port->membase + AML_UART_CONTROL);
13916 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
13918 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13921 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13924 - writel(val, port->membase + AML_UART_CONTROL);
13925 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13928 - writel(val, port->membase + AML_UART_CONTROL);
13929 -
13930 - val = (AML_UART_RECV_IRQ(1) | AML_UART_XMIT_IRQ(port->fifosize / 2));
13931 - writel(val, port->membase + AML_UART_MISC);
13933 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
13935 - ret = request_irq(port->irq, meson_uart_interrupt, 0,
13936 - port->name, port);
13940 @@ -296,18 +335,37 @@
13945 + struct platform_device *pdev = to_platform_device(port->dev);
13947 - while (!meson_uart_tx_empty(port))
13948 + while (!(readl_relaxed(port->membase + AML_UART_STATUS) & AML_UART_TX_EMPTY))
13951 + val = readl_relaxed(port->membase + AML_UART_REG5);
13953 if (port->uartclk == 24000000) {
13954 - val = ((port->uartclk / 3) / baud) - 1;
13955 - val |= AML_UART_BAUD_XTAL;
13957 + val = (port->uartclk / 2 + baud / 2) / baud - 1;
13961 + val = ((port->uartclk / 3) + baud / 2) / baud - 1;
13967 + dev_info(&pdev->dev, "ttyS%d use clk81 %d change %ld to %ld\n",
13968 + port->line, port->uartclk,
13969 + mup->baud, baud);
13970 val = ((port->uartclk * 10 / (baud * 4) + 5) / 10) - 1;
13975 - val |= AML_UART_BAUD_USE;
13976 - writel(val, port->membase + AML_UART_REG5);
13977 + writel_relaxed(val, port->membase + AML_UART_REG5);
13979 + mup->baud = baud;
13983 @@ -323,7 +381,7 @@
13984 cflags = termios->c_cflag;
13985 iflags = termios->c_iflag;
13987 - val = readl(port->membase + AML_UART_CONTROL);
13988 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
13992 @@ -351,34 +409,34 @@
13996 - val &= ~AML_UART_STOP_BIT_LEN_MASK;
13999 - val |= AML_UART_STOP_BIT_2SB;
14002 - val |= AML_UART_STOP_BIT_1SB;
14010 - writel(val, port->membase + AML_UART_CONTROL);
14011 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
14012 + spin_unlock_irqrestore(&port->lock, flags);
14014 - baud = uart_get_baud_rate(port, termios, old, 50, 4000000);
14018 - port->read_status_mask = AML_UART_TX_FIFO_WERR;
14019 + port->read_status_mask = AML_UART_RX_FIFO_OVERFLOW;
14021 port->read_status_mask |= AML_UART_PARITY_ERR |
14022 - AML_UART_FRAME_ERR;
14025 port->ignore_status_mask = 0;
14027 port->ignore_status_mask |= AML_UART_PARITY_ERR |
14028 - AML_UART_FRAME_ERR;
14031 uart_update_timeout(port, termios->c_cflag, baud);
14032 - spin_unlock_irqrestore(&port->lock, flags);
14036 @@ -397,25 +455,51 @@
14040 - devm_iounmap(port->dev, port->membase);
14041 - port->membase = NULL;
14042 - devm_release_mem_region(port->dev, port->mapbase, port->mapsize);
14043 + if (port->flags & UPF_IOREMAP) {
14044 + iounmap(port->membase);
14045 + port->membase = NULL;
14051 - if (!devm_request_mem_region(port->dev, port->mapbase, port->mapsize,
14052 + struct platform_device *pdev = to_platform_device(port->dev);
14059 + dev_err(&pdev->dev, "cannot obtain I/O memory region");
14060 + return -ENODEV;
14064 + if (!devm_request_mem_region(port->dev, port->mapbase, size,
14065 dev_name(port->dev))) {
14066 dev_err(port->dev, "Memory region busy\n");
14067 return -EBUSY;
14070 - port->membase = devm_ioremap(port->dev, port->mapbase,
14071 - port->mapsize);
14072 - if (!port->membase)
14073 - return -ENOMEM;
14074 + if (port->flags & UPF_IOREMAP) {
14075 + port->membase = devm_ioremap(port->dev,
14076 + port->mapbase, size);
14077 + if (!port->membase)
14078 + return -ENOMEM;
14081 + dev_info(&pdev->dev, "==uart%d reg addr = %px\n",
14082 + port->line, port->membase);
14083 + val = (AML_UART_RECV_IRQ(1) | AML_UART_XMIT_IRQ(port->fifosize / 2));
14084 + writel_relaxed(val, port->membase + AML_UART_MISC);
14086 + writel_relaxed(readl_relaxed(port->membase + AML_UART_CONTROL) | UART_CTS_EN,
14087 + port->membase + AML_UART_CONTROL);
14089 + ret = devm_request_irq(port->dev, port->irq, meson_uart_interrupt,
14090 + IRQF_SHARED, port->name, port);
14096 @@ -426,64 +510,6 @@
14100 -#ifdef CONFIG_CONSOLE_POLL
14101 -/*
14102 - * Console polling routines for writing and reading from the uart while
14103 - * in an interrupt or debug context (i.e. kgdb).
14104 - */
14105 -
14106 -static int meson_uart_poll_get_char(struct uart_port *port)
14107 -{
14108 - u32 c;
14109 - unsigned long flags;
14110 -
14111 - spin_lock_irqsave(&port->lock, flags);
14112 -
14113 - if (readl(port->membase + AML_UART_STATUS) & AML_UART_RX_EMPTY)
14114 - c = NO_POLL_CHAR;
14115 - else
14116 - c = readl(port->membase + AML_UART_RFIFO);
14117 -
14118 - spin_unlock_irqrestore(&port->lock, flags);
14119 -
14120 - return c;
14121 -}
14122 -
14123 -static void meson_uart_poll_put_char(struct uart_port *port, unsigned char c)
14124 -{
14125 - unsigned long flags;
14126 - u32 reg;
14127 - int ret;
14128 -
14129 - spin_lock_irqsave(&port->lock, flags);
14130 -
14131 - /* Wait until FIFO is empty or timeout */
14132 - ret = readl_poll_timeout_atomic(port->membase + AML_UART_STATUS, reg,
14133 - reg & AML_UART_TX_EMPTY,
14134 - AML_UART_POLL_USEC,
14135 - AML_UART_TIMEOUT_USEC);
14136 - if (ret == -ETIMEDOUT) {
14137 - dev_err(port->dev, "Timeout waiting for UART TX EMPTY\n");
14138 - goto out;
14139 - }
14140 -
14141 - /* Write the character */
14142 - writel(c, port->membase + AML_UART_WFIFO);
14143 -
14144 - /* Wait until FIFO is empty or timeout */
14145 - ret = readl_poll_timeout_atomic(port->membase + AML_UART_STATUS, reg,
14146 - reg & AML_UART_TX_EMPTY,
14147 - AML_UART_POLL_USEC,
14148 - AML_UART_TIMEOUT_USEC);
14149 - if (ret == -ETIMEDOUT)
14150 - dev_err(port->dev, "Timeout waiting for UART TX EMPTY\n");
14151 -
14152 -out:
14153 - spin_unlock_irqrestore(&port->lock, flags);
14154 -}
14155 -
14156 -#endif /* CONFIG_CONSOLE_POLL */
14157 -
14161 @@ -499,10 +525,6 @@
14165 -#ifdef CONFIG_CONSOLE_POLL
14166 - .poll_get_char = meson_uart_poll_get_char,
14167 - .poll_put_char = meson_uart_poll_put_char,
14168 -#endif
14172 @@ -510,9 +532,9 @@
14176 - val = readl(port->membase + AML_UART_CONTROL);
14177 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
14179 - writel(val, port->membase + AML_UART_CONTROL);
14180 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
14184 @@ -520,9 +542,10 @@
14185 if (!port->membase)
14188 - while (readl(port->membase + AML_UART_STATUS) & AML_UART_TX_FULL)
14189 + while (readl_relaxed(port->membase + AML_UART_STATUS) &
14192 - writel(ch, port->membase + AML_UART_WFIFO);
14193 + writel_relaxed(ch, port->membase + AML_UART_WFIFO);
14197 @@ -542,12 +565,12 @@
14201 - val = readl(port->membase + AML_UART_CONTROL);
14202 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
14204 - writel(tmp, port->membase + AML_UART_CONTROL);
14205 + writel_relaxed(tmp, port->membase + AML_UART_CONTROL);
14208 - writel(val, port->membase + AML_UART_CONTROL);
14209 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
14212 spin_unlock(&port->lock);
14213 @@ -559,7 +582,7 @@
14217 - port = meson_ports[co->index];
14218 + port = &meson_ports[co->index]->port;
14222 @@ -574,10 +597,10 @@
14226 - if (co->index < 0 || co->index >= AML_UART_PORT_NUM)
14227 + if (co->index < 0 || co->index >= AML_UART_PORT_MAX)
14228 return -EINVAL;
14230 - port = meson_ports[co->index];
14231 + port = &meson_ports[co->index]->port;
14232 if (!port || !port->membase)
14233 return -ENODEV;
14235 @@ -616,7 +639,8 @@
14239 -meson_serial_early_console_setup(struct earlycon_device *device, const char *opt)
14243 if (!device->port.membase)
14244 return -ENODEV;
14245 @@ -641,10 +665,72 @@
14249 - .nr = AML_UART_PORT_NUM,
14265 + save_mode = readl_relaxed(port->membase + AML_UART_CONTROL);
14285 + writel_relaxed(save_mode, port->membase + AML_UART_CONTROL);
14319 @@ -715,22 +801,15 @@
14327 - int id = -1;
14329 if (pdev->dev.of_node)
14330 pdev->id = of_alias_get_id(pdev->dev.of_node, "serial");
14332 - if (pdev->id < 0) {
14333 - for (id = AML_UART_PORT_OFFSET; id < AML_UART_PORT_NUM; id++) {
14334 - if (!meson_ports[id]) {
14335 - pdev->id = id;
14336 - break;
14337 - }
14338 - }
14339 - }
14340 -
14341 - if (pdev->id < 0 || pdev->id >= AML_UART_PORT_NUM)
14342 + if (pdev->id < 0 || pdev->id >= AML_UART_PORT_MAX)
14343 return -EINVAL;
14346 @@ -746,10 +825,14 @@
14347 return -EBUSY;
14350 - port = devm_kzalloc(&pdev->dev, sizeof(struct uart_port), GFP_KERNEL);
14351 - if (!port)
14352 + mup = devm_kzalloc(&pdev->dev,
14355 return -ENOMEM;
14357 + spin_lock_init(&mup->wr_lock);
14358 + port = &mup->port;
14361 if (of_device_is_compatible(pdev->dev.of_node, "amlogic,meson-uart"))
14363 @@ -757,34 +840,45 @@
14367 - return ret;
14370 + port->fifosize = 64;
14372 + prop = of_get_property(pdev->dev.of_node, "fifosize", NULL);
14374 + port->fifosize = of_read_ulong(prop, 1);
14377 + prop = of_get_property(pdev->dev.of_node, "xtal_tick_en", NULL);
14382 port->iotype = UPIO_MEM;
14383 port->mapbase = res_mem->start;
14384 - port->mapsize = resource_size(res_mem);
14385 port->irq = res_irq->start;
14386 - port->flags = UPF_BOOT_AUTOCONF | UPF_LOW_LATENCY;
14387 - port->has_sysrq = IS_ENABLED(CONFIG_SERIAL_MESON_CONSOLE);
14388 + port->flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP | UPF_LOW_LATENCY;
14389 port->dev = &pdev->dev;
14390 port->line = pdev->id;
14391 port->type = PORT_MESON;
14392 port->x_char = 0;
14393 port->ops = &meson_uart_ops;
14394 - port->fifosize = 64;
14396 - meson_ports[pdev->id] = port;
14397 + meson_ports[pdev->id] = mup;
14399 -
14400 - /* reset port before registering (and possibly registering console) */
14401 - if (meson_uart_request_port(port) >= 0) {
14402 - meson_uart_reset(port);
14403 - meson_uart_release_port(port);
14404 + if (of_get_property(pdev->dev.of_node, "pinctrl-names", NULL)) {
14405 + mup->p = devm_pinctrl_get_select_default(&pdev->dev);
14406 + /* if (!mup->p) */
14407 + /* return -1; */
14409 -
14412 meson_ports[pdev->id] = NULL;
14414 + prop = of_get_property(pdev->dev.of_node, "support-sysrq", NULL);
14421 @@ -799,6 +893,59 @@
14432 + dev_err(&pdev->dev, "port is NULL");
14436 + if (port->line == 0)
14440 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
14443 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
14457 + dev_err(&pdev->dev, "port is NULL");
14461 + if (port->line == 0)
14465 + val = readl_relaxed(port->membase + AML_UART_CONTROL);
14470 + dev_info(&pdev->dev, "pull up rts");
14472 + writel_relaxed(val, port->membase + AML_UART_CONTROL);
14480 { .compatible = "amlogic,meson-uart" },
14481 @@ -814,9 +961,15 @@
14485 - .driver = {
14486 - .name = "meson_uart",
14487 - .of_match_table = meson_uart_dt_match,
14500 diff -Naur a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
14501 --- a/drivers/usb/chipidea/core.c 2022-06-30 21:35:01.824331749 +0800
14502 +++ b/drivers/usb/chipidea/core.c 2022-05-27 17:20:17.661927695 +0800
14503 @@ -509,7 +509,7 @@
14507 -static irqreturn_t ci_irq_handler(int irq, void *data)
14512 @@ -562,15 +562,6 @@
14516 -static void ci_irq(struct ci_hdrc *ci)
14517 -{
14518 - unsigned long flags;
14519 -
14520 - local_irq_save(flags);
14521 - ci_irq_handler(ci->irq, ci);
14522 - local_irq_restore(flags);
14523 -}
14524 -
14528 @@ -580,7 +571,7 @@
14529 cbl->connected = event;
14530 cbl->changed = true;
14532 - ci_irq(ci);
14533 + ci_irq(ci->irq, ci);
14537 @@ -621,7 +612,7 @@
14539 cable->changed = true;
14540 cable->connected = false;
14541 - ci_irq(ci);
14542 + ci_irq(ci->irq, ci);
14543 spin_unlock_irqrestore(&ci->lock, flags);
14544 if (ci->wq && role != USB_ROLE_NONE)
14545 flush_workqueue(ci->wq);
14546 @@ -639,7 +630,7 @@
14548 cable->changed = true;
14549 cable->connected = true;
14550 - ci_irq(ci);
14551 + ci_irq(ci->irq, ci);
14553 spin_unlock_irqrestore(&ci->lock, flags);
14554 pm_runtime_put_sync(ci->dev);
14555 @@ -1175,7 +1166,7 @@
14559 - ret = devm_request_irq(dev, ci->irq, ci_irq_handler, IRQF_SHARED,
14560 + ret = devm_request_irq(dev, ci->irq, ci_irq, IRQF_SHARED,
14561 ci->platdata->name, ci);
14564 @@ -1296,11 +1287,11 @@
14566 if (!IS_ERR(cable_id->edev) && ci->is_otg &&
14568 - ci_irq(ci);
14569 + ci_irq(ci->irq, ci);
14571 if (!IS_ERR(cable_vbus->edev) && ci->is_otg &&
14573 - ci_irq(ci);
14574 + ci_irq(ci->irq, ci);
14578 diff -Naur a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
14579 --- a/drivers/usb/core/hub.c 2022-05-27 17:20:17.665927747 +0800
14580 +++ b/drivers/usb/core/hub.c 2022-05-31 11:56:48.085256221 +0800
14581 @@ -1826,7 +1826,8 @@
14584 if (hdev->parent) { /* normal device */
14585 - usb_enable_autosuspend(hdev);
14586 + if (!(hdev->parent->quirks & USB_QUIRK_AUTO_SUSPEND))
14589 const struct hc_driver *drv = bus_to_hcd(hdev->bus)->driver;
14591 diff -Naur a/drivers/usb/dwc3/dwc3-meson-g12a.c b/drivers/usb/dwc3/dwc3-meson-g12a.c
14592 --- a/drivers/usb/dwc3/dwc3-meson-g12a.c 2022-05-27 17:20:17.673927851 +0800
14593 +++ b/drivers/usb/dwc3/dwc3-meson-g12a.c 2022-06-02 17:31:15.284653437 +0800
14594 @@ -269,6 +269,59 @@
14620 + regmap_read(priv->u2p_regmap[1], U2P_R0, ®0.d32);
14637 + regmap_update_bits(priv->u2p_regmap[1], U2P_R0,
14641 + regmap_update_bits(priv->u2p_regmap[1], U2P_R0,
14654 @@ -436,6 +489,10 @@
14658 + ret = device_create_file(priv->dev, &dev_attr_usb_mode);
14660 + dev_err(priv->dev, "failed create usb mode file\n");
14665 diff -Naur a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
14666 --- a/drivers/usb/gadget/composite.c 2022-05-27 17:20:17.673927851 +0800
14667 +++ b/drivers/usb/gadget/composite.c 2022-05-31 11:56:48.085256221 +0800
14668 @@ -2061,7 +2061,7 @@
14672 -void composite_disconnect(struct usb_gadget *gadget)
14677 @@ -2078,6 +2078,23 @@
14678 spin_unlock_irqrestore(&cdev->lock, flags);
14698 /*-------------------------------------------------------------------------*/
14701 @@ -2398,7 +2415,7 @@
14705 - .reset = composite_disconnect,
14710 diff -Naur a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
14711 --- a/drivers/usb/gadget/configfs.c 2022-05-27 17:20:17.673927851 +0800
14712 +++ b/drivers/usb/gadget/configfs.c 2022-05-31 11:56:48.085256221 +0800
14713 @@ -10,6 +10,32 @@
14738 + return ERR_PTR(-EINVAL);
14746 @@ -51,6 +77,12 @@
14759 @@ -272,7 +304,7 @@
14761 mutex_lock(&gi->lock);
14763 - if (!strlen(name)) {
14768 @@ -1270,6 +1302,9 @@
14769 f->name, f);
14770 f->unbind(c, f);
14773 + if (f->bind_deactivated)
14776 c->next_interface_id = 0;
14777 memset(c->interface, 0, sizeof(c->interface));
14778 @@ -1422,6 +1457,57 @@
14786 + struct usb_composite_dev *cdev = &gi->cdev;
14790 + /* 0-connected 1-configured 2-disconnected*/
14795 + spin_lock_irqsave(&cdev->lock, flags);
14796 + if (cdev->config)
14799 + if (gi->connected != gi->sw_connected) {
14800 + if (gi->connected)
14804 + gi->sw_connected = gi->connected;
14806 + spin_unlock_irqrestore(&cdev->lock, flags);
14809 + kobject_uevent_env(&gi->dev->kobj, KOBJ_CHANGE, connected);
14815 + kobject_uevent_env(&gi->dev->kobj, KOBJ_CHANGE, configured);
14821 + kobject_uevent_env(&gi->dev->kobj, KOBJ_CHANGE, disconnected);
14828 + gi->connected, gi->sw_connected, cdev->config);
14836 @@ -1447,6 +1533,51 @@
14837 spin_unlock_irqrestore(&gi->spinlock, flags);
14847 + int value = -EOPNOTSUPP;
14850 + spin_lock_irqsave(&cdev->lock, flags);
14851 + if (c->bRequest == USB_REQ_GET_DESCRIPTOR &&
14852 + (c->wValue >> 8) == USB_DT_CONFIG && !gi->connected) {
14853 + gi->connected = 1;
14854 + schedule_work(&gi->work);
14856 + spin_unlock_irqrestore(&cdev->lock, flags);
14857 + list_for_each_entry(fi, &gi->available_func, cfs_list) {
14858 + if (fi != NULL && fi->f != NULL && fi->f->setup != NULL) {
14859 + value = fi->f->setup(fi->f, c);
14873 + spin_lock_irqsave(&cdev->lock, flags);
14874 + if (c->bRequest == USB_REQ_SET_CONFIGURATION &&
14875 + cdev->config) {
14876 + schedule_work(&gi->work);
14878 + spin_unlock_irqrestore(&cdev->lock, flags);
14888 @@ -1472,6 +1603,8 @@
14897 @@ -1482,6 +1615,14 @@
14910 spin_lock_irqsave(&gi->spinlock, flags);
14912 @@ -1490,10 +1631,36 @@
14917 + gi->connected = 0;
14918 + schedule_work(&gi->work);
14921 spin_unlock_irqrestore(&gi->spinlock, flags);
14935 + spin_lock_irqsave(&gi->spinlock, flags);
14937 + if (!cdev || gi->unbind) {
14938 + spin_unlock_irqrestore(&gi->spinlock, flags);
14943 + spin_unlock_irqrestore(&gi->spinlock, flags);
14949 @@ -1542,10 +1709,13 @@
14957 - .reset = configfs_composite_disconnect,
14961 -
14965 @@ -1557,6 +1727,91 @@
14981 + cdev = &dev->cdev;
14986 + spin_lock_irqsave(&cdev->lock, flags);
14987 + if (cdev->config)
14989 + else if (dev->connected)
14991 + spin_unlock_irqrestore(&cdev->lock, flags);
15008 + INIT_WORK(&gi->work, android_work);
15009 + gi->dev = device_create(android_class, NULL,
15011 + if (IS_ERR(gi->dev))
15012 + return PTR_ERR(gi->dev);
15014 + dev_set_drvdata(gi->dev, gi);
15016 + android_device = gi->dev;
15022 + err = device_create_file(gi->dev, attr);
15024 + device_destroy(gi->dev->class,
15025 + gi->dev->devt);
15040 + device_remove_file(gi->dev, attr);
15041 + device_destroy(gi->dev->class, gi->dev->devt);
15057 @@ -1609,7 +1864,11 @@
15058 if (!gi->composite.gadget_driver.function)
15064 return &gi->group;
15068 return ERR_PTR(-ENOMEM);
15069 @@ -1617,7 +1876,11 @@
15081 @@ -1657,6 +1920,13 @@
15095 @@ -1664,5 +1934,10 @@
15106 diff -Naur a/drivers/usb/gadget/function/f_generic.c b/drivers/usb/gadget/function/f_generic.c
15107 --- a/drivers/usb/gadget/function/f_generic.c 2022-06-28 19:20:24.331709124 +0800
15108 +++ b/drivers/usb/gadget/function/f_generic.c 1970-01-01 08:00:00.000000000 +0800
15109 @@ -1,3779 +0,0 @@
15110 -// SPDX-License-Identifier: GPL-2.0+
15111 -/*
15112 - * f_fs.c -- user mode file system API for USB composite function controllers
15113 - *
15114 - * Copyright (C) 2010 Samsung Electronics
15115 - * Author: Michal Nazarewicz <mina86@mina86.com>
15116 - *
15117 - * Based on inode.c (GadgetFS) which was:
15118 - * Copyright (C) 2003-2004 David Brownell
15119 - * Copyright (C) 2003 Agilent Technologies
15120 - */
15121 -
15122 -/* #define DEBUG */
15123 -/* #define VERBOSE_DEBUG */
15124 -
15125 -#include <linux/export.h>
15126 -#include <linux/hid.h>
15127 -#include <linux/miscdevice.h>
15128 -#include <linux/usb/functionfs.h>
15129 -#include <linux/kfifo.h>
15130 -#include <linux/module.h>
15131 -#include <linux/poll.h>
15132 -#include <linux/eventfd.h>
15133 -#include <linux/dma-mapping.h>
15134 -#include <linux/usb/cdc.h>
15135 -#include <linux/interrupt.h>
15136 -#include "u_generic.h"
15137 -#include "u_f.h"
15138 -#include "u_os_desc.h"
15139 -#include "configfs.h"
15140 -
15141 -#define FUNCTIONFS_MAGIC 0xa647361 /* Chosen by a honest dice roll ;) */
15142 -
15143 -/* Reference counter handling */
15144 -static void ffs_data_get(struct ffs_data *ffs);
15145 -static void ffs_data_put(struct ffs_data *ffs);
15146 -/* Creates new ffs_data object. */
15147 -static struct ffs_data *__must_check ffs_data_new(const char *dev_name)
15148 - __attribute__((malloc));
15149 -
15150 -/* Called with ffs->mutex held; take over ownership of data. */
15151 -static int __must_check
15152 -__ffs_data_got_descs(struct ffs_data *ffs, char *data, size_t len);
15153 -static int __must_check
15154 -__ffs_data_got_strings(struct ffs_data *ffs, char *data, size_t len);
15155 -
15156 -/* The function structure ***************************************************/
15157 -
15158 -struct ffs_ep;
15159 -
15160 -struct ffs_function {
15161 - struct usb_configuration *conf;
15162 - struct usb_gadget *gadget;
15163 - struct ffs_data *ffs;
15164 -
15165 - struct ffs_ep *eps;
15166 - u8 eps_revmap[16];
15167 - short *interfaces_nums;
15168 -
15169 - struct usb_function function;
15170 -};
15171 -static struct ffs_function *ffs_func_from_usb(struct usb_function *f)
15172 -{
15173 - return container_of(f, struct ffs_function, function);
15174 -}
15175 -static inline enum ffs_setup_state ffs_setup_state_clear_cancelled(struct ffs_data *ffs)
15176 -{
15177 - return (enum ffs_setup_state)
15178 - cmpxchg(&ffs->setup_state, FFS_SETUP_CANCELLED, FFS_NO_SETUP);
15179 -}
15180 -static void ffs_func_eps_disable(struct ffs_function *func);
15181 -static int __must_check ffs_func_eps_enable(struct ffs_function *func);
15182 -
15183 -static int ffs_func_bind(struct usb_configuration *,
15184 - struct usb_function *);
15185 -static int ffs_func_set_alt(struct usb_function *, unsigned, unsigned);
15186 -static void ffs_func_disable(struct usb_function *);
15187 -static int ffs_func_setup(struct usb_function *,
15188 - const struct usb_ctrlrequest *);
15189 -static bool ffs_func_req_match(struct usb_function *,
15190 - const struct usb_ctrlrequest *,
15191 - bool config0);
15192 -static void ffs_func_suspend(struct usb_function *);
15193 -static void ffs_func_resume(struct usb_function *);
15194 -
15195 -static int ffs_func_revmap_ep(struct ffs_function *func, u8 num);
15196 -static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf);
15197 -
15198 -/* The endpoints structures *************************************************/
15199 -struct ffs_ep {
15200 - struct usb_ep *ep; /* P: ffs->eps_lock */
15201 - struct usb_request *req; /* P: epfile->mutex */
15202 -
15203 - /* [0]: full speed, [1]: high speed, [2]: super speed */
15204 - struct usb_endpoint_descriptor *descs[3];
15205 -
15206 - u8 num;
15207 -
15208 - int status; /* P: epfile->mutex */
15209 -};
15210 -
15211 -struct ffs_epfile {
15212 - /* Protects ep->ep and ep->req. */
15213 - struct mutex mutex;
15214 - struct list_head memory_list;
15215 - struct ffs_data *ffs;
15216 - struct ffs_ep *ep; /* P: ffs->eps_lock */
15217 - /*
15218 - * Buffer for holding data from partial reads which may happen since
15219 - * we’re rounding user read requests to a multiple of a max packet size.
15220 - *
15221 - * The pointer is initialised with NULL value and may be set by
15222 - * __ffs_epfile_read_data function to point to a temporary buffer.
15223 - *
15224 - * In normal operation, calls to __ffs_epfile_read_buffered will consume
15225 - * data from said buffer and eventually free it. Importantly, while the
15226 - * function is using the buffer, it sets the pointer to NULL. This is
15227 - * all right since __ffs_epfile_read_data and __ffs_epfile_read_buffered
15228 - * can never run concurrently (they are synchronised by epfile->mutex)
15229 - * so the latter will not assign a new value to the pointer.
15230 - *
15231 - * Meanwhile ffs_func_eps_disable frees the buffer (if the pointer is
15232 - * valid) and sets the pointer to READ_BUFFER_DROP value. This special
15233 - * value is crux of the synchronisation between ffs_func_eps_disable and
15234 - * __ffs_epfile_read_data.
15235 - *
15236 - * Once __ffs_epfile_read_data is about to finish it will try to set the
15237 - * pointer back to its old value (as described above), but seeing as the
15238 - * pointer is not-NULL (namely READ_BUFFER_DROP) it will instead free
15239 - * the buffer.
15240 - *
15241 - * == State transitions ==
15242 - *
15243 - * • ptr == NULL: (initial state)
15244 - * ◦ __ffs_epfile_read_buffer_free: go to ptr == DROP
15245 - * ◦ __ffs_epfile_read_buffered: nop
15246 - * ◦ __ffs_epfile_read_data allocates temp buffer: go to ptr == buf
15247 - * ◦ reading finishes: n/a, not in ‘and reading’ state
15248 - * • ptr == DROP:
15249 - * ◦ __ffs_epfile_read_buffer_free: nop
15250 - * ◦ __ffs_epfile_read_buffered: go to ptr == NULL
15251 - * ◦ __ffs_epfile_read_data allocates temp buffer: free buf, nop
15252 - * ◦ reading finishes: n/a, not in ‘and reading’ state
15253 - * • ptr == buf:
15254 - * ◦ __ffs_epfile_read_buffer_free: free buf, go to ptr == DROP
15255 - * ◦ __ffs_epfile_read_buffered: go to ptr == NULL and reading
15256 - * ◦ __ffs_epfile_read_data: n/a, __ffs_epfile_read_buffered
15257 - * is always called first
15258 - * ◦ reading finishes: n/a, not in ‘and reading’ state
15259 - * • ptr == NULL and reading:
15260 - * ◦ __ffs_epfile_read_buffer_free: go to ptr == DROP and reading
15261 - * ◦ __ffs_epfile_read_buffered: n/a, mutex is held
15262 - * ◦ __ffs_epfile_read_data: n/a, mutex is held
15263 - * ◦ reading finishes and …
15264 - * … all data read: free buf, go to ptr == NULL
15265 - * … otherwise: go to ptr == buf and reading
15266 - * • ptr == DROP and reading:
15267 - * ◦ __ffs_epfile_read_buffer_free: nop
15268 - * ◦ __ffs_epfile_read_buffered: n/a, mutex is held
15269 - * ◦ __ffs_epfile_read_data: n/a, mutex is held
15270 - * ◦ reading finishes: free buf, go to ptr == DROP
15271 - */
15272 - struct ffs_buffer *read_buffer;
15273 -#define READ_BUFFER_DROP ((struct ffs_buffer *)ERR_PTR(-ESHUTDOWN))
15274 -
15275 - char name[MAX_NAMELEN];
15276 - dev_t devno;
15277 - struct cdev cdev;
15278 - struct device *device;
15279 -
15280 - unsigned char in; /* P: ffs->eps_lock */
15281 - unsigned char isoc; /* P: ffs->eps_lock */
15282 -
15283 - struct kfifo reqEventFifo;
15284 - wait_queue_head_t wait_que;
15285 -
15286 - unsigned char _pad;
15287 -};
15288 -
15289 -struct ffs_buffer {
15290 - size_t length;
15291 - char *data;
15292 - char storage[];
15293 -};
15294 -
15295 -/* ffs_io_data structure ***************************************************/
15296 -
15297 -struct ffs_io_data {
15298 - uint32_t aio;
15299 - uint32_t read;
15300 - uint32_t len;
15301 - uint32_t timeout;
15302 - uint64_t buf;
15303 - uint32_t actual;
15304 - int status;
15305 - struct tasklet_struct task;
15306 - struct usb_ep *ep;
15307 - struct usb_request *req;
15308 - struct ffs_epfile *epfile;
15309 - struct ffs_data *ffs;
15310 -};
15311 -
15312 -struct ffs_desc_helper {
15313 - struct ffs_data *ffs;
15314 - unsigned interfaces_count;
15315 - unsigned eps_count;
15316 -};
15317 -
15318 -static int __must_check ffs_epfiles_create(struct ffs_data *ffs);
15319 -static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count);
15320 -
15321 -/* Devices management *******************************************************/
15322 -
15323 -DEFINE_MUTEX(ffs_lock_adapter);
15324 -EXPORT_SYMBOL_GPL(ffs_lock_adapter);
15325 -
15326 -static struct ffs_dev *_ffs_find_dev(const char *name);
15327 -static struct ffs_dev *_ffs_alloc_dev(void);
15328 -static void _ffs_free_dev(struct ffs_dev *dev);
15329 -static void *ffs_acquire_dev(const char *dev_name);
15330 -static void ffs_release_dev(struct ffs_data *ffs_data);
15331 -static int ffs_ready(struct ffs_data *ffs);
15332 -static void ffs_closed(struct ffs_data *ffs);
15333 -
15334 -/* Misc helper functions ****************************************************/
15335 -
15336 -static int ffs_mutex_lock(struct mutex *mutex, unsigned nonblock)
15337 - __attribute__((warn_unused_result, nonnull));
15338 -static char *ffs_prepare_buffer(const char __user *buf, size_t len)
15339 - __attribute__((warn_unused_result, nonnull));
15340 -
15341 -struct class *ffs_class;
15342 -static char *ffs_devnode(struct device *dev, umode_t *mode)
15343 -{
15344 - if (mode)
15345 - *mode = 0666;
15346 - return kasprintf(GFP_KERNEL, "functionfs/%s", dev_name(dev));
15347 -}
15348 -
15349 -/* Control file aka ep0 *****************************************************/
15350 -static struct ffs_memory *generic_find_ep0_memory_area(struct ffs_data *ffs, uint64_t buf, uint32_…
15351 -{
15352 - struct ffs_memory *ffsm = NULL;
15353 - struct ffs_memory *iter = NULL;
15354 - uint64_t buf_start = buf;
15355 - unsigned long flags;
15356 -
15357 - spin_lock_irqsave(&ffs->mem_lock, flags);
15358 - list_for_each_entry(iter, &ffs->memory_list, memlist) {
15359 - if (buf_start >= iter->vm_start &&
15360 - buf_start < iter->vm_start + iter->size) {
15361 - if (len <= iter->vm_start + iter->size - buf_start) {
15362 - ffsm = iter;
15363 - break;
15364 - }
15365 - }
15366 - }
15367 - spin_unlock_irqrestore(&ffs->mem_lock, flags);
15368 - return ffsm;
15369 -}
15370 -
15371 -static void ffs_ep0_complete(struct usb_ep *ep, struct usb_request *req)
15372 -{
15373 - struct ffs_data *ffs = req->context;
15374 -
15375 - complete(&ffs->ep0req_completion);
15376 -
15377 - ffs->setup_state = FFS_NO_SETUP;
15378 -}
15379 -
15380 -static void ffs_ep0_async_io_complete(struct usb_ep *_ep, struct usb_request *req)
15381 -{
15382 - struct ffs_io_data *io_data = req->context;
15383 - struct ffs_data *ffs = io_data->ffs;
15384 - ENTER();
15385 -
15386 - io_data->status = io_data->req->status;
15387 - io_data->actual = io_data->req->actual;
15388 - kfifo_in(&ffs->reqEventFifo, &io_data->buf, sizeof(struct UsbFnReqEvent));
15389 - wake_up_all(&ffs->wait_que);
15390 -
15391 - list_del(&req->list);
15392 - usb_ep_free_request(io_data->ep, io_data->req);
15393 - kfree(io_data);
15394 -
15395 -}
15396 -
15397 -static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
15398 - __releases(&ffs->ev.waitq.lock)
15399 -{
15400 - struct usb_request *req = ffs->ep0req;
15401 - int ret;
15402 -
15403 - req->zero = len < le16_to_cpu(ffs->ev.setup.wLength);
15404 -
15405 - spin_unlock_irq(&ffs->ev.waitq.lock);
15406 -
15407 - req->buf = data;
15408 - req->length = len;
15409 -
15410 - /*
15411 - * UDC layer requires to provide a buffer even for ZLP, but should
15412 - * not use it at all. Let's provide some poisoned pointer to catch
15413 - * possible bug in the driver.
15414 - */
15415 - if (req->buf == NULL)
15416 - req->buf = (void *)0xDEADBABE;
15417 -
15418 - reinit_completion(&ffs->ep0req_completion);
15419 -
15420 - ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
15421 - if (unlikely(ret < 0))
15422 - return ret;
15423 -
15424 - ret = wait_for_completion_interruptible(&ffs->ep0req_completion);
15425 - if (unlikely(ret)) {
15426 - usb_ep_dequeue(ffs->gadget->ep0, req);
15427 - return -EINTR;
15428 - }
15429 -
15430 - ffs->setup_state = FFS_NO_SETUP;
15431 - return req->status ? req->status : req->actual;
15432 -}
15433 -
15434 -static int __ffs_ep0_stall(struct ffs_data *ffs)
15435 -{
15436 - if (ffs->ev.can_stall) {
15437 - pr_vdebug("ep0 stall\n");
15438 - usb_ep_set_halt(ffs->gadget->ep0);
15439 - ffs->setup_state = FFS_NO_SETUP;
15440 - return -EL2HLT;
15441 - } else {
15442 - pr_debug("bogus ep0 stall!\n");
15443 - return -ESRCH;
15444 - }
15445 -}
15446 -
15447 -static ssize_t ffs_ep0_write(struct file *file, const char __user *buf, size_t len, loff_t *ptr)
15448 -{
15449 - struct ffs_data *ffs = file->private_data;
15450 - ssize_t ret;
15451 - char *data = NULL;
15452 -
15453 - ENTER();
15454 -
15455 - /* Fast check if setup was canceled */
15456 - if (ffs_setup_state_clear_cancelled(ffs) == FFS_SETUP_CANCELLED)
15457 - return -EIDRM;
15458 -
15459 - /* Acquire mutex */
15460 - ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
15461 - if (unlikely(ret < 0))
15462 - return ret;
15463 -
15464 - /* Check state */
15465 - switch (ffs->state) {
15466 - case FFS_READ_DESCRIPTORS:
15467 - case FFS_READ_STRINGS:
15468 - /* Copy data */
15469 - if (unlikely(len < 16)) {
15470 - ret = -EINVAL;
15471 - break;
15472 - }
15473 -
15474 - data = ffs_prepare_buffer(buf, len);
15475 - if (IS_ERR(data)) {
15476 - ret = PTR_ERR(data);
15477 - break;
15478 - }
15479 -
15480 - /* Handle data */
15481 - if (ffs->state == FFS_READ_DESCRIPTORS) {
15482 - pr_info("read descriptors\n");
15483 - ret = __ffs_data_got_descs(ffs, data, len);
15484 - if (unlikely(ret < 0))
15485 - break;
15486 -
15487 - ffs->state = FFS_READ_STRINGS;
15488 - ret = len;
15489 - } else {
15490 - pr_info("read strings\n");
15491 - ret = __ffs_data_got_strings(ffs, data, len);
15492 - if (unlikely(ret < 0))
15493 - break;
15494 -
15495 - ret = ffs_epfiles_create(ffs);
15496 - if (unlikely(ret)) {
15497 - ffs->state = FFS_CLOSING;
15498 - break;
15499 - }
15500 -
15501 - ffs->state = FFS_ACTIVE;
15502 - mutex_unlock(&ffs->mutex);
15503 -
15504 - ret = ffs_ready(ffs);
15505 - if (unlikely(ret < 0)) {
15506 - ffs->state = FFS_CLOSING;
15507 - return ret;
15508 - }
15509 -
15510 - return len;
15511 - }
15512 - break;
15513 -
15514 - case FFS_ACTIVE:
15515 - data = NULL;
15516 - /*
15517 - * We're called from user space, we can use _irq
15518 - * rather then _irqsave
15519 - */
15520 - spin_lock_irq(&ffs->ev.waitq.lock);
15521 - switch (ffs_setup_state_clear_cancelled(ffs)) {
15522 - case FFS_SETUP_CANCELLED:
15523 - ret = -EIDRM;
15524 - goto done_spin;
15525 -
15526 - case FFS_NO_SETUP:
15527 - ret = -ESRCH;
15528 - goto done_spin;
15529 -
15530 - case FFS_SETUP_PENDING:
15531 - break;
15532 - }
15533 -
15534 - /* FFS_SETUP_PENDING */
15535 - if (!(ffs->ev.setup.bRequestType & USB_DIR_IN)) {
15536 - spin_unlock_irq(&ffs->ev.waitq.lock);
15537 - ret = __ffs_ep0_stall(ffs);
15538 - break;
15539 - }
15540 -
15541 - /* FFS_SETUP_PENDING and not stall */
15542 - len = min(len, (size_t)le16_to_cpu(ffs->ev.setup.wLength));
15543 -
15544 - spin_unlock_irq(&ffs->ev.waitq.lock);
15545 -
15546 - data = ffs_prepare_buffer(buf, len);
15547 - if (IS_ERR(data)) {
15548 - ret = PTR_ERR(data);
15549 - break;
15550 - }
15551 -
15552 - spin_lock_irq(&ffs->ev.waitq.lock);
15553 -
15554 - /*
15555 - * We are guaranteed to be still in FFS_ACTIVE state
15556 - * but the state of setup could have changed from
15557 - * FFS_SETUP_PENDING to FFS_SETUP_CANCELLED so we need
15558 - * to check for that. If that happened we copied data
15559 - * from user space in vain but it's unlikely.
15560 - *
15561 - * For sure we are not in FFS_NO_SETUP since this is
15562 - * the only place FFS_SETUP_PENDING -> FFS_NO_SETUP
15563 - * transition can be performed and it's protected by
15564 - * mutex.
15565 - */
15566 - if (ffs_setup_state_clear_cancelled(ffs) ==
15567 - FFS_SETUP_CANCELLED) {
15568 - ret = -EIDRM;
15569 -done_spin:
15570 - spin_unlock_irq(&ffs->ev.waitq.lock);
15571 - } else {
15572 - /* unlocks spinlock */
15573 - ret = __ffs_ep0_queue_wait(ffs, data, len);
15574 - }
15575 - kfree(data);
15576 - break;
15577 -
15578 - default:
15579 - ret = -EBADFD;
15580 - break;
15581 - }
15582 -
15583 - mutex_unlock(&ffs->mutex);
15584 - return ret;
15585 -}
15586 -
15587 -/* Called with ffs->ev.waitq.lock and ffs->mutex held, both released on exit. */
15588 -static ssize_t __ffs_ep0_read_events(struct ffs_data *ffs, char __user *buf, size_t n)
15589 - __releases(&ffs->ev.waitq.lock)
15590 -{
15591 - /*
15592 - * n cannot be bigger than ffs->ev.count, which cannot be bigger than
15593 - * size of ffs->ev.types array (which is four) so that's how much space
15594 - * we reserve.
15595 - */
15596 - struct usb_functionfs_event events[ARRAY_SIZE(ffs->ev.types)];
15597 - const size_t size = n * sizeof *events;
15598 - unsigned i = 0;
15599 -
15600 - memset(events, 0, size);
15601 -
15602 - do {
15603 - events[i].type = ffs->ev.types[i];
15604 - if (events[i].type == FUNCTIONFS_SETUP) {
15605 - events[i].u.setup = ffs->ev.setup;
15606 - ffs->setup_state = FFS_SETUP_PENDING;
15607 - }
15608 - } while (++i < n);
15609 -
15610 - ffs->ev.count -= n;
15611 - if (ffs->ev.count)
15612 - memmove(ffs->ev.types, ffs->ev.types + n, ffs->ev.count * sizeof *ffs->ev.types);
15613 -
15614 - spin_unlock_irq(&ffs->ev.waitq.lock);
15615 - mutex_unlock(&ffs->mutex);
15616 -
15617 - return unlikely(copy_to_user(buf, events, size)) ? -EFAULT : size;
15618 -}
15619 -
15620 -static ssize_t ffs_ep0_read(struct file *file, char __user *buf, size_t len, loff_t *ptr)
15621 -{
15622 - struct ffs_data *ffs = file->private_data;
15623 - char *data = NULL;
15624 - size_t n;
15625 - int ret;
15626 -
15627 - ENTER();
15628 -
15629 - /* Fast check if setup was canceled */
15630 - if (ffs_setup_state_clear_cancelled(ffs) == FFS_SETUP_CANCELLED)
15631 - return -EIDRM;
15632 -
15633 - /* Acquire mutex */
15634 - ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
15635 - if (unlikely(ret < 0))
15636 - return ret;
15637 -
15638 - /* Check state */
15639 - if (ffs->state != FFS_ACTIVE) {
15640 - ret = -EBADFD;
15641 - goto done_mutex;
15642 - }
15643 -
15644 - /*
15645 - * We're called from user space, we can use _irq rather then
15646 - * _irqsave
15647 - */
15648 - spin_lock_irq(&ffs->ev.waitq.lock);
15649 -
15650 - switch (ffs_setup_state_clear_cancelled(ffs)) {
15651 - case FFS_SETUP_CANCELLED:
15652 - ret = -EIDRM;
15653 - break;
15654 -
15655 - case FFS_NO_SETUP:
15656 - n = len / sizeof(struct usb_functionfs_event);
15657 - if (unlikely(!n)) {
15658 - ret = -EINVAL;
15659 - break;
15660 - }
15661 -
15662 - if ((file->f_flags & O_NONBLOCK) && !ffs->ev.count) {
15663 - ret = -EAGAIN;
15664 - break;
15665 - }
15666 -
15667 - if (wait_event_interruptible_exclusive_locked_irq(ffs->ev.waitq,
15668 - ffs->ev.count)) {
15669 - ret = -EINTR;
15670 - break;
15671 - }
15672 -
15673 - /* unlocks spinlock */
15674 - return __ffs_ep0_read_events(ffs, buf,
15675 - min(n, (size_t)ffs->ev.count));
15676 -
15677 - case FFS_SETUP_PENDING:
15678 - if (ffs->ev.setup.bRequestType & USB_DIR_IN) {
15679 - spin_unlock_irq(&ffs->ev.waitq.lock);
15680 - ret = __ffs_ep0_stall(ffs);
15681 - goto done_mutex;
15682 - }
15683 -
15684 - len = min(len, (size_t)le16_to_cpu(ffs->ev.setup.wLength));
15685 -
15686 - spin_unlock_irq(&ffs->ev.waitq.lock);
15687 -
15688 - if (likely(len)) {
15689 - data = kmalloc(len, GFP_KERNEL);
15690 - if (unlikely(!data)) {
15691 - ret = -ENOMEM;
15692 - goto done_mutex;
15693 - }
15694 - }
15695 -
15696 - spin_lock_irq(&ffs->ev.waitq.lock);
15697 -
15698 - /* See ffs_ep0_write() */
15699 - if (ffs_setup_state_clear_cancelled(ffs) ==
15700 - FFS_SETUP_CANCELLED) {
15701 - ret = -EIDRM;
15702 - break;
15703 - }
15704 -
15705 - /* unlocks spinlock */
15706 - ret = __ffs_ep0_queue_wait(ffs, data, len);
15707 - if (likely(ret > 0) && unlikely(copy_to_user(buf, data, len)))
15708 - ret = -EFAULT;
15709 - goto done_mutex;
15710 -
15711 - default:
15712 - ret = -EBADFD;
15713 - break;
15714 - }
15715 -
15716 - spin_unlock_irq(&ffs->ev.waitq.lock);
15717 -done_mutex:
15718 - mutex_unlock(&ffs->mutex);
15719 - kfree(data);
15720 - return ret;
15721 -}
15722 -
15723 -static int ffs_ep0_open(struct inode *inode, struct file *file)
15724 -{
15725 - struct ffs_data *ffs = container_of(inode->i_cdev, struct ffs_data, cdev);
15726 - ENTER();
15727 -
15728 - if (unlikely(ffs->state == FFS_CLOSING))
15729 - return -EBUSY;
15730 -
15731 - file->private_data = ffs;
15732 - return 0;
15733 -}
15734 -
15735 -static int ffs_ep0_release(struct inode *inode, struct file *file)
15736 -{
15737 - ENTER();
15738 - return 0;
15739 -}
15740 -
15741 -static ssize_t ffs_ep0_iorw(struct file *file, struct ffs_io_data *io_data)
15742 -{
15743 - struct ffs_data *ffs = file->private_data;
15744 - struct usb_request *req = NULL;
15745 - ssize_t ret, data_len = io_data->len;
15746 - bool interrupted = false;
15747 - struct ffs_memory *ffsm = NULL;
15748 -
15749 - /* Are we still active? */
15750 - if (WARN_ON(ffs->state != FFS_ACTIVE))
15751 - return -ENODEV;
15752 - ffsm = generic_find_ep0_memory_area(ffs, io_data->buf, data_len);
15753 - if (ffsm == NULL)
15754 - {
15755 - return -ENODEV;
15756 - }
15757 - if (!io_data->aio) {
15758 - reinit_completion(&ffs->ep0req_completion);
15759 -
15760 - req = ffs->ep0req;
15761 - req->buf = (void *)(ffsm->mem + io_data->buf - ffsm->vm_start);
15762 - req->length = data_len;
15763 - req->complete = ffs_ep0_complete;
15764 -
15765 - ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
15766 - if (unlikely(ret < 0))
15767 - goto error;
15768 -
15769 - if (io_data->timeout > 0) {
15770 - ret = wait_for_completion_interruptible_timeout(&ffs->ep0req_completion, io_data->time…
15771 - if (ret < 0) {
15772 - /*
15773 - * To avoid race condition with ffs_epfile_io_complete,
15774 - * dequeue the request first then check
15775 - * status. usb_ep_dequeue API should guarantee no race
15776 - * condition with req->complete callback.
15777 - */
15778 - usb_ep_dequeue(ffs->gadget->ep0, req);
15779 - wait_for_completion(&ffs->ep0req_completion);
15780 - interrupted = req->status < 0;
15781 - } else if (ret == 0) {
15782 - ret = -EBUSY;
15783 - usb_ep_dequeue(ffs->gadget->ep0, req);
15784 - wait_for_completion(&ffs->ep0req_completion);
15785 - goto error;
15786 - }
15787 - } else {
15788 - ret = wait_for_completion_interruptible(&ffs->ep0req_completion);
15789 - if (ret < 0) {
15790 - usb_ep_dequeue(ffs->gadget->ep0, req);
15791 - wait_for_completion(&ffs->ep0req_completion);
15792 - interrupted = req->status < 0;
15793 - }
15794 - }
15795 -
15796 - if (interrupted) {
15797 - ret = -EINTR;
15798 - } else {
15799 - ret = req->actual;
15800 - }
15801 - goto error;
15802 - }
15803 - else if (!(req = usb_ep_alloc_request(ffs->gadget->ep0, GFP_ATOMIC))) {
15804 - ret = -ENOMEM;
15805 - }
15806 - else {
15807 - req->buf = (void *)(ffsm->mem + io_data->buf - ffsm->vm_start);
15808 - req->length = data_len;
15809 -
15810 - io_data->ep = ffs->gadget->ep0;
15811 - io_data->req = req;
15812 - io_data->ffs = ffs;
15813 -
15814 - req->context = io_data;
15815 - req->complete = ffs_ep0_async_io_complete;
15816 - list_add(&req->list, &ffs->ep0req->list);
15817 - ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
15818 - if (unlikely(ret)) {
15819 - usb_ep_free_request(ffs->gadget->ep0, req);
15820 - goto error;
15821 - }
15822 -
15823 - ret = -EIOCBQUEUED;
15824 - }
15825 -
15826 -error:
15827 - return ret;
15828 -}
15829 -
15830 -static long ffs_ep0_ioctl(struct file *file, unsigned code, unsigned long value)
15831 -{
15832 - struct ffs_data *ffs = file->private_data;
15833 - long ret = 0;
15834 - unsigned int copied = 0;
15835 - struct ffs_memory *ffsm = NULL;
15836 - struct generic_memory mem;
15837 -
15838 - ENTER();
15839 -
15840 - switch (code) {
15841 - case FUNCTIONFS_ENDPOINT_QUEUE_INIT:
15842 - ret = kfifo_alloc(&ffs->reqEventFifo, MAX_REQUEST * sizeof(struct UsbFnReqEvent), GFP_KERN…
15843 - break;
15844 - case FUNCTIONFS_ENDPOINT_QUEUE_DEL:
15845 - kfifo_free(&ffs->reqEventFifo);
15846 - break;
15847 - case FUNCTIONFS_ENDPOINT_RELEASE_BUF:
15848 - if (copy_from_user(&mem, (void __user *)value, sizeof(mem)))
15849 - {
15850 - pr_info("copy from user failed\n");
15851 - return -EFAULT;
15852 - }
15853 - ffsm = generic_find_ep0_memory_area(ffs, mem.buf, mem.size);
15854 - if (ffsm == NULL)
15855 - {
15856 - return -EFAULT;
15857 - }
15858 - list_del(&ffsm->memlist);
15859 - kfree((void *)ffsm->mem);
15860 - kfree(ffsm);
15861 - break;
15862 - case FUNCTIONFS_ENDPOINT_READ:
15863 - case FUNCTIONFS_ENDPOINT_WRITE:
15864 - {
15865 - struct IoData myIoData;
15866 - struct ffs_io_data io_data, *p = &io_data;
15867 - ret = copy_from_user(&myIoData, (void __user *)value, sizeof(struct IoData));
15868 - if (unlikely(ret)) {
15869 - return -EFAULT;
15870 - }
15871 - if (myIoData.aio) {
15872 - p = kmalloc(sizeof(io_data), GFP_KERNEL);
15873 - if (unlikely(!p))
15874 - return -ENOMEM;
15875 - } else {
15876 - memset(p, 0, sizeof(*p));
15877 - }
15878 - memcpy(p, &myIoData, sizeof(struct IoData));
15879 -
15880 - ret = ffs_ep0_iorw(file, p);
15881 - if (ret == -EIOCBQUEUED) {
15882 - return 0;
15883 - }
15884 - if (p->aio)
15885 - kfree(p);
15886 - return ret;
15887 - }
15888 - case FUNCTIONFS_ENDPOINT_RW_CANCEL:
15889 - {
15890 - struct usb_request *req;
15891 - struct IoData myIoData;
15892 - ret = copy_from_user(&myIoData, (void __user *)value, sizeof(struct IoData));
15893 - if (unlikely(ret)) {
15894 - return -EFAULT;
15895 - }
15896 - ffsm = generic_find_ep0_memory_area(ffs, myIoData.buf, myIoData.len);
15897 - if (ffsm == NULL)
15898 - {
15899 - return -EFAULT;
15900 - }
15901 - list_for_each_entry(req, &ffs->ep0req->list, list) {
15902 - if (req->buf == (void *)(ffsm->mem + myIoData.buf - ffsm->vm_start)) {
15903 - usb_ep_dequeue(ffs->gadget->ep0, req);
15904 - return 0;
15905 - }
15906 - }
15907 - return -EFAULT;
15908 - }
15909 - case FUNCTIONFS_ENDPOINT_GET_REQ_STATUS:
15910 - {
15911 - struct usb_request *req;
15912 - struct IoData myIoData;
15913 - ret = copy_from_user(&myIoData, (void __user *)value, sizeof(struct IoData));
15914 - if (unlikely(ret)) {
15915 - return -EFAULT;
15916 - }
15917 - ffsm = generic_find_ep0_memory_area(ffs, myIoData.buf, myIoData.len);
15918 - if (ffsm == NULL)
15919 - {
15920 - return -EFAULT;
15921 - }
15922 - list_for_each_entry(req, &ffs->ep0req->list, list) {
15923 - if (req->buf == (void *)(ffsm->mem + myIoData.buf - ffsm->vm_start)) {
15924 - return req->status;
15925 - }
15926 - }
15927 - return -EFAULT;
15928 - }
15929 - case FUNCTIONFS_ENDPOINT_GET_EP0_EVENT:
15930 - if (!kfifo_is_empty(&ffs->reqEventFifo)) {
15931 - ret = kfifo_to_user(&ffs->reqEventFifo, (void __user *)value,
15932 - sizeof(struct UsbFnReqEvent), &copied) == 0 ? copied : -1;
15933 - if (ret > 0) {
15934 - ffs->setup_state = FFS_NO_SETUP;
15935 - return ret;
15936 - }
15937 - }
15938 -
15939 - return -EFAULT;
15940 - }
15941 -
15942 - return ret;
15943 -}
15944 -
15945 -#ifdef CONFIG_COMPAT
15946 -static long ffs_ep0_compat_ioctl(struct file *file, unsigned code,
15947 - unsigned long value)
15948 -{
15949 - return ffs_ep0_ioctl(file, code, value);
15950 -}
15951 -#endif
15952 -
15953 -static __poll_t ffs_ep0_poll(struct file *file, poll_table *wait)
15954 -{
15955 - struct ffs_data *ffs = file->private_data;
15956 - __poll_t mask = EPOLLWRNORM;
15957 - int ret;
15958 -
15959 - ret = ffs_mutex_lock(&ffs->mutex, file->f_flags & O_NONBLOCK);
15960 - if (unlikely(ret < 0))
15961 - return mask;
15962 -
15963 - switch (ffs->state) {
15964 - case FFS_READ_DESCRIPTORS:
15965 - case FFS_READ_STRINGS:
15966 - mask |= EPOLLOUT;
15967 - break;
15968 -
15969 - case FFS_ACTIVE:
15970 - switch (ffs->setup_state) {
15971 - case FFS_NO_SETUP:
15972 - poll_wait(file, &ffs->ev.waitq, wait);
15973 - if (ffs->ev.count)
15974 - mask |= EPOLLIN;
15975 - break;
15976 -
15977 - case FFS_SETUP_PENDING:
15978 - case FFS_SETUP_CANCELLED:
15979 - poll_wait(file, &ffs->wait_que, wait);
15980 - if (!kfifo_is_empty(&ffs->reqEventFifo))
15981 - {
15982 - mask |= EPOLLOUT;
15983 - }
15984 - break;
15985 - }
15986 - case FFS_CLOSING:
15987 - break;
15988 - case FFS_DEACTIVATED:
15989 - break;
15990 - }
15991 -
15992 - mutex_unlock(&ffs->mutex);
15993 -
15994 - return mask;
15995 -}
15996 -
15997 -static int ffs_ep0_mmap(struct file *file, struct vm_area_struct *vma)
15998 -{
15999 - struct ffs_data *ffs = file->private_data;
16000 - size_t size = vma->vm_end - vma->vm_start;
16001 - unsigned long flags;
16002 - struct ffs_memory *ffsm = NULL;
16003 - void *virt_mem = NULL;
16004 -
16005 - if (ffs == NULL) {
16006 - pr_info("Invalid private parameter!\n");
16007 - return -EINVAL;
16008 - }
16009 - virt_mem = kmalloc(size, GFP_KERNEL);
16010 - if (virt_mem == NULL)
16011 - {
16012 - pr_info("%s alloc memory failed!\n", __FUNCTION__);
16013 - return -ENOMEM;
16014 - }
16015 - ffsm = kmalloc(sizeof(struct ffs_memory), GFP_KERNEL);
16016 - if (ffsm == NULL)
16017 - {
16018 - pr_info("%s alloc memory failed!\n", __FUNCTION__);
16019 - goto error_free_mem;
16020 - }
16021 - if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(virt_mem)>>PAGE_SHIFT,
16022 - vma->vm_end - vma->vm_start, vma->vm_page_prot)) {
16023 - goto error_free_ffsm;
16024 - }
16025 - ffsm->mem = (uint64_t)virt_mem;
16026 - ffsm->size = size;
16027 - ffsm->vm_start = vma->vm_start;
16028 - INIT_LIST_HEAD(&ffsm->memlist);
16029 - spin_lock_irqsave(&ffs->mem_lock, flags);
16030 - list_add_tail(&ffsm->memlist, &ffs->memory_list);
16031 - spin_unlock_irqrestore(&ffs->mem_lock, flags);
16032 - return 0;
16033 -error_free_ffsm:
16034 - kfree(ffsm);
16035 -error_free_mem:
16036 - kfree(virt_mem);
16037 - return -1;
16038 -}
16039 -
16040 -static const struct file_operations ffs_ep0_operations = {
16041 - .owner = THIS_MODULE,
16042 - .llseek = no_llseek,
16043 - .open = ffs_ep0_open,
16044 - .write = ffs_ep0_write,
16045 - .read = ffs_ep0_read,
16046 - .release = ffs_ep0_release,
16047 - .unlocked_ioctl = ffs_ep0_ioctl,
16048 -#ifdef CONFIG_COMPAT
16049 - .compat_ioctl = ffs_ep0_compat_ioctl,
16050 -#endif
16051 - .poll = ffs_ep0_poll,
16052 - .mmap = ffs_ep0_mmap,
16053 -};
16054 -
16055 -/* "Normal" endpoints operations ********************************************/
16056 -static struct ffs_memory *generic_find_memory_area(struct ffs_epfile *epfile, uint64_t buf, uint32…
16057 -{
16058 - struct ffs_memory *ffsm = NULL, *iter = NULL;
16059 - uint64_t buf_start = buf;
16060 -
16061 - list_for_each_entry(iter, &epfile->memory_list, memlist) {
16062 - if (buf_start >= iter->vm_start &&
16063 - buf_start < iter->vm_start + iter->size) {
16064 - if (len <= iter->vm_start + iter->size - buf_start) {
16065 - ffsm = iter;
16066 - break;
16067 - }
16068 - }
16069 - }
16070 - return ffsm;
16071 -}
16072 -
16073 -static void ffs_epfile_io_complete(struct usb_ep *_ep, struct usb_request *req)
16074 -{
16075 - ENTER();
16076 - if (likely(req->context)) {
16077 - struct ffs_ep *ep = _ep->driver_data;
16078 - ep->status = req->status ? req->status : req->actual;
16079 - complete(req->context);
16080 - }
16081 -}
16082 -
16083 -static void epfile_task_proc(unsigned long context)
16084 -{
16085 - struct ffs_io_data *io_data = (struct ffs_io_data *)context;
16086 - struct ffs_epfile *epfile = io_data->epfile;
16087 - unsigned long flags;
16088 -
16089 - spin_lock_irqsave(&epfile->ffs->eps_lock, flags);
16090 - io_data->status = io_data->req->status;
16091 - io_data->actual = io_data->req->actual;
16092 - kfifo_in(&epfile->reqEventFifo, &io_data->buf, sizeof(struct UsbFnReqEvent));
16093 - list_del(&io_data->req->list);
16094 - usb_ep_free_request(io_data->ep, io_data->req);
16095 - kfree(io_data);
16096 - spin_unlock_irqrestore(&epfile->ffs->eps_lock, flags);
16097 - wake_up_all(&epfile->wait_que);
16098 -}
16099 -
16100 -static void ffs_epfile_async_io_complete(struct usb_ep *_ep, struct usb_request *req)
16101 -{
16102 - struct ffs_io_data *io_data = req->context;
16103 -
16104 - tasklet_init(&io_data->task, epfile_task_proc, (uintptr_t)io_data);
16105 - tasklet_schedule(&io_data->task);
16106 -
16107 -}
16108 -
16109 -static int ffs_epfile_open(struct inode *inode, struct file *file)
16110 -{
16111 - struct ffs_epfile *epfile = container_of(inode->i_cdev, struct ffs_epfile, cdev);
16112 - ENTER();
16113 - if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))
16114 - return -ENODEV;
16115 -
16116 - file->private_data = epfile;
16117 - return 0;
16118 -}
16119 -
16120 -static int ffs_epfile_release(struct inode *inode, struct file *file)
16121 -{
16122 - ENTER();
16123 - return 0;
16124 -}
16125 -
16126 -static int ffs_epfile_mmap(struct file *file, struct vm_area_struct *vma)
16127 -{
16128 - struct ffs_epfile *epfile = file->private_data;
16129 - size_t size = vma->vm_end - vma->vm_start;
16130 - struct ffs_memory *ffsm = NULL;
16131 - unsigned long flags;
16132 - void *virt_mem = NULL;
16133 -
16134 - if (epfile == NULL)
16135 - {
16136 - pr_info("Invalid private parameter!\n");
16137 - return -EINVAL;
16138 - }
16139 - virt_mem = kmalloc(size, GFP_KERNEL);
16140 - if (virt_mem == NULL)
16141 - {
16142 - pr_info("%s alloc memory failed!\n", __FUNCTION__);
16143 - return -ENOMEM;
16144 - }
16145 - ffsm = kmalloc(sizeof(struct ffs_memory), GFP_KERNEL);
16146 - if (ffsm == NULL)
16147 - {
16148 - pr_info("%s alloc memory failed!\n", __FUNCTION__);
16149 - goto error_free_mem;
16150 - }
16151 - if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(virt_mem)>>PAGE_SHIFT,
16152 - vma->vm_end - vma->vm_start, vma->vm_page_prot))
16153 - {
16154 - goto error_free_ffsm;
16155 - }
16156 - ffsm->mem = (uint64_t)virt_mem;
16157 - ffsm->size = size;
16158 - ffsm->vm_start = vma->vm_start;
16159 - INIT_LIST_HEAD(&ffsm->memlist);
16160 - spin_lock_irqsave(&epfile->ffs->eps_lock, flags);
16161 - list_add_tail(&ffsm->memlist, &epfile->memory_list);
16162 - spin_unlock_irqrestore(&epfile->ffs->eps_lock, flags);
16163 -
16164 - return 0;
16165 -error_free_ffsm:
16166 - kfree(ffsm);
16167 -error_free_mem:
16168 - kfree(virt_mem);
16169 -
16170 - return -1;
16171 -}
16172 -
16173 -static ssize_t ffs_epfile_iorw(struct file *file, struct ffs_io_data *io_data)
16174 -{
16175 - struct ffs_epfile *epfile = file->private_data;
16176 - struct usb_request *req = NULL;
16177 - struct ffs_ep *ep = NULL;
16178 - struct ffs_memory *ffsm = NULL;
16179 - ssize_t ret, data_len = -EINVAL;
16180 - int halt;
16181 -
16182 - /* Are we still active? */
16183 - if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))
16184 - return -ENODEV;
16185 -
16186 - /* Wait for endpoint to be enabled */
16187 - ep = epfile->ep;
16188 - if (!ep) {
16189 - if (file->f_flags & O_NONBLOCK)
16190 - return -EAGAIN;
16191 -
16192 - ret = wait_event_interruptible(
16193 - epfile->ffs->wait, (ep = epfile->ep));
16194 - if (ret)
16195 - return -EINTR;
16196 - }
16197 -
16198 - /* Do we halt? */
16199 - halt = (!io_data->read == !epfile->in);
16200 - if (halt && epfile->isoc)
16201 - return -EINVAL;
16202 -
16203 - /* We will be using request and read_buffer */
16204 - ret = ffs_mutex_lock(&epfile->mutex, file->f_flags & O_NONBLOCK);
16205 - if (unlikely(ret))
16206 - goto error;
16207 -
16208 - /* Allocate & copy */
16209 - if (!halt) {
16210 - struct usb_gadget *gadget;
16211 - /*
16212 - * if we _do_ wait above, the epfile->ffs->gadget might be NULL
16213 - * before the waiting completes, so do not assign to 'gadget'
16214 - * earlier
16215 - */
16216 - gadget = epfile->ffs->gadget;
16217 -
16218 - spin_lock_irq(&epfile->ffs->eps_lock);
16219 - /* In the meantime, endpoint got disabled or changed. */
16220 - if (epfile->ep != ep) {
16221 - ret = -ESHUTDOWN;
16222 - goto error_lock;
16223 - }
16224 - data_len = io_data->len;
16225 - /*
16226 - * Controller may require buffer size to be aligned to
16227 - * maxpacketsize of an out endpoint.
16228 - */
16229 - if (io_data->read)
16230 - data_len = usb_ep_align_maybe(gadget, ep->ep, data_len);
16231 - spin_unlock_irq(&epfile->ffs->eps_lock);
16232 - }
16233 -
16234 - spin_lock_irq(&epfile->ffs->eps_lock);
16235 - ffsm = generic_find_memory_area(epfile, io_data->buf, io_data->len);
16236 - if (ffsm == NULL)
16237 - {
16238 - return -EFAULT;
16239 - }
16240 - if (epfile->ep != ep) {
16241 - /* In the meantime, endpoint got disabled or changed. */
16242 - ret = -ESHUTDOWN;
16243 - }
16244 - else if (halt) {
16245 - ret = usb_ep_set_halt(ep->ep);
16246 - if (!ret)
16247 - ret = -EBADMSG;
16248 - }
16249 - else if (!io_data->aio) {
16250 - DECLARE_COMPLETION_ONSTACK(done);
16251 - bool interrupted = false;
16252 -
16253 - req = ep->req;
16254 - req->buf = (void *)(ffsm->mem + io_data->buf - ffsm->vm_start);
16255 - req->length = data_len;
16256 -
16257 - req->context = &done;
16258 - req->complete = ffs_epfile_io_complete;
16259 -
16260 - ret = usb_ep_queue(ep->ep, req, GFP_ATOMIC);
16261 - if (unlikely(ret < 0))
16262 - goto error_lock;
16263 -
16264 - spin_unlock_irq(&epfile->ffs->eps_lock);
16265 - if (io_data->timeout > 0) {
16266 - ret = wait_for_completion_interruptible_timeout(&done, io_data->timeout);
16267 - if (ret < 0) {
16268 - /*
16269 - * To avoid race condition with ffs_epfile_io_complete,
16270 - * dequeue the request first then check
16271 - * status. usb_ep_dequeue API should guarantee no race
16272 - * condition with req->complete callback.
16273 - */
16274 - usb_ep_dequeue(ep->ep, req);
16275 - wait_for_completion(&done);
16276 - interrupted = ep->status < 0;
16277 - } else if (ret == 0) {
16278 - ret = -EBUSY;
16279 - usb_ep_dequeue(ep->ep, req);
16280 - wait_for_completion(&done);
16281 - goto error_mutex;
16282 - }
16283 - } else {
16284 - ret = wait_for_completion_interruptible(&done);
16285 - if (ret < 0) {
16286 - usb_ep_dequeue(ep->ep, req);
16287 - wait_for_completion(&done);
16288 - interrupted = ep->status < 0;
16289 - }
16290 - }
16291 -
16292 - if (interrupted) {
16293 - ret = -EINTR;
16294 - } else {
16295 - ret = req->actual;
16296 - }
16297 - goto error_mutex;
16298 - }
16299 - else if (!(req = usb_ep_alloc_request(ep->ep, GFP_ATOMIC))) {
16300 - ret = -ENOMEM;
16301 - }
16302 - else {
16303 - req->buf = (void *)(ffsm->mem + io_data->buf - ffsm->vm_start);
16304 - req->length = data_len;
16305 -
16306 - io_data->ep = ep->ep;
16307 - io_data->req = req;
16308 - io_data->epfile = epfile;
16309 -
16310 - req->context = io_data;
16311 - req->complete = ffs_epfile_async_io_complete;
16312 - list_add(&req->list, &ep->req->list);
16313 - ret = usb_ep_queue(ep->ep, req, GFP_ATOMIC);
16314 - if (unlikely(ret)) {
16315 - usb_ep_free_request(ep->ep, req);
16316 - goto error_lock;
16317 - }
16318 -
16319 - ret = -EIOCBQUEUED;
16320 - }
16321 -
16322 -error_lock:
16323 - spin_unlock_irq(&epfile->ffs->eps_lock);
16324 -error_mutex:
16325 - mutex_unlock(&epfile->mutex);
16326 -error:
16327 - return ret;
16328 -}
16329 -
16330 -static long ffs_epfile_ioctl(struct file *file, unsigned code, unsigned long value)
16331 -{
16332 - struct ffs_epfile *epfile = file->private_data;
16333 - struct ffs_ep *ep = epfile->ep;
16334 - int ret = 0;
16335 - struct generic_memory mem;
16336 - struct ffs_memory *ffsm = NULL;
16337 -
16338 - ENTER();
16339 -
16340 - if (WARN_ON(epfile->ffs->state != FFS_ACTIVE))
16341 - return -ENODEV;
16342 -
16343 - spin_lock_irq(&epfile->ffs->eps_lock);
16344 -
16345 - switch (code) {
16346 - case FUNCTIONFS_ENDPOINT_QUEUE_INIT:
16347 - ret = kfifo_alloc(&epfile->reqEventFifo, MAX_REQUEST * sizeof(struct UsbFnReqEvent), GFP_K…
16348 - break;
16349 - case FUNCTIONFS_ENDPOINT_QUEUE_DEL:
16350 - kfifo_free(&epfile->reqEventFifo);
16351 - break;
16352 - case FUNCTIONFS_ENDPOINT_RELEASE_BUF:
16353 - if (copy_from_user(&mem, (void __user *)value, sizeof(mem)))
16354 - {
16355 - pr_info("copy from user failed\n");
16356 - return -EFAULT;
16357 - }
16358 - ffsm = generic_find_memory_area(epfile, mem.buf, mem.size);
16359 - if (ffsm == NULL)
16360 - {
16361 - return -EFAULT;
16362 - }
16363 - list_del(&ffsm->memlist);
16364 - kfree((void *)ffsm->mem);
16365 - kfree(ffsm);
16366 - break;
16367 - case FUNCTIONFS_ENDPOINT_READ:
16368 - case FUNCTIONFS_ENDPOINT_WRITE:
16369 - {
16370 - struct IoData myIoData;
16371 - struct ffs_io_data io_data, *p = &io_data;
16372 - ret = copy_from_user(&myIoData, (void __user *)value, sizeof(struct IoData));
16373 - if (unlikely(ret)) {
16374 - spin_unlock_irq(&epfile->ffs->eps_lock);
16375 - return -EFAULT;
16376 - }
16377 - if (myIoData.aio) {
16378 - p = kmalloc(sizeof(io_data), GFP_KERNEL);
16379 - if (unlikely(!p)) {
16380 - spin_unlock_irq(&epfile->ffs->eps_lock);
16381 - return -ENOMEM;
16382 - }
16383 - } else {
16384 - memset(p, 0, sizeof(*p));
16385 - }
16386 - memcpy(p, &myIoData, sizeof(struct IoData));
16387 -
16388 - spin_unlock_irq(&epfile->ffs->eps_lock);
16389 - ret = ffs_epfile_iorw(file, p);
16390 - if (ret == -EIOCBQUEUED) {
16391 - return 0;
16392 - }
16393 - if (p->aio)
16394 - kfree(p);
16395 - return ret;
16396 - }
16397 - case FUNCTIONFS_ENDPOINT_RW_CANCEL:
16398 - {
16399 - struct usb_request *req;
16400 - struct IoData myIoData;
16401 - if (!ep) {
16402 - spin_unlock_irq(&epfile->ffs->eps_lock);
16403 - return -EFAULT;
16404 - }
16405 - ret = copy_from_user(&myIoData, (void __user *)value, sizeof(struct IoData));
16406 - if (unlikely(ret)) {
16407 - spin_unlock_irq(&epfile->ffs->eps_lock);
16408 - return -EFAULT;
16409 - }
16410 - ffsm = generic_find_memory_area(epfile, myIoData.buf, myIoData.len);
16411 - if (ffsm == NULL)
16412 - {
16413 - return -EFAULT;
16414 - }
16415 - list_for_each_entry(req, &epfile->ep->req->list, list) {
16416 - if (req->buf == (void *)(ffsm->mem + myIoData.buf - ffsm->vm_start)) {
16417 - usb_ep_dequeue(epfile->ep->ep, req);
16418 - spin_unlock_irq(&epfile->ffs->eps_lock);
16419 - return 0;
16420 - }
16421 - }
16422 - spin_unlock_irq(&epfile->ffs->eps_lock);
16423 - return -EFAULT;
16424 - }
16425 - case FUNCTIONFS_ENDPOINT_GET_REQ_STATUS:
16426 - {
16427 - struct usb_request *req;
16428 - struct IoData myIoData;
16429 - if (!ep) {
16430 - spin_unlock_irq(&epfile->ffs->eps_lock);
16431 - return -EFAULT;
16432 - }
16433 - ret = copy_from_user(&myIoData,(void __user *)value, sizeof(struct IoData));
16434 - if (unlikely(ret)) {
16435 - spin_unlock_irq(&epfile->ffs->eps_lock);
16436 - return -EFAULT;
16437 - }
16438 - ffsm = generic_find_memory_area(epfile, myIoData.buf, myIoData.len);
16439 - if (ffsm == NULL)
16440 - {
16441 - return -EFAULT;
16442 - }
16443 - list_for_each_entry(req, &epfile->ep->req->list, list) {
16444 - if (req->buf == (void *)(ffsm->mem + myIoData.buf - ffsm->vm_start)) {
16445 - spin_unlock_irq(&epfile->ffs->eps_lock);
16446 - return req->status;
16447 - }
16448 - }
16449 - spin_unlock_irq(&epfile->ffs->eps_lock);
16450 - return -EFAULT;
16451 - }
16452 - case FUNCTIONFS_FIFO_STATUS:
16453 - ret = usb_ep_fifo_status(epfile->ep->ep);
16454 - break;
16455 - case FUNCTIONFS_FIFO_FLUSH:
16456 - usb_ep_fifo_flush(epfile->ep->ep);
16457 - ret = 0;
16458 - break;
16459 - case FUNCTIONFS_CLEAR_HALT:
16460 - ret = usb_ep_clear_halt(epfile->ep->ep);
16461 - break;
16462 - case FUNCTIONFS_ENDPOINT_REVMAP:
16463 - ret = epfile->ep->num;
16464 - break;
16465 - case FUNCTIONFS_ENDPOINT_DESC:
16466 - {
16467 - int desc_idx;
16468 - int i;
16469 - struct usb_endpoint_descriptor *desc;
16470 -
16471 - switch (epfile->ffs->speed) {
16472 - case USB_SPEED_SUPER:
16473 - desc_idx = 2;
16474 - break;
16475 - case USB_SPEED_HIGH:
16476 - desc_idx = 1;
16477 - break;
16478 - default:
16479 - desc_idx = 1;
16480 - }
16481 - for (i = 0; i < epfile->ffs->eps_count; i++) {
16482 - if (epfile->ffs->epfiles + i == epfile)
16483 - break;
16484 - }
16485 - ep = epfile->ffs->eps + i;
16486 - desc = ep->descs[desc_idx];
16487 - spin_unlock_irq(&epfile->ffs->eps_lock);
16488 - ret = copy_to_user((void __user *)value, desc, desc->bLength);
16489 - if (ret)
16490 - ret = -EFAULT;
16491 - return ret;
16492 - }
16493 - default:
16494 - ret = -ENOTTY;
16495 - }
16496 - spin_unlock_irq(&epfile->ffs->eps_lock);
16497 -
16498 - return ret;
16499 -}
16500 -
16501 -static ssize_t ffs_epfile_read(struct file *file, char __user *buf, size_t count, loff_t *f_pos)
16502 -{
16503 - int status = 0;
16504 - unsigned int copied = 0;
16505 - unsigned long flags;
16506 - struct ffs_epfile *epfile = file->private_data;
16507 - ENTER();
16508 - if (kfifo_is_empty(&epfile->reqEventFifo)) {
16509 - return 0;
16510 - }
16511 - spin_lock_irqsave(&epfile->ffs->eps_lock, flags);
16512 - status = kfifo_to_user(&epfile->reqEventFifo, buf, count, &copied) == 0 ? copied : -1;
16513 - spin_unlock_irqrestore(&epfile->ffs->eps_lock, flags);
16514 -
16515 - return status;
16516 -}
16517 -
16518 -static ssize_t ffs_epfile_write(struct file *file, const char __user *buf, size_t count, loff_t *f…
16519 -{
16520 - return count;
16521 -}
16522 -
16523 -static unsigned int ffs_epfile_poll(struct file *file, struct poll_table_struct * wait)
16524 -{
16525 - unsigned int mask = 0;
16526 - struct ffs_epfile *epfile = file->private_data;
16527 - ENTER();
16528 - poll_wait(file, &epfile->wait_que, wait);
16529 - if (!kfifo_is_empty(&epfile->reqEventFifo)) {
16530 - mask |= POLLIN;
16531 - }
16532 - return mask;
16533 -}
16534 -
16535 -#ifdef CONFIG_COMPAT
16536 -static long ffs_epfile_compat_ioctl(struct file *file, unsigned code,
16537 - unsigned long value)
16538 -{
16539 - return ffs_epfile_ioctl(file, code, value);
16540 -}
16541 -#endif
16542 -
16543 -static const struct file_operations ffs_epfile_operations = {
16544 - .owner = THIS_MODULE,
16545 - .llseek = no_llseek,
16546 - .mmap = ffs_epfile_mmap,
16547 - .read = ffs_epfile_read,
16548 - .write = ffs_epfile_write,
16549 - .poll = ffs_epfile_poll,
16550 - .open = ffs_epfile_open,
16551 - .release = ffs_epfile_release,
16552 - .unlocked_ioctl = ffs_epfile_ioctl,
16553 -#ifdef CONFIG_COMPAT
16554 - .compat_ioctl = ffs_epfile_compat_ioctl,
16555 -#endif
16556 -};
16557 -
16558 -/* ffs_data and ffs_function construction and destruction code **************/
16559 -static void ffs_data_clear(struct ffs_data *ffs);
16560 -static void ffs_data_reset(struct ffs_data *ffs);
16561 -static dev_t g_dev;
16562 -#define MAX_EP_DEV 10
16563 -static long usbfn_ioctl(struct file *file, unsigned int cmd, unsigned long value)
16564 -{
16565 - long ret;
16566 - ENTER();
16567 - switch(cmd)
16568 - {
16569 - case FUNCTIONFS_NEWFN:
16570 - {
16571 - struct ffs_dev *ffs_dev;
16572 - struct ffs_data *ffs;
16573 - struct FuncNew newfn;
16574 - char nameEp0[MAX_NAMELEN];
16575 - ret = copy_from_user(&newfn, (void __user *)value, sizeof(struct FuncNew ));
16576 - if (unlikely(ret)) {
16577 - return -EFAULT;
16578 - }
16579 - ffs = ffs_data_new(newfn.name);
16580 - if (unlikely(!ffs)) {
16581 - return (-ENOMEM);
16582 - }
16583 -
16584 - memcpy(ffs->dev_name, newfn.name, newfn.nameLen);
16585 -
16586 - if (unlikely(!ffs->dev_name)) {
16587 - ffs_data_put(ffs);
16588 - return (-ENOMEM);
16589 - }
16590 -
16591 - if (sprintf(nameEp0, "%s.ep%u", ffs->dev_name, 0) < 0) {
16592 - ffs_data_put(ffs);
16593 - return -EFAULT;
16594 - }
16595 - ffs_dev = ffs_acquire_dev(newfn.name);
16596 - if (IS_ERR(ffs_dev)) {
16597 - ffs_data_put(ffs);
16598 - return (-ENODEV);
16599 - }
16600 - ffs->private_data = ffs_dev;
16601 -
16602 - ret = alloc_chrdev_region(&g_dev, 0, MAX_EP_DEV, nameEp0);
16603 - if (ret < 0) {
16604 - ffs_release_dev(ffs);
16605 - ffs_data_put(ffs);
16606 - return -EBUSY;
16607 - }
16608 - cdev_init(&ffs->cdev, &ffs_ep0_operations);
16609 - ffs->devno = MKDEV(MAJOR(g_dev), 0);
16610 - ret = cdev_add(&ffs->cdev, ffs->devno, 1);
16611 - if (ret) {
16612 - ffs_release_dev(ffs);
16613 - ffs_data_put(ffs);
16614 - return -EBUSY;
16615 - }
16616 -
16617 - ffs->fn_device = device_create(ffs_class, NULL, ffs->devno, NULL, nameEp0);
16618 - if (IS_ERR(ffs->fn_device)) {
16619 - cdev_del(&ffs->cdev);
16620 - ffs_release_dev(ffs);
16621 - ffs_data_put(ffs);
16622 - return -EBUSY;
16623 - }
16624 - return 0;
16625 - }
16626 - case FUNCTIONFS_DELFN:
16627 - {
16628 - struct FuncNew newfn;
16629 - struct ffs_data *ffs;
16630 - struct ffs_dev *ffs_dev;
16631 - ret = copy_from_user(&newfn, (void __user *)value, sizeof(struct FuncNew ));
16632 - if (unlikely(ret)) {
16633 - return -EFAULT;
16634 - }
16635 -
16636 - ffs_dev = _ffs_find_dev(newfn.name);
16637 - if (IS_ERR(ffs_dev)) {
16638 - return -EFAULT;
16639 - }
16640 - ffs = ffs_dev->ffs_data;
16641 - device_destroy(ffs_class, ffs->devno);
16642 - cdev_del(&ffs->cdev);
16643 - unregister_chrdev_region(g_dev, MAX_EP_DEV);
16644 - ffs_release_dev(ffs);
16645 - ffs_data_clear(ffs);
16646 - destroy_workqueue(ffs->io_completion_wq);
16647 - kfree(ffs);
16648 - return 0;
16649 - }
16650 - default:
16651 - ret = -ENOTTY;
16652 - }
16653 -
16654 - return ret;
16655 -}
16656 -
16657 -static int usbfn_open(struct inode *inode, struct file *file)
16658 -{
16659 - return 0;
16660 -}
16661 -
16662 -static int usbfn_release(struct inode *inode, struct file *file)
16663 -{
16664 - return 0;
16665 -}
16666 -
16667 -static struct file_operations usbfn_fops = {
16668 - .owner = THIS_MODULE,
16669 - .unlocked_ioctl = usbfn_ioctl,
16670 - .open = usbfn_open,
16671 - .release = usbfn_release,
16672 -#ifdef CONFIG_COMPAT
16673 - .compat_ioctl = usbfn_ioctl,
16674 -#endif
16675 -};
16676 -
16677 -static struct miscdevice usbfn_misc = {
16678 - .minor = MISC_DYNAMIC_MINOR,
16679 - .name = "usbfn",
16680 - .fops = &usbfn_fops,
16681 -};
16682 -
16683 -/* Driver's main init/cleanup functions *************************************/
16684 -static int functionfs_init(void)
16685 -{
16686 - int ret;
16687 -
16688 - ENTER();
16689 - ret = misc_register(&usbfn_misc);
16690 - if (likely(!ret))
16691 - pr_info("file system registered\n");
16692 - else
16693 - pr_err("failed registering file system (%d)\n", ret);
16694 -
16695 - ffs_class = class_create(THIS_MODULE, "functionfs");
16696 - if (IS_ERR(ffs_class))
16697 - return PTR_ERR(ffs_class);
16698 -
16699 - ffs_class->devnode = ffs_devnode;
16700 -
16701 - return ret;
16702 -}
16703 -
16704 -static void functionfs_cleanup(void)
16705 -{
16706 - ENTER();
16707 - class_destroy(ffs_class);
16708 - misc_deregister(&usbfn_misc);
16709 -}
16710 -
16711 -static void ffs_data_get(struct ffs_data *ffs)
16712 -{
16713 - ENTER();
16714 - refcount_inc(&ffs->ref);
16715 -}
16716 -
16717 -static void ffs_data_put(struct ffs_data *ffs)
16718 -{
16719 - ENTER();
16720 - if (unlikely(refcount_dec_and_test(&ffs->ref))) {
16721 - pr_info("%s(): freeing\n", __func__);
16722 - ffs_data_clear(ffs);
16723 - BUG_ON(waitqueue_active(&ffs->ev.waitq) ||
16724 -#if LINUX_VERSION_CODE >= KERNEL_VERSION(5,0,0)
16725 - swait_active(&ffs->ep0req_completion.wait) ||
16726 -#else
16727 - waitqueue_active(&ffs->ep0req_completion.wait) ||
16728 -#endif
16729 - waitqueue_active(&ffs->wait) ||
16730 - waitqueue_active(&ffs->wait_que));
16731 - destroy_workqueue(ffs->io_completion_wq);
16732 - kfree(ffs);
16733 - }
16734 -}
16735 -
16736 -static struct ffs_data *ffs_data_new(const char *dev_name)
16737 -{
16738 - struct ffs_data *ffs = kzalloc(sizeof *ffs, GFP_KERNEL);
16739 - if (unlikely(!ffs))
16740 - return NULL;
16741 -
16742 - ENTER();
16743 -
16744 - ffs->io_completion_wq = alloc_ordered_workqueue("%s", 0, dev_name);
16745 - if (!ffs->io_completion_wq) {
16746 - kfree(ffs);
16747 - return NULL;
16748 - }
16749 -
16750 - refcount_set(&ffs->ref, 1);
16751 - atomic_set(&ffs->opened, 0);
16752 - ffs->state = FFS_READ_DESCRIPTORS;
16753 - mutex_init(&ffs->mutex);
16754 - spin_lock_init(&ffs->eps_lock);
16755 - spin_lock_init(&ffs->mem_lock);
16756 - init_waitqueue_head(&ffs->ev.waitq);
16757 - init_waitqueue_head(&ffs->wait);
16758 - init_waitqueue_head(&ffs->wait_que);
16759 - init_completion(&ffs->ep0req_completion);
16760 - INIT_LIST_HEAD(&ffs->memory_list);
16761 - ffs->ev.can_stall = 1;
16762 -
16763 - return ffs;
16764 -}
16765 -
16766 -static void ffs_data_clear(struct ffs_data *ffs)
16767 -{
16768 - ENTER();
16769 -
16770 - ffs_closed(ffs);
16771 -
16772 - BUG_ON(ffs->gadget);
16773 -
16774 - if (ffs->epfiles)
16775 - ffs_epfiles_destroy(ffs->epfiles, ffs->eps_count);
16776 -
16777 - if (ffs->ffs_eventfd)
16778 - eventfd_ctx_put(ffs->ffs_eventfd);
16779 -
16780 - kfree(ffs->raw_descs_data);
16781 - kfree(ffs->raw_strings);
16782 - kfree(ffs->stringtabs);
16783 -}
16784 -
16785 -static void ffs_data_reset(struct ffs_data *ffs)
16786 -{
16787 - ENTER();
16788 -
16789 - ffs_data_clear(ffs);
16790 -
16791 - ffs->epfiles = NULL;
16792 - ffs->raw_descs_data = NULL;
16793 - ffs->raw_descs = NULL;
16794 - ffs->raw_strings = NULL;
16795 - ffs->stringtabs = NULL;
16796 -
16797 - ffs->raw_descs_length = 0;
16798 - ffs->fs_descs_count = 0;
16799 - ffs->hs_descs_count = 0;
16800 - ffs->ss_descs_count = 0;
16801 -
16802 - ffs->strings_count = 0;
16803 - ffs->interfaces_count = 0;
16804 - ffs->eps_count = 0;
16805 -
16806 - ffs->ev.count = 0;
16807 -
16808 - ffs->state = FFS_READ_DESCRIPTORS;
16809 - ffs->setup_state = FFS_NO_SETUP;
16810 - ffs->flags = 0;
16811 -}
16812 -
16813 -static int functionfs_bind(struct ffs_data *ffs, struct usb_composite_dev *cdev)
16814 -{
16815 - struct usb_gadget_strings **lang;
16816 - int first_id;
16817 -
16818 - ENTER();
16819 -
16820 - if (WARN_ON(ffs->state != FFS_ACTIVE
16821 - || test_and_set_bit(FFS_FL_BOUND, &ffs->flags)))
16822 - return -EBADFD;
16823 -
16824 - first_id = usb_string_ids_n(cdev, ffs->strings_count);
16825 - if (unlikely(first_id < 0))
16826 - return first_id;
16827 -
16828 - ffs->ep0req = usb_ep_alloc_request(cdev->gadget->ep0, GFP_KERNEL);
16829 - if (unlikely(!ffs->ep0req))
16830 - return -ENOMEM;
16831 - ffs->ep0req->complete = ffs_ep0_complete;
16832 - ffs->ep0req->context = ffs;
16833 - INIT_LIST_HEAD(&ffs->ep0req->list);
16834 -
16835 - lang = ffs->stringtabs;
16836 - if (lang) {
16837 - for (; *lang; ++lang) {
16838 - struct usb_string *str = (*lang)->strings;
16839 - int id = first_id;
16840 - for (; str->s; ++id, ++str)
16841 - str->id = id;
16842 - }
16843 - }
16844 -
16845 - ffs->gadget = cdev->gadget;
16846 - ffs->speed = cdev->gadget->speed;
16847 - ffs_data_get(ffs);
16848 - return 0;
16849 -}
16850 -
16851 -static void functionfs_unbind(struct ffs_data *ffs)
16852 -{
16853 - ENTER();
16854 -
16855 - if (!WARN_ON(!ffs->gadget)) {
16856 - usb_ep_free_request(ffs->gadget->ep0, ffs->ep0req);
16857 - ffs->ep0req = NULL;
16858 - ffs->gadget = NULL;
16859 - clear_bit(FFS_FL_BOUND, &ffs->flags);
16860 - ffs_data_put(ffs);
16861 - }
16862 -}
16863 -
16864 -static int ffs_epfiles_create(struct ffs_data *ffs)
16865 -{
16866 - struct ffs_epfile *epfile = NULL, *epfiles = NULL;
16867 - unsigned int i, count ,ret;
16868 -
16869 - ENTER();
16870 -
16871 - count = ffs->eps_count;
16872 - epfiles = kcalloc(count, sizeof(*epfiles), GFP_KERNEL);
16873 - if (!epfiles)
16874 - return -ENOMEM;
16875 -
16876 - epfile = epfiles;
16877 - for (i = 1; i <= count; ++i, ++epfile) {
16878 - epfile->ffs = ffs;
16879 - mutex_init(&epfile->mutex);
16880 - INIT_LIST_HEAD(&epfile->memory_list);
16881 - init_waitqueue_head(&epfile->wait_que);
16882 - if (ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR) {
16883 - if (sprintf(epfile->name, "%s.ep%02x", ffs->dev_name, ffs->eps_addrmap[i]) < 0) {
16884 - return -EFAULT;
16885 - }
16886 - } else {
16887 - if (sprintf(epfile->name, "%s.ep%u", ffs->dev_name, i) < 0) {
16888 - return -EFAULT;
16889 - }
16890 - }
16891 -
16892 - cdev_init(&epfile->cdev, &ffs_epfile_operations);
16893 - epfile->devno=MKDEV(MAJOR(ffs->devno), i);
16894 - ret = cdev_add(&epfile->cdev, epfile->devno, 1);
16895 - if (ret)
16896 - {
16897 - ffs_epfiles_destroy(epfiles, i - 1);
16898 - return -EBUSY;
16899 - }
16900 -
16901 - epfile->device = device_create(ffs_class, NULL, epfile->devno, NULL, epfile->name);
16902 - if (IS_ERR(epfile->device))
16903 - {
16904 - cdev_del(&epfile->cdev);
16905 - ffs_epfiles_destroy(epfiles, i - 1);
16906 - return -EBUSY;
16907 - }
16908 - }
16909 -
16910 - ffs->epfiles = epfiles;
16911 - return 0;
16912 -}
16913 -
16914 -static void ffs_epfiles_destroy(struct ffs_epfile *epfiles, unsigned count)
16915 -{
16916 - struct ffs_epfile *epfile = epfiles;
16917 -
16918 - ENTER();
16919 -
16920 - for (; count; --count, ++epfile) {
16921 - BUG_ON(mutex_is_locked(&epfile->mutex));
16922 - device_destroy(ffs_class, epfile->devno);
16923 - cdev_del(&epfile->cdev);
16924 - }
16925 -
16926 - kfree(epfiles);
16927 -}
16928 -
16929 -static void ffs_func_eps_disable(struct ffs_function *func)
16930 -{
16931 - struct ffs_ep *ep = func->eps;
16932 - struct ffs_epfile *epfile = func->ffs->epfiles;
16933 - unsigned count = func->ffs->eps_count;
16934 - unsigned long flags;
16935 -
16936 - spin_lock_irqsave(&func->ffs->eps_lock, flags);
16937 - while (count--) {
16938 - /* pending requests get nuked */
16939 - if (likely(ep->ep))
16940 - usb_ep_disable(ep->ep);
16941 - ++ep;
16942 -
16943 - if (epfile) {
16944 - epfile->ep = NULL;
16945 - ++epfile;
16946 - }
16947 - }
16948 - spin_unlock_irqrestore(&func->ffs->eps_lock, flags);
16949 -}
16950 -
16951 -static int ffs_func_eps_enable(struct ffs_function *func)
16952 -{
16953 - struct ffs_data *ffs = func->ffs;
16954 - struct ffs_ep *ep = func->eps;
16955 - struct ffs_epfile *epfile = ffs->epfiles;
16956 - unsigned count = ffs->eps_count;
16957 - unsigned long flags;
16958 - int ret = 0;
16959 -
16960 - spin_lock_irqsave(&func->ffs->eps_lock, flags);
16961 - while(count--) {
16962 - ep->ep->driver_data = ep;
16963 -
16964 - ret = config_ep_by_speed(func->gadget, &func->function, ep->ep);
16965 - if (ret) {
16966 - pr_err("%s: config_ep_by_speed(%s) returned %d\n",
16967 - __func__, ep->ep->name, ret);
16968 - break;
16969 - }
16970 -
16971 - ret = usb_ep_enable(ep->ep);
16972 - if (likely(!ret)) {
16973 - epfile->ep = ep;
16974 - epfile->in = usb_endpoint_dir_in(ep->ep->desc);
16975 - epfile->isoc = usb_endpoint_xfer_isoc(ep->ep->desc);
16976 - } else {
16977 - break;
16978 - }
16979 -
16980 - ++ep;
16981 - ++epfile;
16982 - }
16983 -
16984 - wake_up_interruptible(&ffs->wait);
16985 - spin_unlock_irqrestore(&func->ffs->eps_lock, flags);
16986 -
16987 - return ret;
16988 -}
16989 -
16990 -/* Parsing and building descriptors and strings *****************************/
16991 -
16992 -/*
16993 - * This validates if data pointed by data is a valid USB descriptor as
16994 - * well as record how many interfaces, endpoints and strings are
16995 - * required by given configuration. Returns address after the
16996 - * descriptor or NULL if data is invalid.
16997 - */
16998 -enum ffs_entity_type {
16999 - FFS_DESCRIPTOR, FFS_INTERFACE, FFS_STRING, FFS_ENDPOINT
17000 -};
17001 -
17002 -enum ffs_os_desc_type {
17003 - FFS_OS_DESC, FFS_OS_DESC_EXT_COMPAT, FFS_OS_DESC_EXT_PROP
17004 -};
17005 -
17006 -typedef int (*ffs_entity_callback)(enum ffs_entity_type entity, u8 *valuep,
17007 - struct usb_descriptor_header *desc,
17008 - void *priv);
17009 -
17010 -typedef int (*ffs_os_desc_callback)(enum ffs_os_desc_type entity,
17011 - struct usb_os_desc_header *h, void *data,
17012 - unsigned len, void *priv);
17013 -
17014 -static int __must_check ffs_do_single_desc(char *data, unsigned len,
17015 - ffs_entity_callback entity,
17016 - void *priv)
17017 -{
17018 - struct usb_descriptor_header *_ds = (void *)data;
17019 - u8 length;
17020 - int ret;
17021 -
17022 - ENTER();
17023 -
17024 - /* At least two bytes are required: length and type */
17025 - if (len < 2) {
17026 - pr_vdebug("descriptor too short\n");
17027 - return -EINVAL;
17028 - }
17029 -
17030 - /* If we have at least as many bytes as the descriptor takes? */
17031 - length = _ds->bLength;
17032 - if (len < length) {
17033 - pr_vdebug("descriptor longer then available data\n");
17034 - return -EINVAL;
17035 - }
17036 -
17037 -#define __entity_check_INTERFACE(val) 1
17038 -#define __entity_check_STRING(val) (val)
17039 -#define __entity_check_ENDPOINT(val) ((val) & USB_ENDPOINT_NUMBER_MASK)
17040 -#define __entity(type, val) do { \
17041 - pr_vdebug("entity " #type "(%02x)\n", (val)); \
17042 - if (unlikely(!__entity_check_ ##type(val))) { \
17043 - pr_vdebug("invalid entity's value\n"); \
17044 - return -EINVAL; \
17045 - } \
17046 - ret = entity(FFS_ ##type, &val, _ds, priv); \
17047 - if (unlikely(ret < 0)) { \
17048 - pr_debug("entity " #type "(%02x); ret = %d\n", \
17049 - (val), ret); \
17050 - return ret; \
17051 - } \
17052 - } while (0)
17053 -
17054 - /* Parse descriptor depending on type. */
17055 - switch (_ds->bDescriptorType) {
17056 - case USB_DT_DEVICE:
17057 - case USB_DT_CONFIG:
17058 - case USB_DT_STRING:
17059 - case USB_DT_DEVICE_QUALIFIER:
17060 - /* function can't have any of those */
17061 - pr_vdebug("descriptor reserved for gadget: %d\n",
17062 - _ds->bDescriptorType);
17063 - return -EINVAL;
17064 -
17065 - case USB_DT_INTERFACE: {
17066 - struct usb_interface_descriptor *ds = (void *)_ds;
17067 - pr_vdebug("interface descriptor\n");
17068 - if (length != sizeof *ds)
17069 - goto inv_length;
17070 -
17071 - __entity(INTERFACE, ds->bInterfaceNumber);
17072 - if (ds->iInterface)
17073 - __entity(STRING, ds->iInterface);
17074 - }
17075 - break;
17076 -
17077 - case USB_DT_ENDPOINT: {
17078 - struct usb_endpoint_descriptor *ds = (void *)_ds;
17079 - pr_vdebug("endpoint descriptor\n");
17080 - if (length != USB_DT_ENDPOINT_SIZE &&
17081 - length != USB_DT_ENDPOINT_AUDIO_SIZE)
17082 - goto inv_length;
17083 - __entity(ENDPOINT, ds->bEndpointAddress);
17084 - }
17085 - break;
17086 -
17087 - case HID_DT_HID:
17088 - pr_vdebug("hid descriptor\n");
17089 - if (length != sizeof(struct hid_descriptor))
17090 - goto inv_length;
17091 - break;
17092 -
17093 - case USB_DT_OTG:
17094 - if (length != sizeof(struct usb_otg_descriptor))
17095 - goto inv_length;
17096 - break;
17097 -
17098 - case USB_DT_INTERFACE_ASSOCIATION: {
17099 - struct usb_interface_assoc_descriptor *ds = (void *)_ds;
17100 - pr_vdebug("interface association descriptor\n");
17101 - if (length != sizeof *ds)
17102 - goto inv_length;
17103 - if (ds->iFunction)
17104 - __entity(STRING, ds->iFunction);
17105 - }
17106 - break;
17107 -
17108 - case USB_DT_SS_ENDPOINT_COMP:
17109 - pr_vdebug("EP SS companion descriptor\n");
17110 - if (length != sizeof(struct usb_ss_ep_comp_descriptor))
17111 - goto inv_length;
17112 - break;
17113 -
17114 - case USB_DT_OTHER_SPEED_CONFIG:
17115 - case USB_DT_INTERFACE_POWER:
17116 - case USB_DT_DEBUG:
17117 - case USB_DT_SECURITY:
17118 - case USB_DT_CS_RADIO_CONTROL:
17119 - pr_vdebug("unimplemented descriptor: %d\n", _ds->bDescriptorType);
17120 - break;
17121 - default:
17122 - /* We should never be here */
17123 - pr_vdebug("unknown descriptor: %d\n", _ds->bDescriptorType);
17124 - break;
17125 -inv_length:
17126 - pr_vdebug("invalid length: %d (descriptor %d)\n",
17127 - _ds->bLength, _ds->bDescriptorType);
17128 - return -EINVAL;
17129 - }
17130 -
17131 -#undef __entity
17132 -#undef __entity_check_DESCRIPTOR
17133 -#undef __entity_check_INTERFACE
17134 -#undef __entity_check_STRING
17135 -#undef __entity_check_ENDPOINT
17136 -
17137 - return length;
17138 -}
17139 -
17140 -static int __must_check ffs_do_descs(unsigned count, char *data, unsigned len,
17141 - ffs_entity_callback entity, void *priv)
17142 -{
17143 - const unsigned _len = len;
17144 - uintptr_t num = 0;
17145 -
17146 - ENTER();
17147 -
17148 - for (;;) {
17149 - int ret;
17150 -
17151 - if (num == count)
17152 - data = NULL;
17153 -
17154 - /* Record "descriptor" entity */
17155 - ret = entity(FFS_DESCRIPTOR, (u8 *)num, (void *)data, priv);
17156 - if (unlikely(ret < 0)) {
17157 - pr_debug("entity DESCRIPTOR(%02lx); ret = %d\n",
17158 - num, ret);
17159 - return ret;
17160 - }
17161 -
17162 - if (!data)
17163 - return _len - len;
17164 -
17165 - ret = ffs_do_single_desc(data, len, entity, priv);
17166 - if (unlikely(ret < 0)) {
17167 - pr_debug("%s returns %d\n", __func__, ret);
17168 - return ret;
17169 - }
17170 -
17171 - len -= ret;
17172 - data += ret;
17173 - ++num;
17174 - }
17175 -}
17176 -
17177 -static int __ffs_data_do_entity(enum ffs_entity_type type,
17178 - u8 *valuep, struct usb_descriptor_header *desc,
17179 - void *priv)
17180 -{
17181 - struct ffs_desc_helper *helper = priv;
17182 - struct usb_endpoint_descriptor *d = NULL;
17183 -
17184 - ENTER();
17185 -
17186 - switch (type) {
17187 - case FFS_DESCRIPTOR:
17188 - break;
17189 -
17190 - case FFS_INTERFACE:
17191 - /*
17192 - * Interfaces are indexed from zero so if we
17193 - * encountered interface "n" then there are at least
17194 - * "n+1" interfaces.
17195 - */
17196 - if (*valuep >= helper->interfaces_count)
17197 - helper->interfaces_count = *valuep + 1;
17198 - break;
17199 -
17200 - case FFS_STRING:
17201 - /*
17202 - * Strings are indexed from 1 (0 is reserved
17203 - * for languages list)
17204 - */
17205 - if (*valuep > helper->ffs->strings_count)
17206 - helper->ffs->strings_count = *valuep;
17207 - break;
17208 -
17209 - case FFS_ENDPOINT:
17210 - d = (void *)desc;
17211 - helper->eps_count++;
17212 - if (helper->eps_count >= FFS_MAX_EPS_COUNT)
17213 - return -EINVAL;
17214 - /* Check if descriptors for any speed were already parsed */
17215 - if (!helper->ffs->eps_count && !helper->ffs->interfaces_count)
17216 - helper->ffs->eps_addrmap[helper->eps_count] =
17217 - d->bEndpointAddress;
17218 - else if (helper->ffs->eps_addrmap[helper->eps_count] !=
17219 - d->bEndpointAddress)
17220 - return -EINVAL;
17221 - break;
17222 - }
17223 -
17224 - return 0;
17225 -}
17226 -
17227 -static int __ffs_do_os_desc_header(enum ffs_os_desc_type *next_type,
17228 - struct usb_os_desc_header *desc)
17229 -{
17230 - u16 bcd_version = le16_to_cpu(desc->bcdVersion);
17231 - u16 w_index = le16_to_cpu(desc->wIndex);
17232 -
17233 - if (bcd_version != 1) {
17234 - pr_vdebug("unsupported os descriptors version: %d",
17235 - bcd_version);
17236 - return -EINVAL;
17237 - }
17238 - switch (w_index) {
17239 - case 0x4:
17240 - *next_type = FFS_OS_DESC_EXT_COMPAT;
17241 - break;
17242 - case 0x5:
17243 - *next_type = FFS_OS_DESC_EXT_PROP;
17244 - break;
17245 - default:
17246 - pr_vdebug("unsupported os descriptor type: %d", w_index);
17247 - return -EINVAL;
17248 - }
17249 -
17250 - return sizeof(*desc);
17251 -}
17252 -
17253 -/*
17254 - * Process all extended compatibility/extended property descriptors
17255 - * of a feature descriptor
17256 - */
17257 -static int __must_check ffs_do_single_os_desc(char *data, unsigned len,
17258 - enum ffs_os_desc_type type,
17259 - u16 feature_count,
17260 - ffs_os_desc_callback entity,
17261 - void *priv,
17262 - struct usb_os_desc_header *h)
17263 -{
17264 - int ret;
17265 - const unsigned _len = len;
17266 -
17267 - ENTER();
17268 -
17269 - /* loop over all ext compat/ext prop descriptors */
17270 - while (feature_count--) {
17271 - ret = entity(type, h, data, len, priv);
17272 - if (unlikely(ret < 0)) {
17273 - pr_debug("bad OS descriptor, type: %d\n", type);
17274 - return ret;
17275 - }
17276 - data += ret;
17277 - len -= ret;
17278 - }
17279 - return _len - len;
17280 -}
17281 -
17282 -/* Process a number of complete Feature Descriptors (Ext Compat or Ext Prop) */
17283 -static int __must_check ffs_do_os_descs(unsigned count,
17284 - char *data, unsigned len,
17285 - ffs_os_desc_callback entity, void *priv)
17286 -{
17287 - const unsigned _len = len;
17288 - unsigned long num = 0;
17289 -
17290 - ENTER();
17291 -
17292 - for (num = 0; num < count; ++num) {
17293 - int ret;
17294 - enum ffs_os_desc_type type;
17295 - u16 feature_count;
17296 - struct usb_os_desc_header *desc = (void *)data;
17297 -
17298 - if (len < sizeof(*desc))
17299 - return -EINVAL;
17300 -
17301 - /*
17302 - * Record "descriptor" entity.
17303 - * Process dwLength, bcdVersion, wIndex, get b/wCount.
17304 - * Move the data pointer to the beginning of extended
17305 - * compatibilities proper or extended properties proper
17306 - * portions of the data
17307 - */
17308 - if (le32_to_cpu(desc->dwLength) > len)
17309 - return -EINVAL;
17310 -
17311 - ret = __ffs_do_os_desc_header(&type, desc);
17312 - if (unlikely(ret < 0)) {
17313 - pr_debug("entity OS_DESCRIPTOR(%02lx); ret = %d\n",
17314 - num, ret);
17315 - return ret;
17316 - }
17317 - /*
17318 - * 16-bit hex "?? 00" Little Endian looks like 8-bit hex "??"
17319 - */
17320 - feature_count = le16_to_cpu(desc->wCount);
17321 - if (type == FFS_OS_DESC_EXT_COMPAT &&
17322 - (feature_count > 255 || desc->Reserved))
17323 - return -EINVAL;
17324 - len -= ret;
17325 - data += ret;
17326 -
17327 - /*
17328 - * Process all function/property descriptors
17329 - * of this Feature Descriptor
17330 - */
17331 - ret = ffs_do_single_os_desc(data, len, type,
17332 - feature_count, entity, priv, desc);
17333 - if (unlikely(ret < 0)) {
17334 - pr_debug("%s returns %d\n", __func__, ret);
17335 - return ret;
17336 - }
17337 -
17338 - len -= ret;
17339 - data += ret;
17340 - }
17341 - return _len - len;
17342 -}
17343 -
17344 -/**
17345 - * Validate contents of the buffer from userspace related to OS descriptors.
17346 - */
17347 -static int __ffs_data_do_os_desc(enum ffs_os_desc_type type,
17348 - struct usb_os_desc_header *h, void *data,
17349 - unsigned len, void *priv)
17350 -{
17351 - struct ffs_data *ffs = priv;
17352 - u8 length;
17353 -
17354 - ENTER();
17355 -
17356 - switch (type) {
17357 - case FFS_OS_DESC_EXT_COMPAT: {
17358 - struct usb_ext_compat_desc *d = data;
17359 - int i;
17360 -
17361 - if (len < sizeof(*d) ||
17362 - d->bFirstInterfaceNumber >= ffs->interfaces_count)
17363 - return -EINVAL;
17364 - if (d->Reserved1 != 1) {
17365 - /*
17366 - * According to the spec, Reserved1 must be set to 1
17367 - * but older kernels incorrectly rejected non-zero
17368 - * values. We fix it here to avoid returning EINVAL
17369 - * in response to values we used to accept.
17370 - */
17371 - pr_debug("usb_ext_compat_desc::Reserved1 forced to 1\n");
17372 - d->Reserved1 = 1;
17373 - }
17374 - for (i = 0; i < ARRAY_SIZE(d->Reserved2); ++i)
17375 - if (d->Reserved2[i])
17376 - return -EINVAL;
17377 -
17378 - length = sizeof(struct usb_ext_compat_desc);
17379 - }
17380 - break;
17381 - case FFS_OS_DESC_EXT_PROP: {
17382 - struct usb_ext_prop_desc *d = data;
17383 - u32 type, pdl;
17384 - u16 pnl;
17385 -
17386 - if (len < sizeof(*d) || h->interface >= ffs->interfaces_count)
17387 - return -EINVAL;
17388 - length = le32_to_cpu(d->dwSize);
17389 - if (len < length)
17390 - return -EINVAL;
17391 - type = le32_to_cpu(d->dwPropertyDataType);
17392 - if (type < USB_EXT_PROP_UNICODE ||
17393 - type > USB_EXT_PROP_UNICODE_MULTI) {
17394 - pr_vdebug("unsupported os descriptor property type: %d",
17395 - type);
17396 - return -EINVAL;
17397 - }
17398 - pnl = le16_to_cpu(d->wPropertyNameLength);
17399 - if (length < 14 + pnl) {
17400 - pr_vdebug("invalid os descriptor length: %d pnl:%d (descriptor %d)\n",
17401 - length, pnl, type);
17402 - return -EINVAL;
17403 - }
17404 - pdl = le32_to_cpu(*(__le32 *)((u8 *)data + 10 + pnl));
17405 - if (length != 14 + pnl + pdl) {
17406 - pr_vdebug("invalid os descriptor length: %d pnl:%d pdl:%d (descriptor %d)\n",
17407 - length, pnl, pdl, type);
17408 - return -EINVAL;
17409 - }
17410 - ++ffs->ms_os_descs_ext_prop_count;
17411 - /* property name reported to the host as "WCHAR"s */
17412 - ffs->ms_os_descs_ext_prop_name_len += pnl * 2;
17413 - ffs->ms_os_descs_ext_prop_data_len += pdl;
17414 - }
17415 - break;
17416 - default:
17417 - pr_vdebug("unknown descriptor: %d\n", type);
17418 - return -EINVAL;
17419 - }
17420 - return length;
17421 -}
17422 -
17423 -static int __ffs_data_got_descs(struct ffs_data *ffs,
17424 - char *const _data, size_t len)
17425 -{
17426 - char *data = _data, *raw_descs = NULL;
17427 - unsigned os_descs_count = 0, counts[3], flags;
17428 - int ret = -EINVAL, i;
17429 - struct ffs_desc_helper helper;
17430 -
17431 - ENTER();
17432 -
17433 - if (get_unaligned_le32(data + 4) != len)
17434 - goto error;
17435 -
17436 - switch (get_unaligned_le32(data)) {
17437 - case FUNCTIONFS_DESCRIPTORS_MAGIC:
17438 - flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC;
17439 - data += 8;
17440 - len -= 8;
17441 - break;
17442 - case FUNCTIONFS_DESCRIPTORS_MAGIC_V2:
17443 - flags = get_unaligned_le32(data + 8);
17444 - ffs->user_flags = flags;
17445 - if (flags & ~(FUNCTIONFS_HAS_FS_DESC |
17446 - FUNCTIONFS_HAS_HS_DESC |
17447 - FUNCTIONFS_HAS_SS_DESC |
17448 - FUNCTIONFS_HAS_MS_OS_DESC |
17449 - FUNCTIONFS_VIRTUAL_ADDR |
17450 - FUNCTIONFS_EVENTFD |
17451 - FUNCTIONFS_ALL_CTRL_RECIP |
17452 - FUNCTIONFS_CONFIG0_SETUP)) {
17453 - ret = -ENOSYS;
17454 - goto error;
17455 - }
17456 - data += 12;
17457 - len -= 12;
17458 - break;
17459 - default:
17460 - goto error;
17461 - }
17462 -
17463 - if (flags & FUNCTIONFS_EVENTFD) {
17464 - if (len < 4)
17465 - goto error;
17466 - ffs->ffs_eventfd =
17467 - eventfd_ctx_fdget((int)get_unaligned_le32(data));
17468 - if (IS_ERR(ffs->ffs_eventfd)) {
17469 - ret = PTR_ERR(ffs->ffs_eventfd);
17470 - ffs->ffs_eventfd = NULL;
17471 - goto error;
17472 - }
17473 - data += 4;
17474 - len -= 4;
17475 - }
17476 -
17477 - /* Read fs_count, hs_count and ss_count (if present) */
17478 - for (i = 0; i < 3; ++i) {
17479 - if (!(flags & (1 << i))) {
17480 - counts[i] = 0;
17481 - } else if (len < 4) {
17482 - goto error;
17483 - } else {
17484 - counts[i] = get_unaligned_le32(data);
17485 - data += 4;
17486 - len -= 4;
17487 - }
17488 - }
17489 - if (flags & (1 << i)) {
17490 - if (len < 4) {
17491 - goto error;
17492 - }
17493 - os_descs_count = get_unaligned_le32(data);
17494 - data += 4;
17495 - len -= 4;
17496 - }
17497 -
17498 - /* Read descriptors */
17499 - raw_descs = data;
17500 - helper.ffs = ffs;
17501 - for (i = 0; i < 3; ++i) {
17502 - if (!counts[i])
17503 - continue;
17504 - helper.interfaces_count = 0;
17505 - helper.eps_count = 0;
17506 - ret = ffs_do_descs(counts[i], data, len,
17507 - __ffs_data_do_entity, &helper);
17508 - if (ret < 0)
17509 - goto error;
17510 - if (!ffs->eps_count && !ffs->interfaces_count) {
17511 - ffs->eps_count = helper.eps_count;
17512 - ffs->interfaces_count = helper.interfaces_count;
17513 - } else {
17514 - if (ffs->eps_count != helper.eps_count) {
17515 - ret = -EINVAL;
17516 - goto error;
17517 - }
17518 - if (ffs->interfaces_count != helper.interfaces_count) {
17519 - ret = -EINVAL;
17520 - goto error;
17521 - }
17522 - }
17523 - data += ret;
17524 - len -= ret;
17525 - }
17526 - if (os_descs_count) {
17527 - ret = ffs_do_os_descs(os_descs_count, data, len,
17528 - __ffs_data_do_os_desc, ffs);
17529 - if (ret < 0)
17530 - goto error;
17531 - data += ret;
17532 - len -= ret;
17533 - }
17534 -
17535 - if (raw_descs == data || len) {
17536 - ret = -EINVAL;
17537 - goto error;
17538 - }
17539 -
17540 - ffs->raw_descs_data = _data;
17541 - ffs->raw_descs = raw_descs;
17542 - ffs->raw_descs_length = data - raw_descs;
17543 - ffs->fs_descs_count = counts[0];
17544 - ffs->hs_descs_count = counts[1];
17545 - ffs->ss_descs_count = counts[2];
17546 - ffs->ms_os_descs_count = os_descs_count;
17547 -
17548 - return 0;
17549 -
17550 -error:
17551 - kfree(_data);
17552 - return ret;
17553 -}
17554 -
17555 -static int __ffs_data_got_strings(struct ffs_data *ffs,
17556 - char *const _data, size_t len)
17557 -{
17558 - u32 str_count, needed_count, lang_count;
17559 - struct usb_gadget_strings **stringtabs = NULL, *t = NULL;
17560 - const char *data = _data;
17561 - struct usb_string *s = NULL;
17562 -
17563 - ENTER();
17564 -
17565 - if (unlikely(len < 16 ||
17566 - get_unaligned_le32(data) != FUNCTIONFS_STRINGS_MAGIC ||
17567 - get_unaligned_le32(data + 4) != len))
17568 - goto error;
17569 - str_count = get_unaligned_le32(data + 8);
17570 - lang_count = get_unaligned_le32(data + 12);
17571 -
17572 - /* if one is zero the other must be zero */
17573 - if (unlikely(!str_count != !lang_count))
17574 - goto error;
17575 -
17576 - /* Do we have at least as many strings as descriptors need? */
17577 - needed_count = ffs->strings_count;
17578 - if (unlikely(str_count < needed_count))
17579 - goto error;
17580 -
17581 - /*
17582 - * If we don't need any strings just return and free all
17583 - * memory.
17584 - */
17585 - if (!needed_count) {
17586 - kfree(_data);
17587 - return 0;
17588 - }
17589 -
17590 - /* Allocate everything in one chunk so there's less maintenance. */
17591 - {
17592 - unsigned i = 0;
17593 - vla_group(d);
17594 - vla_item(d, struct usb_gadget_strings *, stringtabs,
17595 - lang_count + 1);
17596 - vla_item(d, struct usb_gadget_strings, stringtab, lang_count);
17597 - vla_item(d, struct usb_string, strings,
17598 - lang_count*(needed_count+1));
17599 -
17600 - char *vlabuf = kmalloc(vla_group_size(d), GFP_KERNEL);
17601 -
17602 - if (unlikely(!vlabuf)) {
17603 - kfree(_data);
17604 - return -ENOMEM;
17605 - }
17606 -
17607 - /* Initialize the VLA pointers */
17608 - stringtabs = vla_ptr(vlabuf, d, stringtabs);
17609 - t = vla_ptr(vlabuf, d, stringtab);
17610 - i = lang_count;
17611 - do {
17612 - *stringtabs++ = t++;
17613 - } while (--i);
17614 - *stringtabs = NULL;
17615 -
17616 - /* stringtabs = vlabuf = d_stringtabs for later kfree */
17617 - stringtabs = vla_ptr(vlabuf, d, stringtabs);
17618 - t = vla_ptr(vlabuf, d, stringtab);
17619 - s = vla_ptr(vlabuf, d, strings);
17620 - }
17621 -
17622 - /* For each language */
17623 - data += 16;
17624 - len -= 16;
17625 -
17626 - do { /* lang_count > 0 so we can use do-while */
17627 - unsigned needed = needed_count;
17628 -
17629 - if (unlikely(len < 3))
17630 - goto error_free;
17631 - t->language = get_unaligned_le16(data);
17632 - t->strings = s;
17633 - ++t;
17634 -
17635 - data += 2;
17636 - len -= 2;
17637 -
17638 - /* For each string */
17639 - do { /* str_count > 0 so we can use do-while */
17640 - size_t length = strnlen(data, len);
17641 -
17642 - if (unlikely(length == len))
17643 - goto error_free;
17644 -
17645 - /*
17646 - * User may provide more strings then we need,
17647 - * if that's the case we simply ignore the
17648 - * rest
17649 - */
17650 - if (likely(needed)) {
17651 - /*
17652 - * s->id will be set while adding
17653 - * function to configuration so for
17654 - * now just leave garbage here.
17655 - */
17656 - s->s = data;
17657 - --needed;
17658 - ++s;
17659 - }
17660 -
17661 - data += length + 1;
17662 - len -= length + 1;
17663 - } while (--str_count);
17664 -
17665 - s->id = 0; /* terminator */
17666 - s->s = NULL;
17667 - ++s;
17668 -
17669 - } while (--lang_count);
17670 -
17671 - /* Some garbage left? */
17672 - if (unlikely(len))
17673 - goto error_free;
17674 -
17675 - /* Done! */
17676 - ffs->stringtabs = stringtabs;
17677 - ffs->raw_strings = _data;
17678 -
17679 - return 0;
17680 -
17681 -error_free:
17682 - kfree(stringtabs);
17683 -error:
17684 - kfree(_data);
17685 - return -EINVAL;
17686 -}
17687 -
17688 -/* Events handling and management *******************************************/
17689 -static void __ffs_event_add(struct ffs_data *ffs,
17690 - enum usb_functionfs_event_type type)
17691 -{
17692 - enum usb_functionfs_event_type rem_type1, rem_type2 = type;
17693 - int neg = 0;
17694 -
17695 - /*
17696 - * Abort any unhandled setup
17697 - *
17698 - * We do not need to worry about some cmpxchg() changing value
17699 - * of ffs->setup_state without holding the lock because when
17700 - * state is FFS_SETUP_PENDING cmpxchg() in several places in
17701 - * the source does nothing.
17702 - */
17703 - if (ffs->setup_state == FFS_SETUP_PENDING)
17704 - ffs->setup_state = FFS_SETUP_CANCELLED;
17705 -
17706 - /*
17707 - * Logic of this function guarantees that there are at most four pending
17708 - * evens on ffs->ev.types queue. This is important because the queue
17709 - * has space for four elements only and __ffs_ep0_read_events function
17710 - * depends on that limit as well. If more event types are added, those
17711 - * limits have to be revisited or guaranteed to still hold.
17712 - */
17713 - switch (type) {
17714 - case FUNCTIONFS_RESUME:
17715 - rem_type2 = FUNCTIONFS_SUSPEND;
17716 - /* FALL THROUGH */
17717 - case FUNCTIONFS_SUSPEND:
17718 - case FUNCTIONFS_SETUP:
17719 - rem_type1 = type;
17720 - /* Discard all similar events */
17721 - break;
17722 -
17723 - case FUNCTIONFS_BIND:
17724 - case FUNCTIONFS_UNBIND:
17725 - case FUNCTIONFS_DISABLE:
17726 - case FUNCTIONFS_ENABLE:
17727 - /* Discard everything other then power management. */
17728 - rem_type1 = FUNCTIONFS_SUSPEND;
17729 - rem_type2 = FUNCTIONFS_RESUME;
17730 - neg = 1;
17731 - break;
17732 -
17733 - default:
17734 - WARN(1, "%d: unknown event, this should not happen\n", type);
17735 - return;
17736 - }
17737 -
17738 - {
17739 - u8 *ev = ffs->ev.types, *out = ev;
17740 - unsigned n = ffs->ev.count;
17741 - for (; n; --n, ++ev)
17742 - if ((*ev == rem_type1 || *ev == rem_type2) == neg)
17743 - *out++ = *ev;
17744 - else
17745 - pr_vdebug("purging event %d\n", *ev);
17746 - ffs->ev.count = out - ffs->ev.types;
17747 - }
17748 -
17749 - pr_vdebug("adding event %d\n", type);
17750 - ffs->ev.types[ffs->ev.count++] = type;
17751 - wake_up_locked(&ffs->ev.waitq);
17752 - if (ffs->ffs_eventfd)
17753 - eventfd_signal(ffs->ffs_eventfd, 1);
17754 -}
17755 -
17756 -static void ffs_event_add(struct ffs_data *ffs,
17757 - enum usb_functionfs_event_type type)
17758 -{
17759 - unsigned long flags;
17760 - spin_lock_irqsave(&ffs->ev.waitq.lock, flags);
17761 - __ffs_event_add(ffs, type);
17762 - spin_unlock_irqrestore(&ffs->ev.waitq.lock, flags);
17763 -}
17764 -
17765 -/* Bind/unbind USB function hooks *******************************************/
17766 -
17767 -static int ffs_ep_addr2idx(struct ffs_data *ffs, u8 endpoint_address)
17768 -{
17769 - int i;
17770 -
17771 - for (i = 1; i < ARRAY_SIZE(ffs->eps_addrmap); ++i)
17772 - if (ffs->eps_addrmap[i] == endpoint_address)
17773 - return i;
17774 - return -ENOENT;
17775 -}
17776 -
17777 -static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
17778 - struct usb_descriptor_header *desc,
17779 - void *priv)
17780 -{
17781 - struct usb_endpoint_descriptor *ds = (void *)desc;
17782 - struct ffs_function *func = priv;
17783 - struct ffs_ep *ffs_ep = NULL;
17784 - unsigned ep_desc_id;
17785 - int idx;
17786 - static const char *speed_names[] = { "full", "high", "super" };
17787 -
17788 - if (type != FFS_DESCRIPTOR)
17789 - return 0;
17790 -
17791 - /*
17792 - * If ss_descriptors is not NULL, we are reading super speed
17793 - * descriptors; if hs_descriptors is not NULL, we are reading high
17794 - * speed descriptors; otherwise, we are reading full speed
17795 - * descriptors.
17796 - */
17797 - if (func->function.ss_descriptors) {
17798 - ep_desc_id = 2;
17799 - func->function.ss_descriptors[(uintptr_t)valuep] = desc;
17800 - } else if (func->function.hs_descriptors) {
17801 - ep_desc_id = 1;
17802 - func->function.hs_descriptors[(uintptr_t)valuep] = desc;
17803 - } else {
17804 - ep_desc_id = 0;
17805 - func->function.fs_descriptors[(uintptr_t)valuep] = desc;
17806 - }
17807 -
17808 - if (!desc || desc->bDescriptorType != USB_DT_ENDPOINT)
17809 - return 0;
17810 -
17811 - idx = ffs_ep_addr2idx(func->ffs, ds->bEndpointAddress) - 1;
17812 - if (idx < 0)
17813 - return idx;
17814 -
17815 - ffs_ep = func->eps + idx;
17816 -
17817 - if (unlikely(ffs_ep->descs[ep_desc_id])) {
17818 - pr_err("two %sspeed descriptors for EP %d\n",
17819 - speed_names[ep_desc_id],
17820 - ds->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
17821 - return -EINVAL;
17822 - }
17823 - ffs_ep->descs[ep_desc_id] = ds;
17824 -
17825 - ffs_dump_mem(": Original ep desc", ds, ds->bLength);
17826 - if (ffs_ep->ep) {
17827 - ds->bEndpointAddress = ffs_ep->descs[0]->bEndpointAddress;
17828 - if (!ds->wMaxPacketSize)
17829 - ds->wMaxPacketSize = ffs_ep->descs[0]->wMaxPacketSize;
17830 - } else {
17831 - struct usb_request *req = NULL;
17832 - struct usb_ep *ep = NULL;
17833 - u8 bEndpointAddress;
17834 -
17835 - /*
17836 - * We back up bEndpointAddress because autoconfig overwrites
17837 - * it with physical endpoint address.
17838 - */
17839 - bEndpointAddress = ds->bEndpointAddress;
17840 - pr_vdebug("autoconfig\n");
17841 - ep = usb_ep_autoconfig(func->gadget, ds);
17842 - if (unlikely(!ep))
17843 - return -ENOTSUPP;
17844 - ep->driver_data = func->eps + idx;
17845 -
17846 - req = usb_ep_alloc_request(ep, GFP_KERNEL);
17847 - if (unlikely(!req))
17848 - return -ENOMEM;
17849 -
17850 - ffs_ep->ep = ep;
17851 - ffs_ep->req = req;
17852 - INIT_LIST_HEAD(&ffs_ep->req->list);
17853 - func->eps_revmap[ds->bEndpointAddress &
17854 - USB_ENDPOINT_NUMBER_MASK] = idx + 1;
17855 - /*
17856 - * If we use virtual address mapping, we restore
17857 - * original bEndpointAddress value.
17858 - */
17859 - if (func->ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
17860 - ds->bEndpointAddress = bEndpointAddress;
17861 - }
17862 - ffs_dump_mem(": Rewritten ep desc", ds, ds->bLength);
17863 -
17864 - return 0;
17865 -}
17866 -
17867 -static int __ffs_func_bind_do_nums(enum ffs_entity_type type, u8 *valuep,
17868 - struct usb_descriptor_header *desc,
17869 - void *priv)
17870 -{
17871 - struct ffs_function *func = priv;
17872 - unsigned idx;
17873 - u8 newValue;
17874 -
17875 - switch (type) {
17876 - default:
17877 - case FFS_DESCRIPTOR:
17878 - /* Handled in previous pass by __ffs_func_bind_do_descs() */
17879 - return 0;
17880 -
17881 - case FFS_INTERFACE:
17882 - idx = *valuep;
17883 - if (func->interfaces_nums[idx] < 0) {
17884 - int id = usb_interface_id(func->conf, &func->function);
17885 - if (unlikely(id < 0))
17886 - return id;
17887 - func->interfaces_nums[idx] = id;
17888 - }
17889 - newValue = func->interfaces_nums[idx];
17890 - break;
17891 -
17892 - case FFS_STRING:
17893 - /* String' IDs are allocated when fsf_data is bound to cdev */
17894 - newValue = func->ffs->stringtabs[0]->strings[*valuep - 1].id;
17895 - break;
17896 -
17897 - case FFS_ENDPOINT:
17898 - /*
17899 - * USB_DT_ENDPOINT are handled in
17900 - * __ffs_func_bind_do_descs().
17901 - */
17902 - if (desc->bDescriptorType == USB_DT_ENDPOINT)
17903 - return 0;
17904 -
17905 - idx = (*valuep & USB_ENDPOINT_NUMBER_MASK) - 1;
17906 - if (unlikely(!func->eps[idx].ep))
17907 - return -EINVAL;
17908 -
17909 - {
17910 - struct usb_endpoint_descriptor **descs;
17911 - descs = func->eps[idx].descs;
17912 - newValue = descs[descs[0] ? 0 : 1]->bEndpointAddress;
17913 - }
17914 - break;
17915 - }
17916 -
17917 - pr_vdebug("%02x -> %02x\n", *valuep, newValue);
17918 - *valuep = newValue;
17919 - return 0;
17920 -}
17921 -
17922 -static int __ffs_func_bind_do_os_desc(enum ffs_os_desc_type type,
17923 - struct usb_os_desc_header *h, void *data,
17924 - unsigned len, void *priv)
17925 -{
17926 - struct ffs_function *func = priv;
17927 - u8 length = 0;
17928 -
17929 - switch (type) {
17930 - case FFS_OS_DESC_EXT_COMPAT: {
17931 - struct usb_ext_compat_desc *desc = data;
17932 - struct usb_os_desc_table *t;
17933 -
17934 - t = &func->function.os_desc_table[desc->bFirstInterfaceNumber];
17935 - t->if_id = func->interfaces_nums[desc->bFirstInterfaceNumber];
17936 - memcpy(t->os_desc->ext_compat_id, &desc->CompatibleID,
17937 - ARRAY_SIZE(desc->CompatibleID) + ARRAY_SIZE(desc->SubCompatibleID));
17938 - length = sizeof(*desc);
17939 - }
17940 - break;
17941 - case FFS_OS_DESC_EXT_PROP: {
17942 - struct usb_ext_prop_desc *desc = data;
17943 - struct usb_os_desc_table *t;
17944 - struct usb_os_desc_ext_prop *ext_prop;
17945 - char *ext_prop_name;
17946 - char *ext_prop_data;
17947 -
17948 - t = &func->function.os_desc_table[h->interface];
17949 - t->if_id = func->interfaces_nums[h->interface];
17950 -
17951 - ext_prop = func->ffs->ms_os_descs_ext_prop_avail;
17952 - func->ffs->ms_os_descs_ext_prop_avail += sizeof(*ext_prop);
17953 -
17954 - ext_prop->type = le32_to_cpu(desc->dwPropertyDataType);
17955 - ext_prop->name_len = le16_to_cpu(desc->wPropertyNameLength);
17956 - ext_prop->data_len = le32_to_cpu(*(__le32 *)
17957 - usb_ext_prop_data_len_ptr(data, ext_prop->name_len));
17958 - length = ext_prop->name_len + ext_prop->data_len + 14;
17959 -
17960 - ext_prop_name = func->ffs->ms_os_descs_ext_prop_name_avail;
17961 - func->ffs->ms_os_descs_ext_prop_name_avail +=
17962 - ext_prop->name_len;
17963 -
17964 - ext_prop_data = func->ffs->ms_os_descs_ext_prop_data_avail;
17965 - func->ffs->ms_os_descs_ext_prop_data_avail +=
17966 - ext_prop->data_len;
17967 - memcpy(ext_prop_data, usb_ext_prop_data_ptr(data, ext_prop->name_len),
17968 - ext_prop->data_len);
17969 - /* unicode data reported to the host as "WCHAR"s */
17970 - switch (ext_prop->type) {
17971 - case USB_EXT_PROP_UNICODE:
17972 - case USB_EXT_PROP_UNICODE_ENV:
17973 - case USB_EXT_PROP_UNICODE_LINK:
17974 - case USB_EXT_PROP_UNICODE_MULTI:
17975 - ext_prop->data_len *= 2;
17976 - break;
17977 - }
17978 - ext_prop->data = ext_prop_data;
17979 -
17980 - memcpy(ext_prop_name, usb_ext_prop_name_ptr(data),
17981 - ext_prop->name_len);
17982 - /* property name reported to the host as "WCHAR"s */
17983 - ext_prop->name_len *= 2;
17984 - ext_prop->name = ext_prop_name;
17985 -
17986 - t->os_desc->ext_prop_len +=
17987 - ext_prop->name_len + ext_prop->data_len + 14;
17988 - ++t->os_desc->ext_prop_count;
17989 - list_add_tail(&ext_prop->entry, &t->os_desc->ext_prop);
17990 - }
17991 - break;
17992 - default:
17993 - pr_vdebug("unknown descriptor: %d\n", type);
17994 - }
17995 -
17996 - return length;
17997 -}
17998 -
17999 -static inline struct f_fs_opts *ffs_do_functionfs_bind(struct usb_function *f,
18000 - struct usb_configuration *c)
18001 -{
18002 - struct ffs_function *func = ffs_func_from_usb(f);
18003 - struct f_fs_opts *ffs_opts =
18004 - container_of(f->fi, struct f_fs_opts, func_inst);
18005 - int ret;
18006 -
18007 - ENTER();
18008 -
18009 - /*
18010 - * Legacy gadget triggers binding in functionfs_ready_callback,
18011 - * which already uses locking; taking the same lock here would
18012 - * cause a deadlock.
18013 - *
18014 - * Configfs-enabled gadgets however do need ffs_dev_lock.
18015 - */
18016 - if (!ffs_opts->no_configfs)
18017 - ffs_dev_lock();
18018 - ret = ffs_opts->dev->desc_ready ? 0 : -ENODEV;
18019 - func->ffs = ffs_opts->dev->ffs_data;
18020 - if (!ffs_opts->no_configfs)
18021 - ffs_dev_unlock();
18022 - if (ret)
18023 - return ERR_PTR(ret);
18024 -
18025 - func->conf = c;
18026 - func->gadget = c->cdev->gadget;
18027 -
18028 - /*
18029 - * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
18030 - * configurations are bound in sequence with list_for_each_entry,
18031 - * in each configuration its functions are bound in sequence
18032 - * with list_for_each_entry, so we assume no race condition
18033 - * with regard to ffs_opts->bound access
18034 - */
18035 - if (!ffs_opts->refcnt) {
18036 - ret = functionfs_bind(func->ffs, c->cdev);
18037 - if (ret)
18038 - return ERR_PTR(ret);
18039 - }
18040 - ffs_opts->refcnt++;
18041 - func->function.strings = func->ffs->stringtabs;
18042 -
18043 - return ffs_opts;
18044 -}
18045 -
18046 -static int _ffs_func_bind(struct usb_configuration *c, struct usb_function *f)
18047 -{
18048 - struct ffs_function *func = ffs_func_from_usb(f);
18049 - struct ffs_data *ffs = func->ffs;
18050 -
18051 - const int full = !!func->ffs->fs_descs_count;
18052 - const int high = !!func->ffs->hs_descs_count;
18053 - const int super = !!func->ffs->ss_descs_count;
18054 -
18055 - int fs_len, hs_len, ss_len, ret, i;
18056 - struct ffs_ep *eps_ptr = NULL;
18057 - struct usb_descriptor_header *des_head = NULL;
18058 - struct usb_interface_descriptor *intf_ctl = NULL;
18059 - struct usb_interface_descriptor *intf_data = NULL;
18060 - /* Make it a single chunk, less management later on */
18061 - vla_group(d);
18062 - vla_item_with_sz(d, struct ffs_ep, eps, ffs->eps_count);
18063 - vla_item_with_sz(d, struct usb_descriptor_header *, fs_descs,
18064 - full ? ffs->fs_descs_count + 1 : 0);
18065 - vla_item_with_sz(d, struct usb_descriptor_header *, hs_descs,
18066 - high ? ffs->hs_descs_count + 1 : 0);
18067 - vla_item_with_sz(d, struct usb_descriptor_header *, ss_descs,
18068 - super ? ffs->ss_descs_count + 1 : 0);
18069 - vla_item_with_sz(d, short, inums, ffs->interfaces_count);
18070 - vla_item_with_sz(d, struct usb_os_desc_table, os_desc_table,
18071 - c->cdev->use_os_string ? ffs->interfaces_count : 0);
18072 - vla_item_with_sz(d, char[16], ext_compat,
18073 - c->cdev->use_os_string ? ffs->interfaces_count : 0);
18074 - vla_item_with_sz(d, struct usb_os_desc, os_desc,
18075 - c->cdev->use_os_string ? ffs->interfaces_count : 0);
18076 - vla_item_with_sz(d, struct usb_os_desc_ext_prop, ext_prop,
18077 - ffs->ms_os_descs_ext_prop_count);
18078 - vla_item_with_sz(d, char, ext_prop_name,
18079 - ffs->ms_os_descs_ext_prop_name_len);
18080 - vla_item_with_sz(d, char, ext_prop_data,
18081 - ffs->ms_os_descs_ext_prop_data_len);
18082 - vla_item_with_sz(d, char, raw_descs, ffs->raw_descs_length);
18083 - char *vlabuf = NULL;
18084 -
18085 - ENTER();
18086 -
18087 - /* Has descriptors only for speeds gadget does not support */
18088 - if (unlikely(!(full | high | super)))
18089 - return -ENOTSUPP;
18090 -
18091 - /* Allocate a single chunk, less management later on */
18092 - vlabuf = kzalloc(vla_group_size(d), GFP_KERNEL);
18093 - if (unlikely(!vlabuf))
18094 - return -ENOMEM;
18095 -
18096 - ffs->ms_os_descs_ext_prop_avail = vla_ptr(vlabuf, d, ext_prop);
18097 - ffs->ms_os_descs_ext_prop_name_avail =
18098 - vla_ptr(vlabuf, d, ext_prop_name);
18099 - ffs->ms_os_descs_ext_prop_data_avail =
18100 - vla_ptr(vlabuf, d, ext_prop_data);
18101 -
18102 - /* Copy descriptors */
18103 - memcpy(vla_ptr(vlabuf, d, raw_descs), ffs->raw_descs, ffs->raw_descs_length);
18104 -
18105 - memset(vla_ptr(vlabuf, d, inums), 0xff, d_inums__sz);
18106 -
18107 - eps_ptr = vla_ptr(vlabuf, d, eps);
18108 - for (i = 0; i < ffs->eps_count; i++)
18109 - eps_ptr[i].num = -1;
18110 -
18111 - /* Save pointers
18112 - * d_eps == vlabuf, func->eps used to kfree vlabuf later
18113 - */
18114 - func->eps = vla_ptr(vlabuf, d, eps);
18115 - func->interfaces_nums = vla_ptr(vlabuf, d, inums);
18116 -
18117 - /*
18118 - * Go through all the endpoint descriptors and allocate
18119 - * endpoints first, so that later we can rewrite the endpoint
18120 - * numbers without worrying that it may be described later on.
18121 - */
18122 - if (likely(full)) {
18123 - func->function.fs_descriptors = vla_ptr(vlabuf, d, fs_descs);
18124 - fs_len = ffs_do_descs(ffs->fs_descs_count,
18125 - vla_ptr(vlabuf, d, raw_descs),
18126 - d_raw_descs__sz,
18127 - __ffs_func_bind_do_descs, func);
18128 - if (unlikely(fs_len < 0)) {
18129 - ret = fs_len;
18130 - goto error;
18131 - }
18132 - } else {
18133 - fs_len = 0;
18134 - }
18135 - if (likely(high)) {
18136 - func->function.hs_descriptors = vla_ptr(vlabuf, d, hs_descs);
18137 - hs_len = ffs_do_descs(ffs->hs_descs_count,
18138 - vla_ptr(vlabuf, d, raw_descs) + fs_len,
18139 - d_raw_descs__sz - fs_len,
18140 - __ffs_func_bind_do_descs, func);
18141 - if (unlikely(hs_len < 0)) {
18142 - ret = hs_len;
18143 - goto error;
18144 - }
18145 - } else {
18146 - hs_len = 0;
18147 - }
18148 - if (likely(super)) {
18149 - func->function.ss_descriptors = vla_ptr(vlabuf, d, ss_descs);
18150 - ss_len = ffs_do_descs(ffs->ss_descs_count,
18151 - vla_ptr(vlabuf, d, raw_descs) + fs_len + hs_len,
18152 - d_raw_descs__sz - fs_len - hs_len,
18153 - __ffs_func_bind_do_descs, func);
18154 - if (unlikely(ss_len < 0)) {
18155 - ret = ss_len;
18156 - goto error;
18157 - }
18158 - } else {
18159 - ss_len = 0;
18160 - }
18161 - /*
18162 - * Now handle interface numbers allocation and interface and
18163 - * endpoint numbers rewriting. We can do that in one go
18164 - * now.
18165 - */
18166 - ret = ffs_do_descs(ffs->fs_descs_count +
18167 - (high ? ffs->hs_descs_count : 0) +
18168 - (super ? ffs->ss_descs_count : 0),
18169 - vla_ptr(vlabuf, d, raw_descs), d_raw_descs__sz,
18170 - __ffs_func_bind_do_nums, func);
18171 - if (unlikely(ret < 0))
18172 - goto error;
18173 -
18174 - func->function.os_desc_table = vla_ptr(vlabuf, d, os_desc_table);
18175 - if (c->cdev->use_os_string) {
18176 - for (i = 0; i < ffs->interfaces_count; ++i) {
18177 - struct usb_os_desc *desc;
18178 -
18179 - desc = func->function.os_desc_table[i].os_desc =
18180 - vla_ptr(vlabuf, d, os_desc) +
18181 - i * sizeof(struct usb_os_desc);
18182 - desc->ext_compat_id =
18183 - vla_ptr(vlabuf, d, ext_compat) + i * 16;
18184 - INIT_LIST_HEAD(&desc->ext_prop);
18185 - }
18186 - ret = ffs_do_os_descs(ffs->ms_os_descs_count,
18187 - vla_ptr(vlabuf, d, raw_descs) +
18188 - fs_len + hs_len + ss_len,
18189 - d_raw_descs__sz - fs_len - hs_len -
18190 - ss_len,
18191 - __ffs_func_bind_do_os_desc, func);
18192 - if (unlikely(ret < 0))
18193 - goto error;
18194 - }
18195 - func->function.os_desc_n =
18196 - c->cdev->use_os_string ? ffs->interfaces_count : 0;
18197 -
18198 - for (i = 0; i< func->ffs->fs_descs_count; i++) {
18199 - des_head = func->function.fs_descriptors[i];
18200 - if (des_head->bDescriptorType == USB_DT_INTERFACE) {
18201 - struct usb_interface_descriptor *intf = (struct usb_interface_descriptor *)des_head;
18202 - if (intf->bNumEndpoints > 0) {
18203 - if (intf_ctl == NULL) {
18204 - intf_ctl = intf;
18205 - } else {
18206 - intf_data = intf;
18207 - break;
18208 - }
18209 - }
18210 - }
18211 - }
18212 - for (i = 0; i< func->ffs->fs_descs_count; i++) {
18213 - des_head = func->function.fs_descriptors[i];
18214 - if (des_head->bDescriptorType == USB_DT_INTERFACE_ASSOCIATION) {
18215 - struct usb_interface_assoc_descriptor *a_dec = (struct usb_interface_assoc_descriptor …
18216 - a_dec->bFirstInterface = intf_ctl->bInterfaceNumber;
18217 - } else if (des_head->bDescriptorType == USB_DT_CS_INTERFACE) {
18218 - struct usb_cdc_header_desc *cs_des = (struct usb_cdc_header_desc *)des_head;
18219 - if (cs_des->bDescriptorSubType == USB_CDC_CALL_MANAGEMENT_TYPE) {
18220 - struct usb_cdc_call_mgmt_descriptor *mgmt_des = (struct usb_cdc_call_mgmt_descript…
18221 - mgmt_des->bDataInterface = intf_data->bInterfaceNumber;
18222 - } else if (cs_des->bDescriptorSubType == USB_CDC_UNION_TYPE) {
18223 - struct usb_cdc_union_desc *union_des = (struct usb_cdc_union_desc *)des_head;
18224 - union_des->bMasterInterface0 = intf_ctl->bInterfaceNumber;
18225 - union_des->bSlaveInterface0 = intf_data->bInterfaceNumber;
18226 - } else if (cs_des->bDescriptorSubType == USB_CDC_ETHERNET_TYPE) {
18227 - struct usb_cdc_ether_desc *ether_des = (struct usb_cdc_ether_desc *)des_head;
18228 - ether_des->iMACAddress = intf_ctl->iInterface + 1;
18229 - }
18230 - }
18231 - }
18232 - for (i = 0; i< func->ffs->hs_descs_count; i++) {
18233 - des_head = func->function.hs_descriptors[i];
18234 - if (des_head->bDescriptorType == USB_DT_INTERFACE_ASSOCIATION) {
18235 - struct usb_interface_assoc_descriptor *a_dec = (struct usb_interface_assoc_descriptor …
18236 - a_dec->bFirstInterface = intf_ctl->bInterfaceNumber;
18237 - } else if (des_head->bDescriptorType == USB_DT_CS_INTERFACE) {
18238 - struct usb_cdc_header_desc *cs_des = (struct usb_cdc_header_desc *)des_head;
18239 - if (cs_des->bDescriptorSubType == USB_CDC_CALL_MANAGEMENT_TYPE) {
18240 - struct usb_cdc_call_mgmt_descriptor *mgmt_des = (struct usb_cdc_call_mgmt_descript…
18241 - mgmt_des->bDataInterface = intf_data->bInterfaceNumber;
18242 - } else if (cs_des->bDescriptorSubType == USB_CDC_UNION_TYPE) {
18243 - struct usb_cdc_union_desc *union_des = (struct usb_cdc_union_desc *)des_head;
18244 - union_des->bMasterInterface0 = intf_ctl->bInterfaceNumber;
18245 - union_des->bSlaveInterface0 = intf_data->bInterfaceNumber;
18246 - } else if (cs_des->bDescriptorSubType == USB_CDC_ETHERNET_TYPE) {
18247 - struct usb_cdc_ether_desc *ether_des = (struct usb_cdc_ether_desc *)des_head;
18248 - ether_des->iMACAddress = intf_ctl->iInterface + 1;
18249 - }
18250 - }
18251 - }
18252 - for (i = 0; i< func->ffs->ss_descs_count; i++) {
18253 - des_head = func->function.ss_descriptors[i];
18254 - if (des_head->bDescriptorType == USB_DT_INTERFACE_ASSOCIATION) {
18255 - struct usb_interface_assoc_descriptor *a_dec = (struct usb_interface_assoc_descriptor …
18256 - a_dec->bFirstInterface = intf_ctl->bInterfaceNumber;
18257 - } else if (des_head->bDescriptorType == USB_DT_CS_INTERFACE) {
18258 - struct usb_cdc_header_desc *cs_des = (struct usb_cdc_header_desc *)des_head;
18259 - if (cs_des->bDescriptorSubType == USB_CDC_CALL_MANAGEMENT_TYPE) {
18260 - struct usb_cdc_call_mgmt_descriptor *mgmt_des = (struct usb_cdc_call_mgmt_descript…
18261 - mgmt_des->bDataInterface = intf_data->bInterfaceNumber;
18262 - } else if (cs_des->bDescriptorSubType == USB_CDC_UNION_TYPE) {
18263 - struct usb_cdc_union_desc *union_des = (struct usb_cdc_union_desc *)des_head;
18264 - union_des->bMasterInterface0 = intf_ctl->bInterfaceNumber;
18265 - union_des->bSlaveInterface0 = intf_data->bInterfaceNumber;
18266 - } else if (cs_des->bDescriptorSubType == USB_CDC_ETHERNET_TYPE) {
18267 - struct usb_cdc_ether_desc *ether_des = (struct usb_cdc_ether_desc *)des_head;
18268 - ether_des->iMACAddress = intf_ctl->iInterface + 1;
18269 - }
18270 - }
18271 - }
18272 - /* And we're done */
18273 - ffs->eps = func->eps;
18274 - ffs_event_add(ffs, FUNCTIONFS_BIND);
18275 - return 0;
18276 -
18277 -error:
18278 - /* XXX Do we need to release all claimed endpoints here? */
18279 - return ret;
18280 -}
18281 -
18282 -static int ffs_func_bind(struct usb_configuration *c, struct usb_function *f)
18283 -{
18284 - struct f_fs_opts *ffs_opts = ffs_do_functionfs_bind(f, c);
18285 - struct ffs_function *func = ffs_func_from_usb(f);
18286 - int ret;
18287 -
18288 - if (IS_ERR(ffs_opts))
18289 - return PTR_ERR(ffs_opts);
18290 -
18291 - ret = _ffs_func_bind(c, f);
18292 - if (ret && !--ffs_opts->refcnt)
18293 - functionfs_unbind(func->ffs);
18294 -
18295 - return ret;
18296 -}
18297 -
18298 -/* Other USB function hooks *************************************************/
18299 -static void ffs_reset_work(struct work_struct *work)
18300 -{
18301 - struct ffs_data *ffs = container_of(work,
18302 - struct ffs_data, reset_work);
18303 - ffs_data_reset(ffs);
18304 -}
18305 -
18306 -static int ffs_func_set_alt(struct usb_function *f,
18307 - unsigned interface, unsigned alt)
18308 -{
18309 - struct ffs_function *func = ffs_func_from_usb(f);
18310 - struct ffs_data *ffs = func->ffs;
18311 - int ret = 0, intf;
18312 -
18313 - if (alt != (unsigned)-1) {
18314 - intf = ffs_func_revmap_intf(func, interface);
18315 - if (unlikely(intf < 0))
18316 - return intf;
18317 - }
18318 -
18319 - if (ffs->func)
18320 - ffs_func_eps_disable(ffs->func);
18321 -
18322 - if (ffs->state == FFS_DEACTIVATED) {
18323 - ffs->state = FFS_CLOSING;
18324 - INIT_WORK(&ffs->reset_work, ffs_reset_work);
18325 - schedule_work(&ffs->reset_work);
18326 - return -ENODEV;
18327 - }
18328 -
18329 - if (ffs->state != FFS_ACTIVE)
18330 - return -ENODEV;
18331 -
18332 - if (alt == (unsigned)-1) {
18333 - ffs->func = NULL;
18334 - ffs_event_add(ffs, FUNCTIONFS_DISABLE);
18335 - return 0;
18336 - }
18337 -
18338 - ffs->func = func;
18339 - ret = ffs_func_eps_enable(func);
18340 - if (likely(ret >= 0))
18341 - ffs_event_add(ffs, FUNCTIONFS_ENABLE);
18342 - return ret;
18343 -}
18344 -
18345 -static void ffs_func_disable(struct usb_function *f)
18346 -{
18347 - ffs_func_set_alt(f, 0, (unsigned)-1);
18348 -}
18349 -
18350 -static int ffs_func_setup(struct usb_function *f, const struct usb_ctrlrequest *creq)
18351 -{
18352 - struct ffs_function *func = ffs_func_from_usb(f);
18353 - struct ffs_data *ffs = func->ffs;
18354 - unsigned long flags;
18355 - int ret;
18356 -
18357 - ENTER();
18358 -
18359 - pr_vdebug("creq->bRequestType = %02x\n", creq->bRequestType);
18360 - pr_vdebug("creq->bRequest = %02x\n", creq->bRequest);
18361 - pr_vdebug("creq->wValue = %04x\n", le16_to_cpu(creq->wValue));
18362 - pr_vdebug("creq->wIndex = %04x\n", le16_to_cpu(creq->wIndex));
18363 - pr_vdebug("creq->wLength = %04x\n", le16_to_cpu(creq->wLength));
18364 -
18365 - /*
18366 - * Most requests directed to interface go through here
18367 - * (notable exceptions are set/get interface) so we need to
18368 - * handle them. All other either handled by composite or
18369 - * passed to usb_configuration->setup() (if one is set). No
18370 - * matter, we will handle requests directed to endpoint here
18371 - * as well (as it's straightforward). Other request recipient
18372 - * types are only handled when the user flag FUNCTIONFS_ALL_CTRL_RECIP
18373 - * is being used.
18374 - */
18375 - if (ffs->state != FFS_ACTIVE)
18376 - return -ENODEV;
18377 -
18378 - switch (creq->bRequestType & USB_RECIP_MASK) {
18379 - case USB_RECIP_INTERFACE:
18380 - ret = ffs_func_revmap_intf(func, le16_to_cpu(creq->wIndex));
18381 - if (unlikely(ret < 0))
18382 - return ret;
18383 - break;
18384 -
18385 - case USB_RECIP_ENDPOINT:
18386 - ret = ffs_func_revmap_ep(func, le16_to_cpu(creq->wIndex));
18387 - if (unlikely(ret < 0))
18388 - return ret;
18389 - if (func->ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
18390 - ret = func->ffs->eps_addrmap[ret];
18391 - break;
18392 -
18393 - default:
18394 - if (func->ffs->user_flags & FUNCTIONFS_ALL_CTRL_RECIP)
18395 - ret = le16_to_cpu(creq->wIndex);
18396 - else
18397 - return -EOPNOTSUPP;
18398 - }
18399 -
18400 - spin_lock_irqsave(&ffs->ev.waitq.lock, flags);
18401 - ffs->ev.setup = *creq;
18402 - ffs->ev.setup.wIndex = cpu_to_le16(ret);
18403 - __ffs_event_add(ffs, FUNCTIONFS_SETUP);
18404 - spin_unlock_irqrestore(&ffs->ev.waitq.lock, flags);
18405 -
18406 - return creq->wLength == 0 ? USB_GADGET_DELAYED_STATUS : 0;
18407 -}
18408 -
18409 -static bool ffs_func_req_match(struct usb_function *f,
18410 - const struct usb_ctrlrequest *creq,
18411 - bool config0)
18412 -{
18413 - struct ffs_function *func = ffs_func_from_usb(f);
18414 -
18415 - if (config0 && !(func->ffs->user_flags & FUNCTIONFS_CONFIG0_SETUP))
18416 - return false;
18417 -
18418 - switch (creq->bRequestType & USB_RECIP_MASK) {
18419 - case USB_RECIP_INTERFACE:
18420 - return (ffs_func_revmap_intf(func,
18421 - le16_to_cpu(creq->wIndex)) >= 0);
18422 - case USB_RECIP_ENDPOINT:
18423 - return (ffs_func_revmap_ep(func,
18424 - le16_to_cpu(creq->wIndex)) >= 0);
18425 - default:
18426 - return (bool) (func->ffs->user_flags &
18427 - FUNCTIONFS_ALL_CTRL_RECIP);
18428 - }
18429 -}
18430 -
18431 -static void ffs_func_suspend(struct usb_function *f)
18432 -{
18433 - ENTER();
18434 - ffs_event_add(ffs_func_from_usb(f)->ffs, FUNCTIONFS_SUSPEND);
18435 -}
18436 -
18437 -static void ffs_func_resume(struct usb_function *f)
18438 -{
18439 - ENTER();
18440 - ffs_event_add(ffs_func_from_usb(f)->ffs, FUNCTIONFS_RESUME);
18441 -}
18442 -
18443 -/* Endpoint and interface numbers reverse mapping ***************************/
18444 -static int ffs_func_revmap_ep(struct ffs_function *func, u8 num)
18445 -{
18446 - num = func->eps_revmap[num & USB_ENDPOINT_NUMBER_MASK];
18447 - return num ? num : -EDOM;
18448 -}
18449 -
18450 -static int ffs_func_revmap_intf(struct ffs_function *func, u8 intf)
18451 -{
18452 - short *nums = func->interfaces_nums;
18453 - unsigned count = func->ffs->interfaces_count;
18454 -
18455 - for (; count; --count, ++nums) {
18456 - if (*nums >= 0 && *nums == intf)
18457 - return nums - func->interfaces_nums;
18458 - }
18459 -
18460 - return -EDOM;
18461 -}
18462 -
18463 -/* Devices management *******************************************************/
18464 -static LIST_HEAD(ffs_devices);
18465 -
18466 -static struct ffs_dev *_ffs_do_find_dev(const char *name)
18467 -{
18468 - struct ffs_dev *dev = NULL;
18469 -
18470 - if (!name)
18471 - return NULL;
18472 -
18473 - list_for_each_entry(dev, &ffs_devices, entry) {
18474 - if (!dev->name)
18475 - return NULL;
18476 - if (strcmp(dev->name, name) == 0)
18477 - return dev;
18478 - }
18479 -
18480 - return NULL;
18481 -}
18482 -
18483 -/*
18484 - * ffs_lock must be taken by the caller of this function
18485 - */
18486 -static struct ffs_dev *_ffs_get_single_dev(void)
18487 -{
18488 - struct ffs_dev *dev = NULL;
18489 -
18490 - if (list_is_singular(&ffs_devices)) {
18491 - dev = list_first_entry(&ffs_devices, struct ffs_dev, entry);
18492 - if (dev->single)
18493 - return dev;
18494 - }
18495 -
18496 - return NULL;
18497 -}
18498 -
18499 -/*
18500 - * ffs_lock must be taken by the caller of this function
18501 - */
18502 -static struct ffs_dev *_ffs_find_dev(const char *name)
18503 -{
18504 - struct ffs_dev *dev;
18505 -
18506 - dev = _ffs_get_single_dev();
18507 - if (dev)
18508 - return dev;
18509 -
18510 - return _ffs_do_find_dev(name);
18511 -}
18512 -
18513 -/* Configfs support *********************************************************/
18514 -static inline struct f_fs_opts *to_ffs_opts(struct config_item *item)
18515 -{
18516 - return container_of(to_config_group(item), struct f_fs_opts,
18517 - func_inst.group);
18518 -}
18519 -
18520 -static void ffs_attr_release(struct config_item *item)
18521 -{
18522 - struct f_fs_opts *opts = to_ffs_opts(item);
18523 -
18524 - usb_put_function_instance(&opts->func_inst);
18525 -}
18526 -
18527 -static struct configfs_item_operations ffs_item_ops = {
18528 - .release = ffs_attr_release,
18529 -};
18530 -
18531 -static const struct config_item_type ffs_func_type = {
18532 - .ct_item_ops = &ffs_item_ops,
18533 - .ct_owner = THIS_MODULE,
18534 -};
18535 -
18536 -/* Function registration interface ******************************************/
18537 -static void ffs_free_inst(struct usb_function_instance *f)
18538 -{
18539 - struct f_fs_opts *opts;
18540 -
18541 - opts = to_f_fs_opts(f);
18542 - ffs_dev_lock();
18543 - _ffs_free_dev(opts->dev);
18544 - ffs_dev_unlock();
18545 - kfree(opts);
18546 -}
18547 -
18548 -static int ffs_set_inst_name(struct usb_function_instance *fi, const char *name)
18549 -{
18550 - char name_dev[MAX_NAMELEN] = {0};
18551 - if (snprintf(name_dev, MAX_NAMELEN - 1, "%s.%s", FUNCTION_GENERIC, name) < 0) {
18552 - return -EFAULT;
18553 - }
18554 - if (strlen(name_dev) >= sizeof_field(struct ffs_dev, name))
18555 - return -ENAMETOOLONG;
18556 - return ffs_name_dev_adapter(to_f_fs_opts(fi)->dev, name_dev);
18557 -}
18558 -
18559 -static struct usb_function_instance *ffs_alloc_inst(void)
18560 -{
18561 - struct f_fs_opts *opts = NULL;
18562 - struct ffs_dev *dev = NULL;
18563 -
18564 - opts = kzalloc(sizeof(*opts), GFP_KERNEL);
18565 - if (!opts)
18566 - return ERR_PTR(-ENOMEM);
18567 -
18568 - opts->func_inst.set_inst_name = ffs_set_inst_name;
18569 - opts->func_inst.free_func_inst = ffs_free_inst;
18570 - ffs_dev_lock();
18571 - dev = _ffs_alloc_dev();
18572 - ffs_dev_unlock();
18573 - if (IS_ERR(dev)) {
18574 - kfree(opts);
18575 - return ERR_CAST(dev);
18576 - }
18577 - opts->dev = dev;
18578 - dev->opts = opts;
18579 -
18580 - config_group_init_type_name(&opts->func_inst.group, "",
18581 - &ffs_func_type);
18582 - return &opts->func_inst;
18583 -}
18584 -
18585 -static void ffs_free(struct usb_function *f)
18586 -{
18587 - kfree(ffs_func_from_usb(f));
18588 -}
18589 -
18590 -static void ffs_func_unbind(struct usb_configuration *c,
18591 - struct usb_function *f)
18592 -{
18593 - struct ffs_function *func = ffs_func_from_usb(f);
18594 - struct ffs_data *ffs = func->ffs;
18595 - struct f_fs_opts *opts =
18596 - container_of(f->fi, struct f_fs_opts, func_inst);
18597 - struct ffs_ep *ep = func->eps;
18598 - unsigned count = ffs->eps_count;
18599 - unsigned long flags;
18600 -
18601 - ENTER();
18602 - if (ffs->func == func) {
18603 - ffs_func_eps_disable(func);
18604 - ffs->func = NULL;
18605 - }
18606 -
18607 - if (!--opts->refcnt)
18608 - functionfs_unbind(ffs);
18609 -
18610 - /* cleanup after autoconfig */
18611 - spin_lock_irqsave(&func->ffs->eps_lock, flags);
18612 - while (count--) {
18613 - if (ep->ep && ep->req)
18614 - usb_ep_free_request(ep->ep, ep->req);
18615 - ep->req = NULL;
18616 - ++ep;
18617 - }
18618 - spin_unlock_irqrestore(&func->ffs->eps_lock, flags);
18619 - kfree(func->eps);
18620 - func->eps = NULL;
18621 - /*
18622 - * eps, descriptors and interfaces_nums are allocated in the
18623 - * same chunk so only one free is required.
18624 - */
18625 - func->function.fs_descriptors = NULL;
18626 - func->function.hs_descriptors = NULL;
18627 - func->function.ss_descriptors = NULL;
18628 - func->interfaces_nums = NULL;
18629 -
18630 - ffs_event_add(ffs, FUNCTIONFS_UNBIND);
18631 -}
18632 -
18633 -static int ffs_func_get_alt(struct usb_function *f, unsigned intf)
18634 -{
18635 - if (intf == 0)
18636 - return 0;
18637 - return 1;
18638 -}
18639 -
18640 -static struct usb_function *ffs_alloc(struct usb_function_instance *fi)
18641 -{
18642 - struct ffs_function *func = NULL;
18643 -
18644 - ENTER();
18645 -
18646 - func = kzalloc(sizeof(*func), GFP_KERNEL);
18647 - if (unlikely(!func))
18648 - return ERR_PTR(-ENOMEM);
18649 -
18650 - func->function.name = "FunctionFS Adapter";
18651 -
18652 - func->function.bind = ffs_func_bind;
18653 - func->function.unbind = ffs_func_unbind;
18654 - func->function.set_alt = ffs_func_set_alt;
18655 - func->function.get_alt = ffs_func_get_alt;
18656 - func->function.disable = ffs_func_disable;
18657 - func->function.setup = ffs_func_setup;
18658 - func->function.req_match = ffs_func_req_match;
18659 - func->function.suspend = ffs_func_suspend;
18660 - func->function.resume = ffs_func_resume;
18661 - func->function.free_func = ffs_free;
18662 -
18663 - return &func->function;
18664 -}
18665 -
18666 -/*
18667 - * ffs_lock must be taken by the caller of this function
18668 - */
18669 -static struct ffs_dev *_ffs_alloc_dev(void)
18670 -{
18671 - struct ffs_dev *dev = NULL;
18672 - int ret;
18673 -
18674 - if (_ffs_get_single_dev())
18675 - return ERR_PTR(-EBUSY);
18676 -
18677 - dev = kzalloc(sizeof(*dev), GFP_KERNEL);
18678 - if (!dev)
18679 - return ERR_PTR(-ENOMEM);
18680 -
18681 - if (list_empty(&ffs_devices)) {
18682 - ret = functionfs_init();
18683 - if (ret) {
18684 - kfree(dev);
18685 - return ERR_PTR(ret);
18686 - }
18687 - }
18688 -
18689 - list_add(&dev->entry, &ffs_devices);
18690 -
18691 - return dev;
18692 -}
18693 -
18694 -int ffs_name_dev_adapter(struct ffs_dev *dev, const char *name)
18695 -{
18696 - struct ffs_dev *existing = NULL;
18697 - int ret = 0;
18698 -
18699 - ffs_dev_lock();
18700 -
18701 - existing = _ffs_do_find_dev(name);
18702 - if (!existing)
18703 - strlcpy(dev->name, name, ARRAY_SIZE(dev->name));
18704 - else if (existing != dev)
18705 - ret = -EBUSY;
18706 -
18707 - ffs_dev_unlock();
18708 -
18709 - return ret;
18710 -}
18711 -EXPORT_SYMBOL_GPL(ffs_name_dev_adapter);
18712 -
18713 -int ffs_single_dev_adapter(struct ffs_dev *dev)
18714 -{
18715 - int ret;
18716 -
18717 - ret = 0;
18718 - ffs_dev_lock();
18719 -
18720 - if (!list_is_singular(&ffs_devices))
18721 - ret = -EBUSY;
18722 - else
18723 - dev->single = true;
18724 -
18725 - ffs_dev_unlock();
18726 - return ret;
18727 -}
18728 -EXPORT_SYMBOL_GPL(ffs_single_dev_adapter);
18729 -/*
18730 - * ffs_lock must be taken by the caller of this function
18731 - */
18732 -static void _ffs_free_dev(struct ffs_dev *dev)
18733 -{
18734 - list_del(&dev->entry);
18735 -
18736 - /* Clear the private_data pointer to stop incorrect dev access */
18737 - if (dev->ffs_data)
18738 - dev->ffs_data->private_data = NULL;
18739 -
18740 - kfree(dev);
18741 - if (list_empty(&ffs_devices))
18742 - functionfs_cleanup();
18743 -}
18744 -
18745 -static void *ffs_acquire_dev(const char *dev_name)
18746 -{
18747 - struct ffs_dev *ffs_dev = NULL;
18748 -
18749 - ENTER();
18750 - ffs_dev_lock();
18751 -
18752 - ffs_dev = _ffs_find_dev(dev_name);
18753 - if (!ffs_dev)
18754 - ffs_dev = ERR_PTR(-ENOENT);
18755 - else if (ffs_dev->mounted)
18756 - ffs_dev = ERR_PTR(-EBUSY);
18757 - else if (ffs_dev->ffs_acquire_dev_callback &&
18758 - ffs_dev->ffs_acquire_dev_callback(ffs_dev))
18759 - ffs_dev = ERR_PTR(-ENOENT);
18760 - else
18761 - ffs_dev->mounted = true;
18762 -
18763 - ffs_dev_unlock();
18764 - return ffs_dev;
18765 -}
18766 -
18767 -static void ffs_release_dev(struct ffs_data *ffs_data)
18768 -{
18769 - struct ffs_dev *ffs_dev = NULL;
18770 -
18771 - ENTER();
18772 - ffs_dev_lock();
18773 -
18774 - ffs_dev = ffs_data->private_data;
18775 - if (ffs_dev) {
18776 - ffs_dev->mounted = false;
18777 -
18778 - if (ffs_dev->ffs_release_dev_callback)
18779 - ffs_dev->ffs_release_dev_callback(ffs_dev);
18780 - }
18781 -
18782 - ffs_dev_unlock();
18783 -}
18784 -
18785 -static int ffs_ready(struct ffs_data *ffs)
18786 -{
18787 - struct ffs_dev *ffs_obj = NULL;
18788 - int ret = 0;
18789 -
18790 - ENTER();
18791 - ffs_dev_lock();
18792 -
18793 - ffs_obj = ffs->private_data;
18794 - if (!ffs_obj) {
18795 - ret = -EINVAL;
18796 - goto done;
18797 - }
18798 - if (WARN_ON(ffs_obj->desc_ready)) {
18799 - ret = -EBUSY;
18800 - goto done;
18801 - }
18802 -
18803 - ffs_obj->desc_ready = true;
18804 - ffs_obj->ffs_data = ffs;
18805 -
18806 - if (ffs_obj->ffs_ready_callback) {
18807 - ret = ffs_obj->ffs_ready_callback(ffs);
18808 - if (ret)
18809 - goto done;
18810 - }
18811 -
18812 - set_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags);
18813 -done:
18814 - ffs_dev_unlock();
18815 - return ret;
18816 -}
18817 -
18818 -static void ffs_closed(struct ffs_data *ffs)
18819 -{
18820 - struct ffs_dev *ffs_obj = NULL;
18821 - struct f_fs_opts *opts = NULL;
18822 - struct config_item *ci = NULL;
18823 -
18824 - ENTER();
18825 - ffs_dev_lock();
18826 -
18827 - ffs_obj = ffs->private_data;
18828 - if (!ffs_obj)
18829 - goto done;
18830 -
18831 - ffs_obj->desc_ready = false;
18832 - ffs_obj->ffs_data = NULL;
18833 -
18834 - if (test_and_clear_bit(FFS_FL_CALL_CLOSED_CALLBACK, &ffs->flags) &&
18835 - ffs_obj->ffs_closed_callback)
18836 - ffs_obj->ffs_closed_callback(ffs);
18837 -
18838 - if (ffs_obj->opts)
18839 - opts = ffs_obj->opts;
18840 - else
18841 - goto done;
18842 -
18843 - if (opts->no_configfs || !opts->func_inst.group.cg_item.ci_parent
18844 - || !kref_read(&opts->func_inst.group.cg_item.ci_kref))
18845 - goto done;
18846 -
18847 - ci = opts->func_inst.group.cg_item.ci_parent->ci_parent;
18848 - ffs_dev_unlock();
18849 -
18850 - if (test_bit(FFS_FL_BOUND, &ffs->flags))
18851 - unregister_gadget_item(ci);
18852 - return;
18853 -done:
18854 - ffs_dev_unlock();
18855 -}
18856 -
18857 -/* Misc helper functions ****************************************************/
18858 -static int ffs_mutex_lock(struct mutex *mutex, unsigned nonblock)
18859 -{
18860 - return nonblock
18861 - ? likely(mutex_trylock(mutex)) ? 0 : -EAGAIN
18862 - : mutex_lock_interruptible(mutex);
18863 -}
18864 -
18865 -static char *ffs_prepare_buffer(const char __user *buf, size_t len)
18866 -{
18867 - char *data = NULL;
18868 -
18869 - if (unlikely(!len))
18870 - return NULL;
18871 -
18872 - data = kmalloc(len, GFP_KERNEL);
18873 - if (unlikely(!data))
18874 - return ERR_PTR(-ENOMEM);
18875 -
18876 - if (unlikely(copy_from_user(data, buf, len))) {
18877 - kfree(data);
18878 - return ERR_PTR(-EFAULT);
18879 - }
18880 -
18881 - pr_vdebug("Buffer from user space:\n");
18882 - ffs_dump_mem("", data, len);
18883 -
18884 - return data;
18885 -}
18886 -
18887 -DECLARE_USB_FUNCTION_INIT(f_generic, ffs_alloc_inst, ffs_alloc);
18888 -MODULE_LICENSE("GPL");
18890 diff -Naur a/drivers/usb/gadget/function/u_generic.h b/drivers/usb/gadget/function/u_generic.h
18891 --- a/drivers/usb/gadget/function/u_generic.h 2022-06-28 19:20:24.331709124 +0800
18892 +++ b/drivers/usb/gadget/function/u_generic.h 1970-01-01 08:00:00.000000000 +0800
18893 @@ -1,356 +0,0 @@
18894 -// SPDX-License-Identifier: GPL-2.0
18895 -/*
18896 - * u_fs.h
18897 - *
18898 - * Utility definitions for the FunctionFS
18899 - *
18900 - * Copyright (c) 2013 Samsung Electronics Co., Ltd.
18901 - * http://www.samsung.com
18902 - *
18903 - * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
18904 - */
18905 -
18906 -#ifndef U_GENERIC_H
18907 -#define U_GENERIC_H
18908 -
18909 -#include <linux/usb/composite.h>
18910 -#include <linux/list.h>
18911 -#include <linux/mutex.h>
18912 -#include <linux/workqueue.h>
18913 -#include <linux/refcount.h>
18914 -#include <linux/cdev.h>
18915 -#ifdef VERBOSE_DEBUG
18916 -#ifndef pr_vdebug
18917 -# define pr_vdebug pr_debug
18918 -#endif /* pr_vdebug */
18919 -# define ffs_dump_mem(prefix, ptr, len) \
18920 - print_hex_dump_bytes(pr_fmt(prefix ": "), DUMP_PREFIX_NONE, ptr, len)
18921 -#else
18922 -#ifndef pr_vdebug
18923 -# define pr_vdebug(...) do { } while (0)
18924 -#endif /* pr_vdebug */
18925 -# define ffs_dump_mem(prefix, ptr, len) do { } while (0)
18926 -#endif /* VERBOSE_DEBUG */
18927 -
18928 -#define ENTER() pr_vdebug("%s()\n", __func__)
18929 -
18930 -#define MAX_REQUEST 64
18931 -#define MAX_NAMELEN 64
18932 -#define FUNCTION_GENERIC "f_generic"
18933 -
18934 -struct FuncNew {
18935 - uint32_t nameLen;
18936 - char name[MAX_NAMELEN];
18937 -};
18938 -
18939 -struct IoData {
18940 - uint32_t aio;
18941 - uint32_t read;
18942 - uint32_t len;
18943 - uint32_t timeout;
18944 - uint64_t buf;
18945 -};
18946 -
18947 -struct UsbFnReqEvent {
18948 - uint64_t buf;
18949 - uint32_t actual;
18950 - int status;
18951 -};
18952 -
18953 -struct ffs_memory{
18954 - uint64_t mem;
18955 - uint64_t vm_start;
18956 - uint32_t size;
18957 - struct list_head memlist;
18958 -};
18959 -
18960 -struct generic_memory{
18961 - uint32_t size;
18962 - uint64_t buf;
18963 -};
18964 -
18965 -
18966 -#define FUNCTIONFS_NEWFN _IOW('g', 60, struct FuncNew)
18967 -#define FUNCTIONFS_DELFN _IOW('g', 61, struct FuncNew)
18968 -#define FUNCTIONFS_ENDPOINT_GET_REQ_STATUS _IOW('g', 48, struct IoData)
18969 -#define FUNCTIONFS_ENDPOINT_WRITE _IOW('g', 49, struct IoData)
18970 -#define FUNCTIONFS_ENDPOINT_READ _IOW('g', 50, struct IoData)
18971 -#define FUNCTIONFS_ENDPOINT_RW_CANCEL _IOW('g', 51, struct IoData)
18972 -#define FUNCTIONFS_ENDPOINT_QUEUE_INIT _IO('g', 52)
18973 -#define FUNCTIONFS_ENDPOINT_QUEUE_DEL _IO('g', 53)
18974 -#define FUNCTIONFS_ENDPOINT_RELEASE_BUF _IOR('g', 54, struct generic_memory)
18975 -#define FUNCTIONFS_ENDPOINT_GET_EP0_EVENT _IOR('g', 56, struct UsbFnReqEvent)
18976 -
18977 -struct f_fs_opts;
18978 -
18979 -struct ffs_dev {
18980 - struct ffs_data *ffs_data;
18981 - struct f_fs_opts *opts;
18982 - struct list_head entry;
18983 -
18984 - char name[MAX_NAMELEN];
18985 -
18986 - bool mounted;
18987 - bool desc_ready;
18988 - bool single;
18989 -
18990 - int (*ffs_ready_callback)(struct ffs_data *ffs);
18991 - void (*ffs_closed_callback)(struct ffs_data *ffs);
18992 - void *(*ffs_acquire_dev_callback)(struct ffs_dev *dev);
18993 - void (*ffs_release_dev_callback)(struct ffs_dev *dev);
18994 -};
18995 -
18996 -extern struct mutex ffs_lock_adapter;
18997 -
18998 -static inline void ffs_dev_lock(void)
18999 -{
19000 - mutex_lock(&ffs_lock_adapter);
19001 -}
19002 -
19003 -static inline void ffs_dev_unlock(void)
19004 -{
19005 - mutex_unlock(&ffs_lock_adapter);
19006 -}
19007 -
19008 -int ffs_name_dev_adapter(struct ffs_dev *dev, const char *name);
19009 -int ffs_single_dev_adapter(struct ffs_dev *dev);
19010 -
19011 -struct ffs_epfile;
19012 -struct ffs_function;
19013 -
19014 -enum ffs_state {
19015 - /*
19016 - * Waiting for descriptors and strings.
19017 - *
19018 - * In this state no open(2), read(2) or write(2) on epfiles
19019 - * may succeed (which should not be the problem as there
19020 - * should be no such files opened in the first place).
19021 - */
19022 - FFS_READ_DESCRIPTORS,
19023 - FFS_READ_STRINGS,
19024 -
19025 - /*
19026 - * We've got descriptors and strings. We are or have called
19027 - * functionfs_ready_callback(). functionfs_bind() may have
19028 - * been called but we don't know.
19029 - *
19030 - * This is the only state in which operations on epfiles may
19031 - * succeed.
19032 - */
19033 - FFS_ACTIVE,
19034 -
19035 - /*
19036 - * Function is visible to host, but it's not functional. All
19037 - * setup requests are stalled and transfers on another endpoints
19038 - * are refused. All epfiles, except ep0, are deleted so there
19039 - * is no way to perform any operations on them.
19040 - *
19041 - * This state is set after closing all functionfs files, when
19042 - * mount parameter "no_disconnect=1" has been set. Function will
19043 - * remain in deactivated state until filesystem is umounted or
19044 - * ep0 is opened again. In the second case functionfs state will
19045 - * be reset, and it will be ready for descriptors and strings
19046 - * writing.
19047 - *
19048 - * This is useful only when functionfs is composed to gadget
19049 - * with another function which can perform some critical
19050 - * operations, and it's strongly desired to have this operations
19051 - * completed, even after functionfs files closure.
19052 - */
19053 - FFS_DEACTIVATED,
19054 -
19055 - /*
19056 - * All endpoints have been closed. This state is also set if
19057 - * we encounter an unrecoverable error. The only
19058 - * unrecoverable error is situation when after reading strings
19059 - * from user space we fail to initialise epfiles or
19060 - * functionfs_ready_callback() returns with error (<0).
19061 - *
19062 - * In this state no open(2), read(2) or write(2) (both on ep0
19063 - * as well as epfile) may succeed (at this point epfiles are
19064 - * unlinked and all closed so this is not a problem; ep0 is
19065 - * also closed but ep0 file exists and so open(2) on ep0 must
19066 - * fail).
19067 - */
19068 - FFS_CLOSING
19069 -};
19070 -
19071 -enum ffs_setup_state {
19072 - /* There is no setup request pending. */
19073 - FFS_NO_SETUP,
19074 - /*
19075 - * User has read events and there was a setup request event
19076 - * there. The next read/write on ep0 will handle the
19077 - * request.
19078 - */
19079 - FFS_SETUP_PENDING,
19080 - /*
19081 - * There was event pending but before user space handled it
19082 - * some other event was introduced which canceled existing
19083 - * setup. If this state is set read/write on ep0 return
19084 - * -EIDRM. This state is only set when adding event.
19085 - */
19086 - FFS_SETUP_CANCELLED
19087 -};
19088 -
19089 -struct ffs_data {
19090 - struct usb_gadget *gadget;
19091 - struct list_head entry;
19092 - struct list_head memory_list;
19093 - /*
19094 - * Protect access read/write operations, only one read/write
19095 - * at a time. As a consequence protects ep0req and company.
19096 - * While setup request is being processed (queued) this is
19097 - * held.
19098 - */
19099 - struct mutex mutex;
19100 -
19101 - /*
19102 - * Protect access to endpoint related structures (basically
19103 - * usb_ep_queue(), usb_ep_dequeue(), etc. calls) except for
19104 - * endpoint zero.
19105 - */
19106 - spinlock_t eps_lock;
19107 - spinlock_t mem_lock;
19108 -
19109 - /*
19110 - * XXX REVISIT do we need our own request? Since we are not
19111 - * handling setup requests immediately user space may be so
19112 - * slow that another setup will be sent to the gadget but this
19113 - * time not to us but another function and then there could be
19114 - * a race. Is that the case? Or maybe we can use cdev->req
19115 - * after all, maybe we just need some spinlock for that?
19116 - */
19117 - struct usb_request *ep0req; /* P: mutex */
19118 - struct completion ep0req_completion; /* P: mutex */
19119 -
19120 - /* reference counter */
19121 - refcount_t ref;
19122 - /* how many files are opened (EP0 and others) */
19123 - atomic_t opened;
19124 -
19125 - /* EP0 state */
19126 - enum ffs_state state;
19127 -
19128 - /*
19129 - * Possible transitions:
19130 - * + FFS_NO_SETUP -> FFS_SETUP_PENDING -- P: ev.waitq.lock
19131 - * happens only in ep0 read which is P: mutex
19132 - * + FFS_SETUP_PENDING -> FFS_NO_SETUP -- P: ev.waitq.lock
19133 - * happens only in ep0 i/o which is P: mutex
19134 - * + FFS_SETUP_PENDING -> FFS_SETUP_CANCELLED -- P: ev.waitq.lock
19135 - * + FFS_SETUP_CANCELLED -> FFS_NO_SETUP -- cmpxchg
19136 - *
19137 - * This field should never be accessed directly and instead
19138 - * ffs_setup_state_clear_cancelled function should be used.
19139 - */
19140 - enum ffs_setup_state setup_state;
19141 -
19142 - /* Events & such. */
19143 - struct {
19144 - u8 types[4];
19145 - unsigned short count;
19146 - /* XXX REVISIT need to update it in some places, or do we? */
19147 - unsigned short can_stall;
19148 - struct usb_ctrlrequest setup;
19149 -
19150 - wait_queue_head_t waitq;
19151 - } ev; /* the whole structure, P: ev.waitq.lock */
19152 -
19153 - /* Flags */
19154 - unsigned long flags;
19155 -#define FFS_FL_CALL_CLOSED_CALLBACK 0
19156 -#define FFS_FL_BOUND 1
19157 -
19158 - /* For waking up blocked threads when function is enabled. */
19159 - wait_queue_head_t wait;
19160 -
19161 - /* Active function */
19162 - struct ffs_function *func;
19163 -
19164 -
19165 - char dev_name[MAX_NAMELEN];
19166 - struct cdev cdev;
19167 - dev_t devno;
19168 - struct device *fn_device;
19169 -
19170 - struct kfifo reqEventFifo;
19171 - wait_queue_head_t wait_que;
19172 - /* Private data for our user (ie. gadget). Managed by user. */
19173 - void *private_data;
19174 - /* filled by __ffs_data_got_descs() */
19175 - /*
19176 - * raw_descs is what you kfree, real_descs points inside of raw_descs,
19177 - * where full speed, high speed and super speed descriptors start.
19178 - * real_descs_length is the length of all those descriptors.
19179 - */
19180 - const void *raw_descs_data;
19181 - const void *raw_descs;
19182 - unsigned raw_descs_length;
19183 - unsigned fs_descs_count;
19184 - unsigned hs_descs_count;
19185 - unsigned ss_descs_count;
19186 - unsigned ms_os_descs_count;
19187 - unsigned ms_os_descs_ext_prop_count;
19188 - unsigned ms_os_descs_ext_prop_name_len;
19189 - unsigned ms_os_descs_ext_prop_data_len;
19190 - void *ms_os_descs_ext_prop_avail;
19191 - void *ms_os_descs_ext_prop_name_avail;
19192 - void *ms_os_descs_ext_prop_data_avail;
19193 -
19194 - unsigned user_flags;
19195 -
19196 -#define FFS_MAX_EPS_COUNT 31
19197 - u8 eps_addrmap[FFS_MAX_EPS_COUNT];
19198 -
19199 - unsigned short strings_count;
19200 - unsigned short interfaces_count;
19201 - unsigned short eps_count;
19202 - unsigned short _pad1;
19203 -
19204 - /* filled by __ffs_data_got_strings() */
19205 - /* ids in stringtabs are set in functionfs_bind() */
19206 - const void *raw_strings;
19207 - struct usb_gadget_strings **stringtabs;
19208 -
19209 - /*
19210 - * File system's super block, write once when file system is
19211 - * mounted.
19212 - */
19213 - struct super_block *sb;
19214 -
19215 - /* File permissions, written once when fs is mounted */
19216 - struct ffs_file_perms {
19217 - umode_t mode;
19218 - kuid_t uid;
19219 - kgid_t gid;
19220 - } file_perms;
19221 -
19222 - struct eventfd_ctx *ffs_eventfd;
19223 - struct workqueue_struct *io_completion_wq;
19224 - bool no_disconnect;
19225 - struct work_struct reset_work;
19226 -
19227 - /*
19228 - * The endpoint files, filled by ffs_epfiles_create(),
19229 - * destroyed by ffs_epfiles_destroy().
19230 - */
19231 - struct ffs_epfile *epfiles;
19232 - struct ffs_ep *eps;
19233 - enum usb_device_speed speed;
19234 -};
19235 -
19236 -
19237 -struct f_fs_opts {
19238 - struct usb_function_instance func_inst;
19239 - struct ffs_dev *dev;
19240 - unsigned refcnt;
19241 - bool no_configfs;
19242 -};
19243 -
19244 -static inline struct f_fs_opts *to_f_fs_opts(struct usb_function_instance *fi)
19245 -{
19246 - return container_of(fi, struct f_fs_opts, func_inst);
19247 -}
19248 -
19249 -#endif /* U_GENERIC_H */
19251 diff -Naur a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
19252 --- a/drivers/usb/gadget/Kconfig 2022-05-27 17:20:17.673927851 +0800
19253 +++ b/drivers/usb/gadget/Kconfig 2022-05-31 11:56:48.085256221 +0800
19254 @@ -216,6 +216,12 @@
19264 # this first set of drivers all depend on bulk-capable hardware.
19267 @@ -230,6 +236,14 @@
19282 @@ -371,6 +385,23 @@
19306 diff -Naur a/drivers/usb/gadget/udc/core.c b/drivers/usb/gadget/udc/core.c
19307 --- a/drivers/usb/gadget/udc/core.c 2022-05-27 17:20:17.685928005 +0800
19308 +++ b/drivers/usb/gadget/udc/core.c 2022-05-31 11:56:48.085256221 +0800
19309 @@ -755,7 +755,7 @@
19313 - if (gadget->deactivated)
19314 + if (!gadget || gadget->deactivated)
19317 if (gadget->connected) {
19318 diff -Naur a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
19319 --- a/drivers/usb/serial/ch341.c 2022-05-27 17:20:17.725928520 +0800
19320 +++ b/drivers/usb/serial/ch341.c 2022-05-31 11:56:48.085256221 +0800
19321 @@ -85,6 +85,7 @@
19329 diff -Naur a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
19330 --- a/drivers/usb/serial/keyspan.c 2022-06-30 21:35:01.828331831 +0800
19331 +++ b/drivers/usb/serial/keyspan.c 2022-05-27 17:20:17.729928572 +0800
19332 @@ -2910,22 +2910,22 @@
19333 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i) {
19334 p_priv->in_buffer[i] = kzalloc(IN_BUFLEN, GFP_KERNEL);
19335 if (!p_priv->in_buffer[i])
19336 - goto err_free_in_buffer;
19340 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i) {
19341 p_priv->out_buffer[i] = kzalloc(OUT_BUFLEN, GFP_KERNEL);
19342 if (!p_priv->out_buffer[i])
19343 - goto err_free_out_buffer;
19347 p_priv->inack_buffer = kzalloc(INACK_BUFLEN, GFP_KERNEL);
19348 if (!p_priv->inack_buffer)
19349 - goto err_free_out_buffer;
19352 p_priv->outcont_buffer = kzalloc(OUTCONT_BUFLEN, GFP_KERNEL);
19353 if (!p_priv->outcont_buffer)
19354 - goto err_free_inack_buffer;
19357 p_priv->device_details = d_details;
19359 @@ -2971,14 +2971,15 @@
19363 -err_free_inack_buffer:
19365 kfree(p_priv->inack_buffer);
19366 -err_free_out_buffer:
19368 for (i = 0; i < ARRAY_SIZE(p_priv->out_buffer); ++i)
19369 kfree(p_priv->out_buffer[i]);
19370 -err_free_in_buffer:
19372 for (i = 0; i < ARRAY_SIZE(p_priv->in_buffer); ++i)
19373 kfree(p_priv->in_buffer[i]);
19377 return -ENOMEM;
19378 diff -Naur a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c
19379 --- a/drivers/video/fbdev/core/fbcon.c 2022-05-27 17:20:17.765929037 +0800
19380 +++ b/drivers/video/fbdev/core/fbcon.c 2022-05-31 11:56:48.085256221 +0800
19381 @@ -365,6 +365,7 @@
19387 struct fbcon_ops *ops = info->fbcon_par;
19389 @@ -395,6 +396,7 @@
19390 ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
19397 @@ -1328,6 +1330,7 @@
19402 struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
19403 struct fbcon_ops *ops = info->fbcon_par;
19404 int c = scr_readw((u16 *) vc->vc_pos);
19405 @@ -1349,6 +1352,7 @@
19407 ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
19413 diff -Naur a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
19414 --- a/drivers/video/fbdev/core/fbmem.c 2022-05-27 17:20:17.765929037 +0800
19415 +++ b/drivers/video/fbdev/core/fbmem.c 2022-05-31 11:56:48.089256185 +0800
19416 @@ -53,9 +53,9 @@
19420 -bool fb_center_logo __read_mostly;
19423 -int fb_logo_count __read_mostly = -1;
19428 diff -Naur a/fs/notify/fanotify/fanotify_user.c b/fs/notify/fanotify/fanotify_user.c
19429 --- a/fs/notify/fanotify/fanotify_user.c 2022-06-21 15:22:57.075397772 +0800
19430 +++ b/fs/notify/fanotify/fanotify_user.c 2022-05-27 17:20:17.989931926 +0800
19431 @@ -366,6 +366,9 @@
19432 if (fanotify_is_perm_event(event->mask))
19433 FANOTIFY_PERM(event)->fd = fd;
19440 info_type = info->name_len ? FAN_EVENT_INFO_TYPE_DFID_NAME :
19441 @@ -429,9 +432,6 @@
19442 count -= ret;
19445 - if (f)
19446 - fd_install(fd, f);
19447 -
19451 diff -Naur a/include/drm/bridge/dw_hdmi.h b/include/drm/bridge/dw_hdmi.h
19452 --- a/include/drm/bridge/dw_hdmi.h 2022-05-27 17:20:18.077933060 +0800
19453 +++ b/include/drm/bridge/dw_hdmi.h 2022-05-31 11:56:48.089256185 +0800
19454 @@ -126,6 +126,8 @@
19463 @@ -153,6 +155,8 @@
19472 diff -Naur a/include/drm/bridge/dw_mipi_dsi.h b/include/drm/bridge/dw_mipi_dsi.h
19473 --- a/include/drm/bridge/dw_mipi_dsi.h 2022-05-27 17:20:18.077933060 +0800
19474 +++ b/include/drm/bridge/dw_mipi_dsi.h 2022-05-31 11:56:48.089256185 +0800
19475 @@ -51,7 +51,9 @@
19479 - const struct drm_display_mode *mode);
19486 diff -Naur a/include/drm/drm_aperture.h b/include/drm/drm_aperture.h
19487 --- a/include/drm/drm_aperture.h 1970-01-01 08:00:00.000000000 +0800
19488 +++ b/include/drm/drm_aperture.h 2022-05-31 11:56:48.089256185 +0800
19489 @@ -0,0 +1,39 @@
19490 +/* SPDX-License-Identifier: MIT */
19511 + * drm_aperture_remove_framebuffers - remove all existing framebuffers
19524 + return drm_aperture_remove_conflicting_framebuffers(0, (resource_size_t)-1, primary,
19529 diff -Naur a/include/drm/drm_atomic_helper.h b/include/drm/drm_atomic_helper.h
19530 --- a/include/drm/drm_atomic_helper.h 2022-05-27 17:20:18.077933060 +0800
19531 +++ b/include/drm/drm_atomic_helper.h 2022-05-31 11:56:48.089256185 +0800
19532 @@ -167,7 +167,7 @@
19533 drm_for_each_plane_mask(plane, (crtc)->dev, (crtc)->state->plane_mask)
19536 - * drm_crtc_atomic_state_for_each_plane - iterate over attached planes in new state
19537 + * drm_atomic_crtc_state_for_each_plane - iterate over attached planes in new state
19541 @@ -180,7 +180,7 @@
19542 drm_for_each_plane_mask(plane, (crtc_state)->state->dev, (crtc_state)->plane_mask)
19545 - * drm_crtc_atomic_state_for_each_plane_state - iterate over attached planes in new state
19546 + * drm_atomic_crtc_state_for_each_plane_state - iterate over attached planes in new state
19550 diff -Naur a/include/drm/drm_connector.h b/include/drm/drm_connector.h
19551 --- a/include/drm/drm_connector.h 2022-05-27 17:20:18.077933060 +0800
19552 +++ b/include/drm/drm_connector.h 2022-05-31 11:56:48.089256185 +0800
19553 @@ -1622,6 +1622,9 @@
19563 diff -Naur a/include/dt-bindings/clock/g12a-clkc.h b/include/dt-bindings/clock/g12a-clkc.h
19564 --- a/include/dt-bindings/clock/g12a-clkc.h 2022-05-27 17:20:18.089933214 +0800
19565 +++ b/include/dt-bindings/clock/g12a-clkc.h 2022-05-31 11:56:48.093256151 +0800
19566 @@ -147,5 +147,23 @@
19590 diff -Naur a/include/linux/amlogic/aml_gpio_consumer.h b/include/linux/amlogic/aml_gpio_consumer.h
19591 --- a/include/linux/amlogic/aml_gpio_consumer.h 1970-01-01 08:00:00.000000000 +0800
19592 +++ b/include/linux/amlogic/aml_gpio_consumer.h 2022-05-31 11:56:48.093256151 +0800
19593 @@ -0,0 +1,43 @@
19594 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
19637 diff -Naur a/include/linux/amlogic/aml_key.h b/include/linux/amlogic/aml_key.h
19638 --- a/include/linux/amlogic/aml_key.h 1970-01-01 08:00:00.000000000 +0800
19639 +++ b/include/linux/amlogic/aml_key.h 2022-05-31 11:56:48.093256151 +0800
19640 @@ -0,0 +1,76 @@
19641 +/* SPDX-License-Identifier: LGPL-2.1+ WITH Linux-syscall-note */
19717 diff -Naur a/include/linux/amlogic/aml_sd.h b/include/linux/amlogic/aml_sd.h
19718 --- a/include/linux/amlogic/aml_sd.h 1970-01-01 08:00:00.000000000 +0800
19719 +++ b/include/linux/amlogic/aml_sd.h 2022-05-31 11:56:48.093256151 +0800
19720 @@ -0,0 +1,424 @@
19721 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
19757 +#define aml_card_type_unknown(c) ((c)->card_type == CARD_TYPE_UNKNOWN)
19758 +#define aml_card_type_mmc(c) ((c)->card_type == CARD_TYPE_MMC)
19759 +#define aml_card_type_sd(c) ((c)->card_type == CARD_TYPE_SD)
19760 +#define aml_card_type_sdio(c) ((c)->card_type == CARD_TYPE_SDIO)
19761 +#define aml_card_type_non_sdio(c) ((c)->card_type == CARD_TYPE_NON_SDIO)
19932 +#define DRIVER_NAME "meson-gx-mmc"
19952 +#define CLK_TX_DELAY_MASK(h) ((h)->data->tx_delay_mask)
19953 +#define CLK_RX_DELAY_MASK(h) ((h)->data->rx_delay_mask)
19954 +#define CLK_ALWAYS_ON(h) ((h)->data->always_on)
20145 diff -Naur a/include/linux/amlogic/bt_device.h b/include/linux/amlogic/bt_device.h
20146 --- a/include/linux/amlogic/bt_device.h 1970-01-01 08:00:00.000000000 +0800
20147 +++ b/include/linux/amlogic/bt_device.h 2022-05-31 11:56:48.093256151 +0800
20148 @@ -0,0 +1,26 @@
20149 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
20175 diff -Naur a/include/linux/amlogic/cpu_info.h b/include/linux/amlogic/cpu_info.h
20176 --- a/include/linux/amlogic/cpu_info.h 1970-01-01 08:00:00.000000000 +0800
20177 +++ b/include/linux/amlogic/cpu_info.h 2022-05-31 11:56:48.093256151 +0800
20178 @@ -0,0 +1,12 @@
20179 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
20191 diff -Naur a/include/linux/amlogic/cpu_version.h b/include/linux/amlogic/cpu_version.h
20192 --- a/include/linux/amlogic/cpu_version.h 1970-01-01 08:00:00.000000000 +0800
20193 +++ b/include/linux/amlogic/cpu_version.h 2022-05-31 11:56:48.093256151 +0800
20194 @@ -0,0 +1,234 @@
20251 + return -1;
20429 diff -Naur a/include/linux/amlogic/efuse.h b/include/linux/amlogic/efuse.h
20430 --- a/include/linux/amlogic/efuse.h 1970-01-01 08:00:00.000000000 +0800
20431 +++ b/include/linux/amlogic/efuse.h 2022-05-31 11:56:48.093256151 +0800
20432 @@ -0,0 +1,37 @@
20470 diff -Naur a/include/linux/amlogic/i2c-amlogic.h b/include/linux/amlogic/i2c-amlogic.h
20471 --- a/include/linux/amlogic/i2c-amlogic.h 1970-01-01 08:00:00.000000000 +0800
20472 +++ b/include/linux/amlogic/i2c-amlogic.h 2022-05-31 11:56:48.093256151 +0800
20473 @@ -0,0 +1,34 @@
20475 + * include/linux/amlogic/i2c-amlogic.h
20508 diff -Naur a/include/linux/amlogic/iomap.h b/include/linux/amlogic/iomap.h
20509 --- a/include/linux/amlogic/iomap.h 1970-01-01 08:00:00.000000000 +0800
20510 +++ b/include/linux/amlogic/iomap.h 2022-05-31 11:56:48.093256151 +0800
20511 @@ -0,0 +1,129 @@
20631 + unsigned int mask = (((1L << len) - 1) << start);
20641 diff -Naur a/include/linux/amlogic/key_manage.h b/include/linux/amlogic/key_manage.h
20642 --- a/include/linux/amlogic/key_manage.h 1970-01-01 08:00:00.000000000 +0800
20643 +++ b/include/linux/amlogic/key_manage.h 2022-05-31 11:56:48.093256151 +0800
20644 @@ -0,0 +1,28 @@
20645 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
20673 diff -Naur a/include/linux/amlogic/media/canvas/canvas.h b/include/linux/amlogic/media/canvas/canva…
20674 --- a/include/linux/amlogic/media/canvas/canvas.h 1970-01-01 08:00:00.000000000 +0800
20675 +++ b/include/linux/amlogic/media/canvas/canvas.h 2022-05-31 11:56:48.093256151 +0800
20676 @@ -0,0 +1,94 @@
20739 +#define PPMGR2_CANVAS_INDEX 0x70 /* 0x70-0x7f for PPMGR2 (IONVIDEO)/ */
20771 diff -Naur a/include/linux/amlogic/media/codec_mm/codec_mm.h b/include/linux/amlogic/media/codec_mm…
20772 --- a/include/linux/amlogic/media/codec_mm/codec_mm.h 1970-01-01 08:00:00.000000000 +0800
20773 +++ b/include/linux/amlogic/media/codec_mm/codec_mm.h 2022-05-31 11:56:48.093256151 +0800
20774 @@ -0,0 +1,167 @@
20794 +#include <linux/dma-direction.h>
20811 +*cma->then ..reserved.
20849 +/*--------------------------------------------------*/
20909 +/*---------------------------------------------------------------*/
20942 diff -Naur a/include/linux/amlogic/media/codec_mm/codec_mm_keeper.h b/include/linux/amlogic/media/c…
20943 --- a/include/linux/amlogic/media/codec_mm/codec_mm_keeper.h 1970-01-01 08:00:00.000000000 +0800
20944 +++ b/include/linux/amlogic/media/codec_mm/codec_mm_keeper.h 2022-05-31 11:56:48.093256151 +0800
20945 @@ -0,0 +1,35 @@
20981 diff -Naur a/include/linux/amlogic/media/codec_mm/codec_mm_scatter.h b/include/linux/amlogic/media/…
20982 --- a/include/linux/amlogic/media/codec_mm/codec_mm_scatter.h 1970-01-01 08:00:00.000000000 +0800
20983 +++ b/include/linux/amlogic/media/codec_mm/codec_mm_scatter.h 2022-05-31 11:56:48.093256151 +0800
20984 @@ -0,0 +1,116 @@
21101 diff -Naur a/include/linux/amlogic/media/codec_mm/configs_api.h b/include/linux/amlogic/media/codec…
21102 --- a/include/linux/amlogic/media/codec_mm/configs_api.h 1970-01-01 08:00:00.000000000 +0800
21103 +++ b/include/linux/amlogic/media/codec_mm/configs_api.h 2022-05-31 11:56:48.093256151 +0800
21104 @@ -0,0 +1,48 @@
21153 diff -Naur a/include/linux/amlogic/media/codec_mm/configs.h b/include/linux/amlogic/media/codec_mm/…
21154 --- a/include/linux/amlogic/media/codec_mm/configs.h 1970-01-01 08:00:00.000000000 +0800
21155 +++ b/include/linux/amlogic/media/codec_mm/configs.h 2022-05-31 11:56:48.093256151 +0800
21156 @@ -0,0 +1,270 @@
21427 diff -Naur a/include/linux/amlogic/media/ge2d/ge2d_cmd.h b/include/linux/amlogic/media/ge2d/ge2d_cm…
21428 --- a/include/linux/amlogic/media/ge2d/ge2d_cmd.h 1970-01-01 08:00:00.000000000 +0800
21429 +++ b/include/linux/amlogic/media/ge2d/ge2d_cmd.h 2022-05-31 11:56:48.093256151 +0800
21430 @@ -0,0 +1,44 @@
21475 diff -Naur a/include/linux/amlogic/media/ge2d/ge2d_func.h b/include/linux/amlogic/media/ge2d/ge2d_f…
21476 --- a/include/linux/amlogic/media/ge2d/ge2d_func.h 1970-01-01 08:00:00.000000000 +0800
21477 +++ b/include/linux/amlogic/media/ge2d/ge2d_func.h 2022-05-31 11:56:48.093256151 +0800
21478 @@ -0,0 +1,124 @@
21500 +#define BLENDOP_SUB 1 /* Cd = Cs*Fs-Cd*Fd */
21501 +#define BLENDOP_REVERSE_SUB 2 /* Cd = Cd*Fd-Cs*Fs */
21603 diff -Naur a/include/linux/amlogic/media/ge2d/ge2d.h b/include/linux/amlogic/media/ge2d/ge2d.h
21604 --- a/include/linux/amlogic/media/ge2d/ge2d.h 1970-01-01 08:00:00.000000000 +0800
21605 +++ b/include/linux/amlogic/media/ge2d/ge2d.h 2022-05-31 11:56:48.093256151 +0800
21606 @@ -0,0 +1,1224 @@
21632 +#include <linux/soc/amlogic/meson-canvas.h>
21681 +#define OPERATION_SUB 1 /* Cd = Cs*Fs-Cd*Fd */
21682 +#define OPERATION_REVERSE_SUB 2 /* Cd = Cd*Fd-Cs*Fs */
21815 + * [18] : 1-deep color mode(10/12 bit), 0-8bit mode
21816 + * [17] : 1-YUV color space, 0-RGB color space
21817 + * [16] : compress_range, 1-full ramge, 0-limited range
21981 + int x; /* X coordinate of its top-left point */
21982 + int y; /* Y coordinate of its top-left point */
22831 diff -Naur a/include/linux/amlogic/meson_atrace.h b/include/linux/amlogic/meson_atrace.h
22832 --- a/include/linux/amlogic/meson_atrace.h 1970-01-01 08:00:00.000000000 +0800
22833 +++ b/include/linux/amlogic/meson_atrace.h 2022-05-31 11:56:48.093256151 +0800
22834 @@ -0,0 +1,123 @@
22855 + * without any custom javascript change in chromium-trace
22918 + __entry->flags = flags;
22919 + __entry->value = value;
22922 + TP_printk("%s%s%s|%u", print_flags_header(__entry->flags),
22923 + print_flags_delim(__entry->flags),
22924 + __get_str(name), __entry->value)
22958 diff -Naur a/include/linux/amlogic/power_ctrl.h b/include/linux/amlogic/power_ctrl.h
22959 --- a/include/linux/amlogic/power_ctrl.h 1970-01-01 08:00:00.000000000 +0800
22960 +++ b/include/linux/amlogic/power_ctrl.h 2022-05-31 11:56:48.093256151 +0800
22961 @@ -0,0 +1,48 @@
22995 + return -EINVAL;
23000 + return -EINVAL;
23006 + return -EINVAL;
23010 diff -Naur a/include/linux/amlogic/power_domain.h b/include/linux/amlogic/power_domain.h
23011 --- a/include/linux/amlogic/power_domain.h 1970-01-01 08:00:00.000000000 +0800
23012 +++ b/include/linux/amlogic/power_domain.h 2022-05-31 11:56:48.093256151 +0800
23013 @@ -0,0 +1,27 @@
23041 diff -Naur a/include/linux/amlogic/reboot.h b/include/linux/amlogic/reboot.h
23042 --- a/include/linux/amlogic/reboot.h 1970-01-01 08:00:00.000000000 +0800
23043 +++ b/include/linux/amlogic/reboot.h 2022-06-06 14:41:46.045026500 +0800
23044 @@ -0,0 +1,32 @@
23077 diff -Naur a/include/linux/amlogic/scpi_protocol.h b/include/linux/amlogic/scpi_protocol.h
23078 --- a/include/linux/amlogic/scpi_protocol.h 1970-01-01 08:00:00.000000000 +0800
23079 +++ b/include/linux/amlogic/scpi_protocol.h 2022-05-31 11:56:48.093256151 +0800
23080 @@ -0,0 +1,141 @@
23222 diff -Naur a/include/linux/amlogic/sd.h b/include/linux/amlogic/sd.h
23223 --- a/include/linux/amlogic/sd.h 1970-01-01 08:00:00.000000000 +0800
23224 +++ b/include/linux/amlogic/sd.h 2022-05-31 11:56:48.093256151 +0800
23225 @@ -0,0 +1,1869 @@
23249 +#include <linux/clk-provider.h>
23253 +#define pr_fmt(fmt) "meson-mmc: " fmt
23315 +#define SD_EMMC_DESC_SIZE (0x200 - SD_EMMC_RESP_SIZE)
23611 + * 3:sdio device(ie:sdio-wifi), 4:SD combo (IO+mem) card,
23629 +#define aml_card_type_unknown(c) ((c)->card_type == CARD_TYPE_UNKNOWN)
23630 +#define aml_card_type_mmc(c) ((c)->card_type == CARD_TYPE_MMC)
23631 +#define aml_card_type_sd(c) ((c)->card_type == CARD_TYPE_SD)
23632 +#define aml_card_type_sdio(c) ((c)->card_type == CARD_TYPE_SDIO)
23633 +#define aml_card_type_non_sdio(c) ((c)->card_type == CARD_TYPE_NON_SDIO)
23677 + /* back-link to device */
23805 + /* bit[7-0]--minor version, bit[31-8]--major version */
23822 +/*-sdio-*/
23843 + * (cmd bits+response bits+crc bits-1)
24107 +/*-sdhc-*/
24172 +#define INT_SDIO (60-32)
24173 +#define INT_SDHC (110-32)
24175 +#define INT_GPIO_0 (96-32)
24176 +#define INT_GPIO_1 (97-32)
24177 +#define INT_GPIO_2 (98-32)
24178 +#define INT_GPIO_3 (99-32)
24179 +#define INT_GPIO_4 (100-32)
24180 +#define INT_GPIO_5 (101-32)
24181 +#define INT_GPIO_6 (102-32)
24182 +#define INT_GPIO_7 (103-32)
24307 + /*[30:29] [30]self-clear-flush,[29] mode: 0:hw, 1:sw*/
24309 + /*[31] self-clear-fill, recommand to write before sd send*/
24807 + /*[15:12] Wait response-command,
24808 + *command-command gap before next command,
25054 +/* P_AO_SECURE_REG1 is "Secure Register 1" in <M8-Secure-AHB-Registers.doc> */
25071 +#include <mach/meson-secure.h>
25095 diff -Naur a/include/linux/amlogic/secmon.h b/include/linux/amlogic/secmon.h
25096 --- a/include/linux/amlogic/secmon.h 1970-01-01 08:00:00.000000000 +0800
25097 +++ b/include/linux/amlogic/secmon.h 2022-05-31 11:56:48.093256151 +0800
25098 @@ -0,0 +1,24 @@
25099 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
25123 diff -Naur a/include/linux/amlogic/tee.h b/include/linux/amlogic/tee.h
25124 --- a/include/linux/amlogic/tee.h 1970-01-01 08:00:00.000000000 +0800
25125 +++ b/include/linux/amlogic/tee.h 2022-05-31 11:56:48.093256151 +0800
25126 @@ -0,0 +1,89 @@
25127 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
25216 diff -Naur a/include/linux/amlogic/unifykey/key_manage.h b/include/linux/amlogic/unifykey/key_manag…
25217 --- a/include/linux/amlogic/unifykey/key_manage.h 1970-01-01 08:00:00.000000000 +0800
25218 +++ b/include/linux/amlogic/unifykey/key_manage.h 2022-05-31 11:56:48.093256151 +0800
25219 @@ -0,0 +1,29 @@
25249 diff -Naur a/include/linux/amlogic/unifykey/security_key.h b/include/linux/amlogic/unifykey/securit…
25250 --- a/include/linux/amlogic/unifykey/security_key.h 1970-01-01 08:00:00.000000000 +0800
25251 +++ b/include/linux/amlogic/unifykey/security_key.h 2022-05-31 11:56:48.093256151 +0800
25252 @@ -0,0 +1,45 @@
25298 diff -Naur a/include/linux/libata.h b/include/linux/libata.h
25299 --- a/include/linux/libata.h 2022-06-29 08:47:07.199383757 +0800
25300 +++ b/include/linux/libata.h 2022-05-27 17:20:18.157934092 +0800
25301 @@ -390,7 +390,7 @@
25303 * ata_eh_cmd_timeout_table in libata-eh.c.
25305 - ATA_EH_CMD_TIMEOUT_TABLE_SIZE = 7,
25310 diff -Naur a/include/linux/mmc/card.h b/include/linux/mmc/card.h
25311 --- a/include/linux/mmc/card.h 2022-05-27 17:20:18.181934401 +0800
25312 +++ b/include/linux/mmc/card.h 2022-05-31 11:56:48.097256115 +0800
25313 @@ -310,6 +310,7 @@
25321 diff -Naur a/include/linux/mmc/emmc_partitions.h b/include/linux/mmc/emmc_partitions.h
25322 --- a/include/linux/mmc/emmc_partitions.h 1970-01-01 08:00:00.000000000 +0800
25323 +++ b/include/linux/mmc/emmc_partitions.h 2022-05-31 11:56:48.097256115 +0800
25324 @@ -0,0 +1,85 @@
25325 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
25396 + * return -1;
25410 diff -Naur a/include/linux/mmc/host.h b/include/linux/mmc/host.h
25411 --- a/include/linux/mmc/host.h 2022-05-27 17:20:18.181934401 +0800
25412 +++ b/include/linux/mmc/host.h 2022-05-31 11:56:48.097256115 +0800
25413 @@ -286,6 +286,9 @@
25414 u32 ocr_avail_sd; /* SD-specific OCR */
25415 u32 ocr_avail_mmc; /* MMC-specific OCR */
25423 @@ -387,6 +390,9 @@
25433 @@ -606,4 +612,8 @@
25442 diff -Naur a/include/linux/soc/amlogic/meson-canvas.h b/include/linux/soc/amlogic/meson-canvas.h
25443 --- a/include/linux/soc/amlogic/meson-canvas.h 2022-05-27 17:20:18.225934968 +0800
25444 +++ b/include/linux/soc/amlogic/meson-canvas.h 2022-05-31 11:56:48.097256115 +0800
25445 @@ -39,6 +39,14 @@
25449 + * meson_canvas_alloc_spec() - take ownership of a canvas
25457 * meson_canvas_free() - remove ownership from a canvas
25460 diff -Naur a/include/linux/usb/composite.h b/include/linux/usb/composite.h
25461 --- a/include/linux/usb/composite.h 2022-05-27 17:20:18.241935174 +0800
25462 +++ b/include/linux/usb/composite.h 2022-05-31 11:56:48.097256115 +0800
25463 @@ -525,6 +525,8 @@
25472 @@ -590,6 +592,7 @@
25480 diff -Naur a/include/linux/usb/quirks.h b/include/linux/usb/quirks.h
25481 --- a/include/linux/usb/quirks.h 2022-05-27 17:20:18.241935174 +0800
25482 +++ b/include/linux/usb/quirks.h 2022-05-31 11:56:48.097256115 +0800
25483 @@ -72,4 +72,7 @@
25491 diff -Naur a/Kconfig b/Kconfig
25492 --- a/Kconfig 2022-05-27 17:20:13.749877237 +0800
25493 +++ b/Kconfig 2022-06-22 17:36:54.306837149 +0800
25494 @@ -30,3 +30,5 @@
25500 diff -Naur a/kernel/dma/contiguous.c b/kernel/dma/contiguous.c
25501 --- a/kernel/dma/contiguous.c 2022-05-27 17:20:18.377936928 +0800
25502 +++ b/kernel/dma/contiguous.c 2022-05-31 11:56:48.097256115 +0800
25503 @@ -262,6 +262,7 @@
25510 * dma_release_from_contiguous() - release allocated pages
25511 @@ -278,6 +279,7 @@
25519 diff -Naur a/Makefile b/Makefile
25520 --- a/Makefile 2022-05-27 17:20:13.753877288 +0800
25521 +++ b/Makefile 2022-06-22 23:09:26.871334703 +0800
25522 @@ -653,6 +653,7 @@
25523 drivers-$(CONFIG_SAMPLES) += samples/
25524 drivers-y += net/ virt/
25525 libs-y := lib/
25526 +vendor-y := vendor/
25530 @@ -851,7 +852,7 @@
25534 -
25535 +KBUILD_CFLAGS += -Wno-unused-function
25539 @@ -945,7 +946,7 @@
25540 KBUILD_CFLAGS += -Werror=date-time
25543 -KBUILD_CFLAGS += $(call cc-option,-Werror=incompatible-pointer-types)
25544 +#KBUILD_CFLAGS += $(call cc-option,-Werror=incompatible-pointer-types)
25547 KBUILD_CFLAGS += $(call cc-option,-Werror=designated-init)
25548 @@ -1115,16 +1116,16 @@
25549 core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ block/
25551 vmlinux-dirs := $(patsubst %/,%,$(filter %/, \
25552 - $(core-y) $(core-m) $(drivers-y) $(drivers-m) \
25553 + $(core-y) $(core-m) $(drivers-y) $(drivers-m) $(vendor-y) \
25554 $(libs-y) $(libs-m)))
25556 vmlinux-alldirs := $(sort $(vmlinux-dirs) Documentation \
25557 $(patsubst %/,%,$(filter %/, $(core-) \
25558 - $(drivers-) $(libs-))))
25559 + $(drivers-) $(vendor-) $(libs-))))
25561 subdir-modorder := $(addsuffix modules.order,$(filter %/, \
25562 $(core-y) $(core-m) $(libs-y) $(libs-m) \
25563 - $(drivers-y) $(drivers-m)))
25564 + $(drivers-y) $(vendor-y) $(drivers-m)))
25566 build-dirs := $(vmlinux-dirs)
25567 clean-dirs := $(vmlinux-alldirs)
25568 @@ -1139,6 +1140,7 @@
25569 KBUILD_VMLINUX_LIBS := $(patsubst %/,%/lib.a, $(libs-y))
25571 KBUILD_VMLINUX_OBJS += $(patsubst %/,%/built-in.a, $(drivers-y))
25572 +KBUILD_VMLINUX_OBJS += $(patsubst %/,%/built-in.a, $(vendor-y))
25576 diff -Naur a/mm/Kconfig b/mm/Kconfig
25577 --- a/mm/Kconfig 2022-07-04 18:32:52.121159105 +0800
25578 +++ b/mm/Kconfig 2022-06-25 13:59:26.657088100 +0800
25579 @@ -961,7 +961,6 @@
25583 - depends on 64BIT
25587 diff -Naur a/mm/vmscan.c b/mm/vmscan.c
25588 --- a/mm/vmscan.c 2022-07-01 17:31:52.025722900 +0800
25589 +++ b/mm/vmscan.c 2022-06-17 09:33:40.366370000 +0800
25590 @@ -4362,10 +4362,8 @@
25594 -#ifdef CONFIG_MEMCG
25595 - while (memcg = mem_cgroup_iter(NULL, memcg, NULL))
25596 -#endif
25597 - {
25602 shrink_list(LRU_ACTIVE_PURGEABLE, -1, lruvec, sc);
25603 diff -Naur a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
25604 --- a/net/ipv4/inet_hashtables.c 2022-07-04 18:32:52.121159105 +0800
25605 +++ b/net/ipv4/inet_hashtables.c 2022-06-15 15:15:55.636125159 +0800
25606 @@ -711,18 +711,6 @@
25610 -/* RFC 6056 3.3.4. Algorithm 4: Double-Hash Port Selection Algorithm
25611 - * Note that we use 32bit integers (vs RFC 'short integers')
25612 - * because 2^16 is not a multiple of num_ephemeral and this
25613 - * property might be used by clever attacker.
25614 - * RFC claims using TABLE_LENGTH=10 buckets gives an improvement, though
25615 - * attacks were since demonstrated, thus we use 65536 instead to really
25616 - * give more isolation and privacy, at the expense of 256kB of kernel
25617 - * memory.
25618 - */
25619 -#define INET_TABLE_PERTURB_SHIFT 16
25620 -static u32 table_perturb[1 << INET_TABLE_PERTURB_SHIFT];
25621 -
25625 @@ -736,8 +724,8 @@
25631 - u32 index;
25634 head = &hinfo->bhash[inet_bhashfn(net, port,
25635 @@ -764,10 +752,7 @@
25639 - net_get_random_once(table_perturb, sizeof(table_perturb));
25640 - index = hash_32(port_offset, INET_TABLE_PERTURB_SHIFT);
25641 -
25642 - offset = READ_ONCE(table_perturb[index]) + port_offset;
25647 @@ -822,7 +807,7 @@
25648 return -EADDRNOTAVAIL;
25651 - WRITE_ONCE(table_perturb[index], READ_ONCE(table_perturb[index]) + i + 2);
25656 diff -Naur a/net/nfc/netlink.c b/net/nfc/netlink.c
25657 --- a/net/nfc/netlink.c 2022-06-25 17:56:10.483704524 +0800
25658 +++ b/net/nfc/netlink.c 2022-05-27 17:20:18.613939971 +0800
25659 @@ -1242,7 +1242,7 @@
25663 - msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
25666 return -ENOMEM;
25668 @@ -1258,7 +1258,7 @@
25672 - genlmsg_multicast(&nfc_genl_family, msg, 0, 0, GFP_ATOMIC);
25677 diff -Naur a/scripts/dtc/include-prefixes/arm64/amlogic/Makefile b/scripts/dtc/include-prefixes/arm…
25678 --- a/scripts/dtc/include-prefixes/arm64/amlogic/Makefile 2022-05-27 17:20:14.013880643 +0800
25679 +++ b/scripts/dtc/include-prefixes/arm64/amlogic/Makefile 2022-06-04 12:12:41.042068628 +0800
25680 @@ -1,50 +1,2 @@
25681 # SPDX-License-Identifier: GPL-2.0
25682 -dtb-$(CONFIG_ARCH_MESON) += meson-axg-s400.dtb
25683 -dtb-$(CONFIG_ARCH_MESON) += meson-g12a-sei510.dtb
25684 -dtb-$(CONFIG_ARCH_MESON) += meson-g12a-u200.dtb
25685 -dtb-$(CONFIG_ARCH_MESON) += meson-g12a-x96-max.dtb
25686 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-gtking.dtb
25687 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-gtking-pro.dtb
25688 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-a311d-khadas-vim3.dtb
25689 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-s922x-khadas-vim3.dtb
25690 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-odroid-n2.dtb
25691 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-odroid-n2-plus.dtb
25692 -dtb-$(CONFIG_ARCH_MESON) += meson-g12b-ugoos-am6.dtb
25693 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-kii-pro.dtb
25694 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-nanopi-k2.dtb
25695 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-nexbox-a95x.dtb
25696 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-odroidc2.dtb
25697 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-p200.dtb
25698 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-p201.dtb
25699 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-vega-s95-pro.dtb
25700 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-vega-s95-meta.dtb
25701 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-vega-s95-telos.dtb
25702 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-wetek-hub.dtb
25703 -dtb-$(CONFIG_ARCH_MESON) += meson-gxbb-wetek-play2.dtb
25704 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s805x-libretech-ac.dtb
25705 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-hwacom-amazetv.dtb
25706 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-khadas-vim.dtb
25707 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-libretech-cc.dtb
25708 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-libretech-cc-v2.dtb
25709 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-nexbox-a95x.dtb
25710 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905x-p212.dtb
25711 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-p230.dtb
25712 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-p231.dtb
25713 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-phicomm-n1.dtb
25714 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-sml5442tw.dtb
25715 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s805x-p241.dtb
25716 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905w-p281.dtb
25717 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905w-tx3-mini.dtb
25718 -dtb-$(CONFIG_ARCH_MESON) += meson-gxl-s905d-libretech-pc.dtb
25719 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-khadas-vim2.dtb
25720 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-nexbox-a1.dtb
25721 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-q200.dtb
25722 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-q201.dtb
25723 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-rbox-pro.dtb
25724 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-s912-libretech-pc.dtb
25725 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-vega-s96.dtb
25726 -dtb-$(CONFIG_ARCH_MESON) += meson-gxm-wetek-core2.dtb
25727 -dtb-$(CONFIG_ARCH_MESON) += meson-sm1-sei610.dtb
25728 -dtb-$(CONFIG_ARCH_MESON) += meson-sm1-khadas-vim3l.dtb
25729 -dtb-$(CONFIG_ARCH_MESON) += meson-sm1-odroid-c4.dtb
25730 -dtb-$(CONFIG_ARCH_MESON) += meson-a1-ad401.dtb
25731 +dtb-$(CONFIG_ARCH_MESON) += meson-g12b-unionpi-tiger.dtb
25733 diff -Naur a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-a311d.dtsi b/scripts/dtc/include…
25734 --- a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-a311d.dtsi 2022-05-27 17:20:14.01388064…
25735 +++ b/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-a311d.dtsi 2022-05-31 11:56:47.69325967…
25736 @@ -11,26 +11,6 @@
25737 compatible = "operating-points-v2";
25738 opp-shared;
25740 - opp-100000000 {
25741 - opp-hz = /bits/ 64 <100000000>;
25742 - opp-microvolt = <731000>;
25743 - };
25744 -
25745 - opp-250000000 {
25746 - opp-hz = /bits/ 64 <250000000>;
25747 - opp-microvolt = <731000>;
25748 - };
25749 -
25750 - opp-500000000 {
25751 - opp-hz = /bits/ 64 <500000000>;
25752 - opp-microvolt = <731000>;
25753 - };
25754 -
25755 - opp-667000000 {
25756 - opp-hz = /bits/ 64 <667000000>;
25757 - opp-microvolt = <731000>;
25758 - };
25759 -
25760 opp-1000000000 {
25761 opp-hz = /bits/ 64 <1000000000>;
25762 opp-microvolt = <761000>;
25763 @@ -65,31 +45,21 @@
25764 opp-hz = /bits/ 64 <1800000000>;
25765 opp-microvolt = <1001000>;
25767 - };
25768 -
25769 - cpub_opp_table_1: opp-table-1 {
25770 - compatible = "operating-points-v2";
25771 - opp-shared;
25773 - opp-100000000 {
25774 - opp-hz = /bits/ 64 <100000000>;
25775 - opp-microvolt = <731000>;
25776 + opp-1908000000 {
25777 + opp-hz = /bits/ 64 <1908000000>;
25778 + opp-microvolt = <1022000>;
25781 - opp-250000000 {
25782 - opp-hz = /bits/ 64 <250000000>;
25783 - opp-microvolt = <731000>;
25784 - };
25785 -
25786 - opp-500000000 {
25787 - opp-hz = /bits/ 64 <500000000>;
25788 - opp-microvolt = <731000>;
25789 + opp-2016000000 {
25790 + opp-hz = /bits/ 64 <2016000000>;
25791 + opp-microvolt = <1022000>;
25795 - opp-667000000 {
25796 - opp-hz = /bits/ 64 <667000000>;
25797 - opp-microvolt = <731000>;
25798 - };
25799 + cpub_opp_table_1: opp-table-1 {
25800 + compatible = "operating-points-v2";
25801 + opp-shared;
25803 opp-1000000000 {
25804 opp-hz = /bits/ 64 <1000000000>;
25805 @@ -126,24 +96,34 @@
25806 opp-microvolt = <831000>;
25809 - opp-1908000000 {
25810 - opp-hz = /bits/ 64 <1908000000>;
25811 - opp-microvolt = <861000>;
25812 - };
25813 -
25814 - opp-2016000000 {
25815 - opp-hz = /bits/ 64 <2016000000>;
25816 - opp-microvolt = <911000>;
25817 - };
25818 -
25819 - opp-2108000000 {
25820 - opp-hz = /bits/ 64 <2108000000>;
25821 - opp-microvolt = <951000>;
25822 - };
25823 -
25824 - opp-2208000000 {
25825 - opp-hz = /bits/ 64 <2208000000>;
25826 - opp-microvolt = <1011000>;
25827 - };
25828 + opp-1908000000 {
25829 + opp-hz = /bits/ 64 <1908000000>;
25830 + opp-microvolt = <861000>;
25833 + opp-2016000000 {
25834 + opp-hz = /bits/ 64 <2016000000>;
25835 + opp-microvolt = <911000>;
25838 + opp-2108000000 {
25839 + opp-hz = /bits/ 64 <2108000000>;
25840 + opp-microvolt = <951000>;
25843 + opp-2208000000 {
25844 + opp-hz = /bits/ 64 <2208000000>;
25845 + opp-microvolt = <1011000>;
25848 + opp-2304000000 {
25849 + opp-hz = /bits/ 64 <2304000000>;
25850 + opp-microvolt = <1022000>;
25853 + opp-2400000000 {
25854 + opp-hz = /bits/ 64 <2400000000>;
25855 + opp-microvolt = <1022000>;
25859 …iff -Naur a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-unionpi-tiger.dts b/scripts/dtc/…
25860 --- a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-unionpi-tiger.dts 1970-01-01 08:00:00.0…
25861 +++ b/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-unionpi-tiger.dts 2022-07-04 13:57:46.7…
25862 @@ -0,0 +1,489 @@
25863 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
25870 +/dts-v1/;
25872 +#include "meson-g12b-a311d.dtsi"
25873 +#include "meson-unionpi-tiger.dtsi"
25874 +#include "meson-g12b-unionpi-tiger.dtsi"
25879 + amlogic-dt-id = "g12b_w400_b";
25881 + reserved-memory {
25883 + compatible = "shared-dma-pool";
25887 + linux,contiguous-region;
25891 + compatible = "shared-dma-pool";
25895 + linux,contiguous-region;
25899 + compatible = "shared-dma-pool";
25903 + linux,contiguous-region;
25907 + compatible = "shared-dma-pool";
25912 + linux,contiguous-region;
25917 + compatible = "amlogic, codec-mm-reserved";
25920 + //no-map;
25930 + dev_name = "amlogic-canvas";
25946 + clock-names = "parser_top",
25958 + memory-region = <&codec_mm_cma &codec_mm_reserved>;
25966 + #address-cells=<1>;
25967 + #size-cells=<1>;
26002 + interrupt-names = "vsync",
26015 + interrupt-names = "mailbox_2";
26019 + compatible = "amlogic, ge2d-g12a";
26023 + interrupt-names = "ge2d";
26027 + clock-names = "clk_vapb_0",
26040 + clock-names = "cts_vipnanoq_axi_clk_composite",
26043 + interrupt-names = "galcore";
26050 + reg-names = "NN_REG","NN_SRAM","NN_MEM0",
26055 + memory-region = <&galcore_reserved>;
26060 + #address-cells=<2>;
26061 + #size-cells=<2>;
26095 + compatible = "amlogic, bt-dev";
26103 + compatible = "amlogic, wifi-dev";
26111 + part-0 = <&logo>;
26112 + part-1 = <&updater>;
26113 + part-2 = <&misc>;
26114 + part-3 = <&dto>;
26115 + part-4 = <&cri_data>;
26116 + part-5 = <¶m>;
26117 + part-6 = <&boot>;
26118 + part-7 = <&rsv>;
26119 + part-8 = <&tee>;
26120 + part-9 = <&vendor>;
26121 + part-10 = <&odm>;
26122 + part-11 = <&system>;
26123 + part-12 = <&cache>;
26124 + part-13 = <&data>;
26214 + unifykey-num = <17>;
26215 + unifykey-index-0 = <&keysn_0>;
26216 + unifykey-index-1 = <&keysn_1>;
26217 + unifykey-index-2 = <&keysn_2>;
26218 + unifykey-index-3 = <&keysn_3>;
26219 + unifykey-index-4 = <&keysn_4>;
26220 + unifykey-index-5 = <&keysn_5>;
26221 + unifykey-index-6 = <&keysn_6>;
26222 + unifykey-index-7 = <&keysn_7>;
26223 + unifykey-index-8 = <&keysn_8>;
26224 + unifykey-index-9 = <&keysn_9>;
26225 + unifykey-index-10= <&keysn_10>;
26226 + unifykey-index-11= <&keysn_11>;
26227 + unifykey-index-12= <&keysn_12>;
26228 + unifykey-index-13= <&keysn_13>;
26229 + unifykey-index-14= <&keysn_14>;
26230 + unifykey-index-15= <&keysn_15>;
26231 + unifykey-index-16= <&keysn_16>;
26234 + key-name = "usid";
26235 + key-device = "normal";
26236 + key-permit = "read","write","del";
26239 + key-name = "mac";
26240 + key-device = "normal";
26241 + key-permit = "read","write","del";
26244 + key-name = "hdcp";
26245 + key-device = "secure";
26246 + key-type = "sha1";
26247 + key-permit = "read","write","del";
26250 + key-name = "secure_boot_set";
26251 + key-device = "efuse";
26252 + key-permit = "write";
26255 + key-name = "mac_bt";
26256 + key-device = "normal";
26257 + key-permit = "read","write","del";
26258 + key-type = "mac";
26261 + key-name = "mac_wifi";
26262 + key-device = "normal";
26263 + key-permit = "read","write","del";
26264 + key-type = "mac";
26267 + key-name = "hdcp2_tx";
26268 + key-device = "normal";
26269 + key-permit = "read","write","del";
26272 + key-name = "hdcp2_rx";
26273 + key-device = "normal";
26274 + key-permit = "read","write","del";
26277 + key-name = "widevinekeybox";
26278 + key-device = "secure";
26279 + key-permit = "read","write","del";
26282 + key-name = "deviceid";
26283 + key-device = "normal";
26284 + key-permit = "read","write","del";
26287 + key-name = "hdcp22_fw_private";
26288 + key-device = "secure";
26289 + key-permit = "read","write","del";
26292 + key-name = "PlayReadykeybox25";
26293 + key-device = "secure";
26294 + key-permit = "read","write","del";
26297 + key-name = "prpubkeybox";// PlayReady
26298 + key-device = "secure";
26299 + key-permit = "read","write","del";
26302 + key-name = "prprivkeybox";// PlayReady
26303 + key-device = "secure";
26304 + key-permit = "read","write","del";
26307 + key-name = "netflix_mgkid";
26308 + key-device = "secure";
26309 + key-permit = "read","write","del";
26312 + key-name = "eth_exphy_para";
26313 + key-device = "normal";
26314 + key-permit = "read","write","del";
26317 + key-name = "um_factory_para";
26318 + key-device = "normal";
26319 + key-permit = "read","write","del";
26326 + sensor-name = "imx219"; /*ov5647,imx290;os08a10;imx227;imx307;imx219*/
26327 + pinctrl-names="default";
26329 + clock-names = "g12a_24m";
26335 + sensor-name = "imx219"; /*ov5647,imx290;os08a10;imx227;imx307;imx219*/
26341 + temper-line-offset = <0x1680>;
26342 + temper-buf-size = <12>;
26343 + temper-frame-num = <1>;
26344 + temper-frame-size = <0xBDD800>;
26345 + memory-region = <&isp_cma_reserved>;
26350 + memory-region = <&adapt_cma_reserved>;
26352 …iff -Naur a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-unionpi-tiger.dtsi b/scripts/dtc…
26353 --- a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-unionpi-tiger.dtsi 1970-01-01 08:00:00.…
26354 +++ b/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12b-unionpi-tiger.dtsi 2022-05-31 11:56:47.…
26355 @@ -0,0 +1,101 @@
26356 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
26364 + vddcpu_a: regulator-vddcpu-a {
26365 + compatible = "pwm-regulator";
26367 + regulator-name = "VDDCPU_A";
26368 + regulator-min-microvolt = <721000>;
26369 + regulator-max-microvolt = <1022000>;
26370 + regulator-ramp-delay = <10>;
26372 + vin-supply = <&dc_in>;
26375 + pwm-dutycycle-range = <100 0>;
26377 + regulator-boot-on;
26378 + regulator-always-on;
26381 + vddcpu_b: regulator-vddcpu-b {
26382 + compatible = "pwm-regulator";
26384 + regulator-name = "VDDCPU_B";
26385 + regulator-min-microvolt = <721000>;
26386 + regulator-max-microvolt = <1022000>;
26387 + regulator-ramp-delay = <10>;
26389 + vin-supply = <&dc_in>;
26392 + pwm-dutycycle-range = <100 0>;
26394 + regulator-boot-on;
26395 + regulator-always-on;
26400 + cpu-supply = <&vddcpu_b>;
26401 + operating-points-v2 = <&cpu_opp_table_0>;
26403 + clock-latency = <50000>;
26407 + cpu-supply = <&vddcpu_b>;
26408 + operating-points-v2 = <&cpu_opp_table_0>;
26410 + clock-latency = <50000>;
26414 + cpu-supply = <&vddcpu_a>;
26415 + operating-points-v2 = <&cpub_opp_table_1>;
26417 + clock-latency = <50000>;
26421 + cpu-supply = <&vddcpu_a>;
26422 + operating-points-v2 = <&cpub_opp_table_1>;
26424 + clock-latency = <50000>;
26428 + cpu-supply = <&vddcpu_a>;
26429 + operating-points-v2 = <&cpub_opp_table_1>;
26431 + clock-latency = <50000>;
26435 + cpu-supply = <&vddcpu_a>;
26436 + operating-points-v2 = <&cpub_opp_table_1>;
26438 + clock-latency = <50000>;
26442 + pinctrl-0 = <&pwm_a_e_pins>;
26443 + pinctrl-names = "default";
26445 + clock-names = "clkin0";
26450 + pinctrl-0 = <&pwm_ao_c_6_pins>, <&pwm_ao_d_e_pins>;
26451 + pinctrl-names = "default";
26453 + clock-names = "clkin1";
26457 diff -Naur a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12-common.dtsi b/scripts/dtc/include…
26458 --- a/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12-common.dtsi 2022-05-27 17:20:14.01388064…
26459 +++ b/scripts/dtc/include-prefixes/arm64/amlogic/meson-g12-common.dtsi 2022-06-18 13:48:23.73452542…
26460 @@ -17,6 +17,12 @@
26461 #address-cells = <2>;
26462 #size-cells = <2>;
26471 #address-cells = <2>;
26472 #size-cells = <2>;
26473 @@ -43,6 +49,10 @@
26477 + system-suspend {
26478 + compatible = "amlogic,meson-gx-pm";
26482 compatible = "amlogic,meson-gxbb-efuse";
26484 @@ -55,10 +65,6 @@
26485 gpu_opp_table: gpu-opp-table {
26486 compatible = "operating-points-v2";
26488 - opp-124999998 {
26489 - opp-hz = /bits/ 64 <124999998>;
26490 - opp-microvolt = <800000>;
26491 - };
26492 opp-249999996 {
26493 opp-hz = /bits/ 64 <249999996>;
26494 opp-microvolt = <800000>;
26495 @@ -96,15 +102,19 @@
26499 - secmon_reserved: secmon@5000000 {
26500 - reg = <0x0 0x05000000 0x0 0x300000>;
26501 - no-map;
26503 + compatible = "shared-dma-pool";
26507 + alloc-ranges = <0x0 0x05000000 0x0 0x3400000>;
26508 + clear-map;
26512 compatible = "shared-dma-pool";
26514 - size = <0x0 0x10000000>;
26517 linux,cma-default;
26519 @@ -113,6 +123,16 @@
26520 sm: secure-monitor {
26521 compatible = "amlogic,meson-gxbb-sm";
26526 + memory-region = <&secmon_reserved>;
26535 compatible = "simple-bus";
26536 @@ -224,6 +244,8 @@
26537 "timing-adjustment";
26538 rx-fifo-depth = <4096>;
26539 tx-fifo-depth = <2048>;
26541 + reset-names = "stmmaceth";
26545 @@ -1681,12 +1703,31 @@
26549 - <250000000>,
26555 + compatible = "amlogic,g12a-mipi-dphy-analog";
26556 + #phy-cells = <0>;
26563 + compatible = "amlogic,axg-mipi-dphy";
26566 + clock-names = "pclk";
26568 + reset-names = "phy";
26570 + phy-names = "analog";
26571 + #phy-cells = <0>;
26576 compatible = "amlogic,g12a-usb3-pcie-phy";
26578 @@ -1930,6 +1971,33 @@
26582 + uart_ao_b_1_pins: uart-ao-b-1 {
26587 + bias-disable;
26591 + uart_ao_b_2_pins: uart-ao-b-2 {
26596 + bias-disable;
26600 + uart_ao_b_cts_rts_pins: uart-ao-b-cts-rts {
26605 + bias-disable;
26609 pwm_a_e_pins: pwm-a-e {
26612 @@ -2003,7 +2071,7 @@
26616 - vrtc: rtc@0a8 {
26618 compatible = "amlogic,meson-vrtc";
26621 @@ -2144,6 +2212,15 @@
26622 remote-endpoint = <&hdmi_tx_in>;
26631 + remote-endpoint = <&mipi_dsi_in>;
26636 gic: interrupt-controller@ffc01000 {
26637 @@ -2181,6 +2258,49 @@
26638 amlogic,channel-interrupts = <64 65 66 67 68 69 70 71>;
26641 + mipi_dsi: mipi-dsi@7000 {
26642 + compatible = "amlogic,meson-g12a-dw-mipi-dsi";
26645 + reset-names = "top";
26648 + clock-names = "pclk", "px_clk";
26650 + phy-names = "dphy";
26651 + #address-cells = <1>;
26652 + #size-cells = <0>;
26655 + assigned-clocks = <&clkc CLKID_MIPI_DSI_PXCLK_SEL>;
26656 + assigned-clock-parents = <&clkc CLKID_GP0_PLL>;
26659 + #address-cells = <1>;
26660 + #size-cells = <0>;
26667 + remote-endpoint = <&dpi_out>;
26679 + compatible = "amlogic,meson-gxbb-wdt";
26685 compatible = "amlogic,meson-g12a-spicc";
26687 @@ -2305,6 +2425,7 @@
26689 clock-names = "xtal", "pclk", "baud";
26691 + fifo-size = <128>;
26695 @@ -2400,6 +2521,62 @@
26696 operating-points-v2 = <&gpu_opp_table>;
26697 #cooling-cells = <2>;
26700 + isp_sc: isp-sc@ff655400 {
26701 + compatible = "amlogic, isp-sc";
26703 + reg-names = "isp_sc";
26705 + interrupt-names = "isp_sc";
26711 + reg-names = "ISP";
26712 + isp-efuse = <0xff630038 0x4000>;
26714 + interrupt-names = "ISP";
26715 + temper-buf-size = <24>;
26718 + clock-names = "cts_mipi_isp_clk_composite",
26720 + link-device = <&isp_sc>;
26723 + adapter: isp-adapter@ff650000 {
26724 + compatible = "amlogic, isp-adapter";
26726 + reg-names = "adapter";
26728 + interrupt-names = "adapter-irq";
26732 + phycsi: phy-csi@ff650000 {
26733 + compatible = "amlogic, phy-csi";
26739 + reg-names = "csi2_phy0", "csi2_phy1", "aphy_reg",
26747 + interrupt-names = "phy0-irq",
26748 + "phy1-irq",
26749 + "csi-host0-intr2",
26750 + "csi-host0-intr1",
26751 + "csi-host1-intr2",
26752 + "csi-host1-intr1";
26753 + link-device = <&adapter>;
26758 @@ -2422,4 +2599,10 @@
26759 #clock-cells = <0>;
26763 + compatible = "fixed-clock";
26764 + clock-output-names = "osc8M";
26765 + clock-frequency = <8000000>;
26766 + #clock-cells = <0>;
26769 diff -Naur a/scripts/dtc/include-prefixes/arm64/amlogic/meson-unionpi-tiger.dtsi b/scripts/dtc/incl…
26770 --- a/scripts/dtc/include-prefixes/arm64/amlogic/meson-unionpi-tiger.dtsi 1970-01-01 08:00:00.00000…
26771 +++ b/scripts/dtc/include-prefixes/arm64/amlogic/meson-unionpi-tiger.dtsi 2022-06-04 12:16:05.31822…
26772 @@ -0,0 +1,805 @@
26773 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
26780 +#include <dt-bindings/input/input.h>
26781 +#include <dt-bindings/gpio/meson-g12a-gpio.h>
26782 +#include <dt-bindings/sound/meson-g12a-toacodec.h>
26783 +#include <dt-bindings/sound/meson-g12a-tohdmitx.h>
26784 +#include <dt-bindings/clock/g12a-clkc.h>
26785 +#include <dt-bindings/reset/amlogic,meson-g12a-reset.h>
26786 +#include <dt-bindings/clock/axg-audio-clkc.h>
26804 + stdout-path = "serial0:115200n8";
26812 + gpio-keys-polled {
26813 + compatible = "gpio-keys-polled";
26814 + #address-cells = <1>;
26815 + #size-cells = <0>;
26816 + poll-interval = <100>;
26818 + power-button {
26826 + compatible = "gpio-leds";
26828 + /* USB-OTG Switch GPIO */
26829 + usb-switch {
26832 + default-state = "on";
26836 + emmc_pwrseq: emmc-pwrseq {
26837 + compatible = "mmc-pwrseq-emmc";
26838 + reset-gpios = <&gpio BOOT_12 GPIO_ACTIVE_LOW>;
26841 + sdio_pwrseq: sdio-pwrseq {
26842 + compatible = "mmc-pwrseq-simple";
26843 + reset-gpios = <&gpio GPIOX_6 GPIO_ACTIVE_LOW>;
26846 + dc_in: regulator-dc_in {
26847 + compatible = "regulator-fixed";
26848 + regulator-name = "DC_IN";
26849 + regulator-min-microvolt = <12000000>;
26850 + regulator-max-microvolt = <12000000>;
26851 + regulator-always-on;
26854 + vcc_5v: regulator-vcc_5v {
26855 + compatible = "regulator-fixed";
26856 + regulator-name = "VCC_5V";
26857 + regulator-min-microvolt = <5000000>;
26858 + regulator-max-microvolt = <5000000>;
26859 + vin-supply = <&dc_in>;
26863 + enable-active-high;
26866 + vsys_3v3: regulator-vsys_3v3 {
26867 + compatible = "regulator-fixed";
26868 + regulator-name = "VSYS_3V3";
26869 + regulator-min-microvolt = <3300000>;
26870 + regulator-max-microvolt = <3300000>;
26871 + vin-supply = <&dc_in>;
26872 + regulator-always-on;
26875 + usb_pwr_en: regulator-usb-pwr-en {
26876 + compatible = "regulator-fixed";
26877 + regulator-name = "USB_PWR_EN";
26878 + regulator-min-microvolt = <5000000>;
26879 + regulator-max-microvolt = <5000000>;
26880 + vin-supply = <&vcc_5v>;
26881 + enable-active-high;
26884 + usb1_pow: regulator-usb1-pow {
26885 + compatible = "regulator-fixed";
26886 + regulator-name = "USB1_POW";
26887 + regulator-min-microvolt = <5000000>;
26888 + regulator-max-microvolt = <5000000>;
26889 + vin-supply = <&vcc_5v>;
26890 + enable-active-high;
26893 + vddao_3v3: regulator-vddao-3v3 {
26894 + compatible = "regulator-fixed";
26895 + regulator-name = "VDDAO_3V3";
26896 + regulator-min-microvolt = <3300000>;
26897 + regulator-max-microvolt = <3300000>;
26898 + vin-supply = <&dc_in>;
26899 + regulator-always-on;
26902 + vddao_1v8: regulator-vddao_1v8 {
26903 + compatible = "regulator-fixed";
26904 + regulator-name = "VDDAO_1V8";
26905 + regulator-min-microvolt = <1800000>;
26906 + regulator-max-microvolt = <1800000>;
26907 + vin-supply = <&vddao_3v3>;
26908 + regulator-always-on;
26911 + usb_pwr: regulator-usb_pwr {
26912 + compatible = "regulator-fixed";
26913 + regulator-name = "USB_PWR";
26914 + regulator-min-microvolt = <5000000>;
26915 + regulator-max-microvolt = <5000000>;
26916 + vin-supply = <&vcc_5v>;
26917 + enable-active-high;
26920 + hdmi-connector {
26921 + compatible = "hdmi-connector";
26927 + remote-endpoint = <&hdmi_tx_tmds_out>;
26932 + spdif_dit: audio-codec-1 {
26933 + #sound-dai-cells = <0>;
26934 + compatible = "linux,spdif-dit";
26936 + sound-name-prefix = "DIT";
26940 + compatible = "amlogic,axg-sound-card";
26941 + model = "UNIONPI-TIGER";
26942 + audio-widgets = "Line", "Lineout",
26944 + audio-aux-devs = <&tdmout_b>, <&tdmout_c>,
26946 + audio-routing = "TDMOUT_B IN 0", "FRDDR_A OUT 1",
26971 + /* tdmin -> toddr */
26987 + assigned-clocks = <&clkc CLKID_MPLL2>,
26990 + assigned-clock-parents = <0>, <0>, <0>;
26991 + assigned-clock-rates = <294912000>,
26996 + dai-link-0 {
26997 + sound-dai = <&frddr_a>;
27000 + dai-link-1 {
27001 + sound-dai = <&frddr_b>;
27004 + dai-link-2 {
27005 + sound-dai = <&frddr_c>;
27008 + dai-link-3 {
27009 + sound-dai = <&toddr_a>;
27012 + dai-link-4 {
27013 + sound-dai = <&toddr_b>;
27016 + dai-link-5 {
27017 + sound-dai = <&toddr_c>;
27021 + dai-link-6 {
27022 + sound-dai = <&tdmif_b>;
27023 + dai-format = "i2s";
27024 + dai-tdm-slot-tx-mask-0 = <1 1>;
27025 + dai-tdm-slot-rx-mask-1 = <1 1>;
27026 + dai-tdm-slot-tx-mask-2 = <1 1>;
27027 + dai-tdm-slot-tx-mask-3 = <1 1>;
27028 + mclk-fs = <256>;
27030 + codec-0 {
27031 + sound-dai = <&tohdmitx TOHDMITX_I2S_IN_B>;
27034 + codec-1 {
27035 + sound-dai = <&toacodec TOACODEC_IN_B>;
27039 + codec-2 {
27040 + sound-dai = <&nau8540>;
27045 + dai-link-7 {
27046 + sound-dai = <&tdmif_c>;
27047 + dai-format = "i2s";
27048 + dai-tdm-slot-tx-mask-0 = <1 1>;
27049 + mclk-fs = <256>;
27051 + codec-0 {
27052 + sound-dai = <&tohdmitx TOHDMITX_I2S_IN_C>;
27055 + codec-1 {
27056 + sound-dai = <&toacodec TOACODEC_IN_C>;
27061 + dai-link-8 {
27062 + sound-dai = <&tohdmitx TOHDMITX_I2S_OUT>;
27065 + sound-dai = <&hdmi_tx>;
27070 + dai-link-9 {
27071 + sound-dai = <&toacodec TOACODEC_OUT>;
27074 + sound-dai = <&acodec>;
27085 + AVDD-supply = <&vddao_1v8>;
27098 + pinctrl-0 = <&cec_ao_a_h_pins>;
27099 + pinctrl-names = "default";
27101 + hdmi-phandle = <&hdmi_tx>;
27105 + pinctrl-0 = <&cec_ao_b_h_pins>;
27106 + pinctrl-names = "default";
27108 + hdmi-phandle = <&hdmi_tx>;
27112 + external_phy: ethernet-phy@0 {
27115 + max-speed = <1000>;
27116 + reset-assert-us = <10000>;
27117 + reset-deassert-us = <80000>;
27118 + reset-gpios = <&gpio GPIOZ_15 (GPIO_ACTIVE_LOW | GPIO_OPEN_DRAIN)>;
27120 + interrupt-parent = <&gpio_intc>;
27127 + pinctrl-0 = <ð_pins>, <ð_rgmii_pins>;
27128 + pinctrl-names = "default";
27130 + phy-mode = "rgmii";
27131 + phy-handle = <&external_phy>;
27132 + amlogic,tx-delay-ns = <2>;
27149 + pinctrl-0 = <&hdmitx_hpd_pins>, <&hdmitx_ddc_pins>;
27150 + pinctrl-names = "default";
27151 + hdmi-supply = <&vcc_5v>;
27156 + remote-endpoint = <&hdmi_connector_in>;
27163 + assigned-clocks = <&clkc CLKID_GP0_PLL>,
27166 + assigned-clock-parents = <0>,
27169 + assigned-clock-rates = <720000000>,
27176 + power-supply = <&vddao_3v3>;
27178 + power-supply = <&vcc_5v>;*/
27183 + remote-endpoint = <&dsi_out_panel>;
27199 + remote-endpoint = <&dsi_in_panel>;
27205 + pinctrl-names = "default";
27206 + pinctrl-0 = <&i2c2_sck_x_pins>, <&i2c2_sda_x_pins>;
27207 + clock-frequency = <100000>; /* default 100k */
27212 + pinctrl-names="default";
27213 + pinctrl-0 = <&i2c3_sck_a_pins>, <&i2c3_sda_a_pins>;
27214 + clock-frequency = <100000>; /* default 100k */
27220 + pinctrl-names = "default";
27221 + #address-cells = <1>;
27222 + #size-cells = <0>;
27226 + #address-cells = <1>;
27227 + #size-cells = <0>;
27233 + #address-cells = <1>;
27234 + #size-cells = <0>;
27240 + #address-cells = <1>;
27241 + #size-cells = <0>;
27247 + gpio-controller;
27248 + #gpio-cells = <0x02>;
27250 + gpio-line-names = "WAKEUP_OUT", "PWR_ON_N", "WAKEUP_IN", "W_DISABLE_N",
27251 + "PMU_RSTIN_N", "9342_RST", "SEN-SYNC1", "", "MUTE",
27259 + gpio-controller;
27260 + #gpio-cells = <0x02>;
27262 + gpio-line-names = "GPIO_01", "GPIO_02", "GPIO_03", "GPIO_04",
27270 + #sound-dai-cells = <0>;
27277 + #sound-dai-cells = <0>;
27279 + sound-name-prefix = "Linein";
27285 + #sound-dai-cells = <0>;
27293 + compatible = "edt,edt-ft5406";
27295 + touchscreen-size-x = < 800 >;
27296 + touchscreen-size-y = < 480 >;
27297 + touchscreen-inverted-x = < 1 >;
27298 + touchscreen-inverted-y = < 1 >;
27303 + compatible = "chipone,icn6211-i2c";
27308 + sensor-i2c@6c {
27309 + compatible = "arm, i2c-sensor";
27311 + reg-names = "i2c-sensor";
27312 + slave-addr = <0x6c>;
27313 + reg-type = <2>;
27314 + reg-data-type = <1>;
27315 + link-device = <&phycsi>;
27319 + /*icm-20948*/
27321 + #address-cells = <1>;
27322 + #size-cells = <0>;
27331 + pinctrl-names = "default";
27332 + pinctrl-0 = <&i2c_ao_sck_pins>, <&i2c_ao_sda_pins>;
27333 + clock-frequency = <400000>;
27339 + wakeup-source;
27349 + pinctrl-0 = <&pwm_ao_a_pins>;
27350 + pinctrl-names = "default";
27352 + clock-names = "clkin0";
27357 + vref-supply = <&vddao_1v8>;
27363 + compatible = "amlogic,meson-axg-mmc";
27364 + pinctrl-0 = <&emmc_ctrl_pins>, <&emmc_data_8b_pins>, <&emmc_ds_pins>;
27365 + pinctrl-1 = <&emmc_clk_gate_pins>;
27366 + pinctrl-names = "default", "clk-gate";
27368 + bus-width = <8>;
27369 + cap-mmc-highspeed;
27370 + mmc-ddr-1_8v;
27371 + mmc-hs200-1_8v;
27372 + max-frequency = <200000000>;
27373 + disable-wp;
27375 + mmc-pwrseq = <&emmc_pwrseq>;
27376 + vmmc-supply = <&vddao_3v3>;
27377 + vqmmc-supply = <&vddao_1v8>;
27383 + compatible = "amlogic,meson-axg-mmc";
27384 + pinctrl-0 = <&sdcard_c_pins>;
27385 + pinctrl-1 = <&sdcard_clk_gate_c_pins>;
27386 + pinctrl-names = "default", "clk-gate";
27388 + bus-width = <4>;
27389 + cap-sd-highspeed;
27390 + max-frequency = <50000000>;
27391 + disable-wp;
27393 + cd-gpios = <&gpio GPIOC_6 GPIO_ACTIVE_LOW>;
27394 + vmmc-supply = <&vddao_3v3>;
27395 + vqmmc-supply = <&vddao_3v3>;
27401 + pinctrl-0 = <&sdio_pins>;
27402 + pinctrl-1 = <&sdio_clk_gate_pins>;
27403 + pinctrl-names = "default", "clk-gate";
27404 + #address-cells = <1>;
27405 + #size-cells = <0>;
27407 + bus-width = <4>;
27408 + cap-sd-highspeed;
27409 + sd-uhs-sdr104;
27410 + max-frequency = <167000000>;
27412 + non-removable;
27413 + disable-wp;
27416 + keep-power-in-suspend;
27418 + mmc-pwrseq = <&sdio_pwrseq>;
27420 + vmmc-supply = <&vddao_3v3>;
27421 + vqmmc-supply = <&vddao_1v8>;
27429 + pinctrl-0 = <&tdm_b_sclk_pins>, <&tdm_b_fs_pins>,
27431 + pinctrl-names = "default";
27433 + assigned-clocks = <&clkc_audio AUD_CLKID_TDM_MCLK_PAD0>,
27436 + assigned-clock-parents = <&clkc_audio AUD_CLKID_MST_B_MCLK>,
27439 + assigned-clock-rates = <0>, <0>, <0>;
27498 + pinctrl-0 = <&uart_ao_a_pins>;
27499 + pinctrl-names = "default";
27505 + pinctrl-0 = <&uart_ao_b_2_pins>;
27506 + pinctrl-names = "default";
27512 + pinctrl-0 = <&uart_a_pins>;
27513 + pinctrl-names = "default";
27526 + phy-supply = <&usb1_pow>;
27531 + phy-supply = <&usb1_pow>;
27536 + phy-supply = <&usb_pwr>;
27542 + vbus-supply = <&usb_pwr_en>;
27547 + pinctrl-names = "default","gpio_periphs";
27548 + pinctrl-0 = <&spicc0_x_pins>;
27549 + pinctrl-1 = <&spicc0_ss0_x_pins>;
27551 + cs-gpios = <&gpio GPIOX_10 GPIO_ACTIVE_LOW>;
27557 + spi-max-frequency = <10000000>;
27563 + pinctrl-names = "default";
27564 + pinctrl-0 = <&spicc1_pins>;
27566 + cs-gpios = <&gpio GPIOH_6 GPIO_ACTIVE_LOW>;
27573 + spi-max-frequency = <5000000>;
27574 + interrupt-parent = <&gpio_intc>;
27578 diff -Naur a/scripts/dtc/include-prefixes/arm64/Makefile b/scripts/dtc/include-prefixes/arm64/Makef…
27579 --- a/scripts/dtc/include-prefixes/arm64/Makefile 2022-05-27 17:20:14.009880591 +0800
27580 +++ b/scripts/dtc/include-prefixes/arm64/Makefile 2022-05-31 11:56:47.697259643 +0800
27581 @@ -30,3 +30,5 @@
27582 subdir-y += toshiba
27583 subdir-y += xilinx
27584 subdir-y += zte
27586 +clean-files := dts/*.dtb *.dtb
27587 diff -Naur a/scripts/dtc/include-prefixes/dt-bindings/clock/g12a-clkc.h b/scripts/dtc/include-prefi…
27588 --- a/scripts/dtc/include-prefixes/dt-bindings/clock/g12a-clkc.h 2022-05-27 17:20:18.089933214 +0800
27589 +++ b/scripts/dtc/include-prefixes/dt-bindings/clock/g12a-clkc.h 2022-05-31 11:56:48.093256151 +0800
27590 @@ -147,5 +147,23 @@
27614 diff -Naur a/scripts/Makefile.lib b/scripts/Makefile.lib
27615 --- a/scripts/Makefile.lib 2022-05-27 17:20:18.681940848 +0800
27616 +++ b/scripts/Makefile.lib 2022-05-31 11:57:06.789097155 +0800
27617 @@ -210,7 +210,9 @@
27619 ld_flags = $(KBUILD_LDFLAGS) $(ldflags-y) $(LDFLAGS_$(@F))
27621 -DTC_INCLUDE := $(srctree)/scripts/dtc/include-prefixes
27622 +DTC_INCLUDE := $(srctree)/scripts/dtc/include-prefixes \
27624 + $(srctree)/include/dt-bindings
27626 dtc_cpp_flags = -Wp,-MMD,$(depfile).pre.tmp -nostdinc \
27627 $(addprefix -I,$(DTC_INCLUDE)) \
27628 @@ -316,7 +318,7 @@
27632 -cmd_dtc = $(HOSTCC) -E $(dtc_cpp_flags) -x assembler-with-cpp -o $(dtc-tmp) $< ; \
27633 +cmd_dtc = mkdir -p $(dir $(dtc-tmp)); $(HOSTCC) -E $(dtc_cpp_flags) -x assembler-with-cpp -o $(dtc…
27634 $(DTC) -O $(patsubst .%,%,$(suffix $@)) -o $@ -b 0 \
27635 $(addprefix -i,$(dir $<) $(DTC_INCLUDE)) $(DTC_FLAGS) \
27636 -d $(depfile).dtc.tmp $(dtc-tmp) ; \
27637 diff -Naur a/sound/soc/codecs/nau8540.c b/sound/soc/codecs/nau8540.c
27638 --- a/sound/soc/codecs/nau8540.c 2022-05-27 17:20:18.829942757 +0800
27639 +++ b/sound/soc/codecs/nau8540.c 2022-05-31 11:57:06.789097155 +0800
27640 @@ -756,7 +756,7 @@
27644 - NAU8540_CH_SYNC | NAU8540_ADC_OSR_64);
27649 @@ -769,6 +769,17 @@
27654 + regmap_update_bits(nau8540->regmap, NAU8540_REG_PCM_CTRL1,
27656 + regmap_write(nau8540->regmap, NAU8540_REG_FEPGA3,0x1717);
27657 + regmap_write(nau8540->regmap, NAU8540_REG_DIGITAL_GAIN_CH1,0x0520);
27658 + regmap_write(nau8540->regmap, NAU8540_REG_DIGITAL_GAIN_CH2,0x0520);
27659 + regmap_write(nau8540->regmap, NAU8540_REG_DIGITAL_GAIN_CH3, 0x0520);
27660 + regmap_write(nau8540->regmap, NAU8540_REG_DIGITAL_GAIN_CH4, 0x0520);
27661 + regmap_write(nau8540->regmap, NAU8540_REG_DIGITAL_MUX,0x0000);
27662 + regmap_write(nau8540->regmap, NAU8540_REG_HPF_FILTER_CH12,0x1F1F);
27663 + regmap_write(nau8540->regmap, NAU8540_REG_HPF_FILTER_CH34,0x1F1F);
27667 diff -Naur a/sound/soc/Makefile b/sound/soc/Makefile
27668 --- a/sound/soc/Makefile 2022-05-27 17:20:18.801942396 +0800
27669 +++ b/sound/soc/Makefile 2022-06-18 17:43:11.719529135 +0800
27670 @@ -37,7 +37,9 @@
27671 obj-$(CONFIG_SND_SOC) += img/
27672 obj-$(CONFIG_SND_SOC) += intel/
27673 obj-$(CONFIG_SND_SOC) += mediatek/
27675 obj-$(CONFIG_SND_SOC) += meson/
27677 obj-$(CONFIG_SND_SOC) += mxs/
27678 obj-$(CONFIG_SND_SOC) += kirkwood/
27679 obj-$(CONFIG_SND_SOC) += pxa/
27680 diff -Naur a/vendor/amlogic/battery/aml_battery.c b/vendor/amlogic/battery/aml_battery.c
27681 --- a/vendor/amlogic/battery/aml_battery.c 1970-01-01 08:00:00.000000000 +0800
27682 +++ b/vendor/amlogic/battery/aml_battery.c 2022-06-27 21:51:16.307017964 +0800
27683 @@ -0,0 +1,175 @@
27737 + val->intval = 1;
27740 + ret = -EINVAL;
27754 + val->intval = POWER_SUPPLY_STATUS_CHARGING;
27757 + val->intval = POWER_SUPPLY_HEALTH_GOOD;
27760 + val->intval = 0;
27763 + val->intval = 100;
27767 + val->intval = 3000 * 1000;
27770 + val->intval = 3000 * 1000;
27774 + val->intval = 4200 * 1000;
27777 + val->intval = 25;
27780 + val->intval = -40;
27783 + val->intval = 100;
27786 + val->intval = 4200 * 1000;
27789 + val->intval = 100 * 1000;
27792 + val->intval = 3000000;
27795 + val->intval = 5000000;
27798 + val->intval = POWER_SUPPLY_TECHNOLOGY_LIPO;
27801 + ret = -EINVAL;
27833 + return -1;
27840 + return -1;
27860 diff -Naur a/vendor/amlogic/battery/Kconfig b/vendor/amlogic/battery/Kconfig
27861 --- a/vendor/amlogic/battery/Kconfig 1970-01-01 08:00:00.000000000 +0800
27862 +++ b/vendor/amlogic/battery/Kconfig 2022-06-02 19:59:17.401116604 +0800
27863 @@ -0,0 +1,5 @@
27869 diff -Naur a/vendor/amlogic/battery/Makefile b/vendor/amlogic/battery/Makefile
27870 --- a/vendor/amlogic/battery/Makefile 1970-01-01 08:00:00.000000000 +0800
27871 +++ b/vendor/amlogic/battery/Makefile 2022-06-02 19:59:32.185446082 +0800
27872 @@ -0,0 +1 @@
27873 +obj-y += aml_battery.o
27875 diff -Naur a/vendor/amlogic/bluetooth/bluesleep.c b/vendor/amlogic/bluetooth/bluesleep.c
27876 --- a/vendor/amlogic/bluetooth/bluesleep.c 1970-01-01 08:00:00.000000000 +0800
27877 +++ b/vendor/amlogic/bluetooth/bluesleep.c 2022-05-31 11:56:47.705259573 +0800
27878 @@ -0,0 +1,961 @@
27881 + * ----------- -------------- --------------------------------
27882 + * 2006-Apr-28 Motorola The kernel module for running the Bluetooth(R)
27883 + * Sleep-Mode Protocol from the Host side
27884 + * 2006-Sep-08 Motorola Added workqueue for handling sleep work.
27885 + * 2007-Jan-24 Motorola Added mbm_handle_ioi() call to ISR.
27886 + * 2009-Aug-10 Motorola Changed "add_timer" to "mod_timer" to solve
27941 +/* enable/disable wake-on-bluetooth */
28062 + return (gpio_get_value(bsi->host_wake) != bsi->irq_polarity) &&
28064 + (bsi->uport != NULL);
28072 + wake_lock(&bsi->wake_lock);
28077 + if (bsi->has_ext_wake == 1)
28078 + gpio_set_value(bsi->ext_wake, 1);
28100 + if (bsi->uport->ops->tx_empty(bsi->uport)) {
28109 + wake_lock_timeout(&bsi->wake_lock, HZ / 2);
28120 + if (bsi->has_ext_wake == 1)
28121 + gpio_set_value(bsi->ext_wake, 1);
28139 + if (gpio_get_value(bsi->host_wake) == bsi->irq_polarity)
28193 + hu = (struct hci_uart *) hdev->driver_data;
28194 + state = (struct uart_state *) hu->tty->driver_data;
28195 + bsi->uport = state->uart_port;
28203 + bsi->uport = NULL;
28234 + if (bsi->has_ext_wake == 1)
28235 + gpio_set_value(bsi->ext_wake, 0);
28264 + * Starts the Sleep-Mode Protocol on the Host.
28265 + * @return On success, 0. On error, -1, and <code>errno</code> is set
28284 + return -EBUSY;
28294 + if (bsi->has_ext_wake == 1)
28295 + gpio_set_value(bsi->ext_wake, 1);
28297 + retval = request_irq(bsi->host_wake_irq, bluesleep_hostwake_isr,
28305 + retval = enable_irq_wake(bsi->host_wake_irq);
28312 + wake_lock(&bsi->wake_lock);
28323 + * Stops the Sleep-Mode Protocol on the Host.
28339 + if (bsi->has_ext_wake == 1)
28340 + gpio_set_value(bsi->ext_wake, 1);
28356 + if (disable_irq_wake(bsi->host_wake_irq))
28359 + free_irq(bsi->host_wake_irq, NULL);
28360 + wake_lock_timeout(&bsi->wake_lock, HZ / 2);
28370 + struct device_node *np = pdev->dev.of_node;
28377 + return -ENODEV;
28379 + bsi->host_wake = tmp;
28383 + bsi->has_ext_wake = 0;
28385 + bsi->has_ext_wake = 1;
28387 + if (bsi->has_ext_wake)
28388 + bsi->ext_wake = tmp;
28397 + bsi->host_wake,
28398 + bsi->ext_wake);
28410 + return -ENODEV;
28412 + bsi->host_wake = res->start;
28417 + bsi->has_ext_wake = 0;
28419 + bsi->has_ext_wake = 1;
28421 + if (bsi->has_ext_wake)
28422 + bsi->ext_wake = res->start;
28434 + return -ENOMEM;
28436 + if (pdev->dev.of_node) {
28451 + ret = gpio_request_one(bsi->host_wake, GPIOF_IN, "bt_host_wake");
28454 + bsi->host_wake, ret);
28460 + if (bsi->has_ext_wake) {
28462 + ret = gpio_request_one(bsi->ext_wake,
28467 + bsi->ext_wake, ret);
28473 + bsi->host_wake_irq =
28474 + irq_of_parse_and_map(pdev->dev.of_node, 0);
28475 + if (bsi->host_wake_irq == 0) {
28477 + ret = -ENODEV;
28481 + gpio_for_irq(bsi->host_wake,
28482 + AML_GPIO_IRQ(bsi->host_wake_irq, FILTER_NUM7,
28485 + bsi->irq_polarity = POLARITY_LOW;/*low edge (falling edge)*/
28487 + wake_lock_init(&bsi->wake_lock,
28492 + bsi->host_wake_irq,
28493 + bsi->irq_polarity);
28498 + gpio_free(bsi->ext_wake);
28500 + gpio_free(bsi->host_wake);
28508 + gpio_free(bsi->host_wake);
28509 + gpio_free(bsi->ext_wake);
28510 + wake_lock_destroy(&bsi->wake_lock);
28521 + if ((bsi->uport != NULL) &&
28522 + (gpio_get_value(bsi->host_wake) == bsi->irq_polarity)) {
28558 + switch ((long)m->private) {
28563 + seq_printf(m, "hostwake: %u\n", gpio_get_value(bsi->host_wake));
28595 + count = sizeof(lbuf)-1;
28598 + return -EFAULT;
28606 + if (bsi->has_ext_wake == 1)
28607 + gpio_set_value(bsi->ext_wake, 1);
28612 + if (bsi->has_ext_wake == 1)
28613 + gpio_set_value(bsi->ext_wake, 0);
28627 + bsi->uport = NULL;
28631 + bsi->uport = get_uart_port(bt_port_id);
28632 + if (bsi->uport)
28640 + if (lbuf[0] != '0' && bsi->uport)
28671 + * @return On success, 0. On error, -1, and <code>errno</code> is set
28695 + return -ENOMEM;
28701 + return -ENOMEM;
28709 + retval = -ENOMEM;
28718 + retval = -ENOMEM;
28727 + retval = -ENOMEM;
28736 + retval = -ENOMEM;
28746 + retval = -ENOMEM;
28755 + retval = -ENOMEM;
28773 + if (bsi->has_ext_wake == 1)
28774 + gpio_set_value(bsi->ext_wake, 1);
28804 + if (bsi->has_ext_wake == 1)
28805 + gpio_set_value(bsi->ext_wake, 1);
28808 + if (disable_irq_wake(bsi->host_wake_irq))
28810 + free_irq(bsi->host_wake_irq, NULL);
28840 diff -Naur a/vendor/amlogic/bluetooth/bluesleep.h b/vendor/amlogic/bluetooth/bluesleep.h
28841 --- a/vendor/amlogic/bluetooth/bluesleep.h 1970-01-01 08:00:00.000000000 +0800
28842 +++ b/vendor/amlogic/bluetooth/bluesleep.h 2022-06-24 14:37:49.260765339 +0800
28843 @@ -0,0 +1,22 @@
28866 diff -Naur a/vendor/amlogic/bluetooth/bt_device.c b/vendor/amlogic/bluetooth/bt_device.c
28867 --- a/vendor/amlogic/bluetooth/bt_device.c 1970-01-01 08:00:00.000000000 +0800
28868 +++ b/vendor/amlogic/bluetooth/bt_device.c 2022-06-30 15:33:55.343687749 +0800
28869 @@ -0,0 +1,440 @@
28918 + return -EINVAL;
28937 + int ret = -EINVAL;
28944 + if (bt_addr[strlen(bt_addr)-1] == '\n')
28945 + bt_addr[strlen(bt_addr)-1] = '\0';
28959 + if (pdata->power_down_disable == 0) {
28960 + if (pdata->power_off_flag > 0) {
28961 + if (pdata->gpio_reset > 0) {
28962 + if ((pdata->power_on_pin_OD)
28963 + && (pdata->power_low_level)) {
28964 + gpio_direction_input(pdata->gpio_reset);
28966 + gpio_direction_output(pdata->gpio_reset,
28967 + pdata->power_low_level);
28970 + if (pdata->gpio_en > 0) {
28971 + if ((pdata->power_on_pin_OD)
28972 + && (pdata->power_low_level)) {
28973 + gpio_direction_input(pdata->gpio_en);
28975 + gpio_direction_output(pdata->gpio_en, 0);
28987 + if (pdata->gpio_reset > 0)
28988 + gpio_request(pdata->gpio_reset, BT_RFKILL);
28990 + if (pdata->gpio_en > 0){
28991 + gpio_request(pdata->gpio_en, BT_RFKILL);
28994 + if (pdata->gpio_hostwake > 0) {
28995 + gpio_request(pdata->gpio_hostwake, BT_RFKILL);
28996 + gpio_direction_output(pdata->gpio_hostwake, 1);
28999 + tmp = pdata->power_down_disable;
29000 + pdata->power_down_disable = 0;
29002 + pdata->power_down_disable = tmp;
29008 + if (pdata->gpio_reset > 0)
29009 + gpio_free(pdata->gpio_reset);
29011 + if (pdata->gpio_en > 0)
29012 + gpio_free(pdata->gpio_en);
29014 + if (pdata->gpio_hostwake > 0)
29015 + gpio_free(pdata->gpio_hostwake);
29020 + if (pdata->power_down_disable == 0) {
29021 + if (pdata->gpio_reset > 0) {
29022 + if ((pdata->power_on_pin_OD)
29023 + && (pdata->power_low_level)) {
29024 + gpio_direction_input(pdata->gpio_reset);
29026 + gpio_direction_output(pdata->gpio_reset,
29027 + pdata->power_low_level);
29031 + if (pdata->gpio_en > 0) {
29032 + if ((pdata->power_on_pin_OD)
29033 + && (pdata->power_low_level)) {
29034 + gpio_direction_input(pdata->gpio_en);
29036 + gpio_direction_output(pdata->gpio_en, 0);
29042 + if (pdata->gpio_reset > 0) {
29044 + if ((pdata->power_on_pin_OD)
29045 + && (!pdata->power_low_level)) {
29046 + gpio_direction_input(pdata->gpio_reset);
29048 + gpio_direction_output(pdata->gpio_reset,
29049 + !pdata->power_low_level);
29053 + if (pdata->gpio_en > 0) {
29054 + if ((pdata->power_on_pin_OD)
29055 + && (!pdata->power_low_level)) {
29056 + gpio_direction_input(pdata->gpio_en);
29058 + gpio_direction_output(pdata->gpio_en, 1);
29115 + if (pdev && pdev->dev.of_node) {
29119 + ret = of_property_read_string(pdev->dev.of_node, "gpio_reset", &str);
29122 + pdata->gpio_reset = 0;
29124 + pdata->gpio_reset = of_get_named_gpio_flags(pdev->dev.of_node, "gpio_reset", 0, NULL);
29127 + ret = of_property_read_string(pdev->dev.of_node, "gpio_en", &str);
29130 + pdata->gpio_en = 0;
29132 + pdata->gpio_en = of_get_named_gpio_flags(pdev->dev.of_node, "gpio_en", 0, NULL);
29134 + ret = of_property_read_string(pdev->dev.of_node, "gpio_hostwake", &str);
29137 + pdata->gpio_hostwake = 0;
29139 + pdata->gpio_hostwake = of_get_named_gpio_flags(pdev->dev.of_node, "gpio_hostwake", 0, NULL);
29142 + prop = of_get_property(pdev->dev.of_node, "power_low_level", NULL);
29145 + pdata->power_low_level = 1;
29148 + pdata->power_low_level = 0;
29149 + pdata->power_on_pin_OD = 0;
29152 + ret = of_property_read_u32(pdev->dev.of_node, "power_on_pin_OD", &pdata->power_on_pin_OD);
29154 + pdata->power_on_pin_OD = 0;
29155 + pr_info("bt: power_on_pin_OD = %d;\n", pdata->power_on_pin_OD);
29157 + ret = of_property_read_u32(pdev->dev.of_node, "power_off_flag", &pdata->power_off_flag);
29159 + pdata->power_off_flag = 1;/*bt poweroff*/
29160 + pr_info("bt: power_off_flag = %d;\n", pdata->power_off_flag);
29162 + ret = of_property_read_u32(pdev->dev.of_node, "power_down_disable", &pdata->power_down_disable);
29164 + pdata->power_down_disable = 0;
29165 + pr_info("bt: power down = %d;\n", pdata->power_down_disable);
29167 + pdata = (struct bt_dev_data *)(pdev->dev.platform_data);
29169 + ret = -ENOENT;
29173 + pdata = (struct bt_dev_data *)(pdev->dev.platform_data);
29179 + if (pdata->power_down_disable == 1) {
29180 + pdata->power_down_disable = 0;
29182 + pdata->power_down_disable = 1;
29185 + bt_rfk = rfkill_alloc("bluetooth", &pdev->dev,
29191 + ret = -ENOMEM;
29206 + prdata->bt_rfk = bt_rfk;
29207 + prdata->pdata = pdata;
29239 + rfk = prdata->bt_rfk;
29240 + pdata = prdata->pdata;
29259 + { .compatible = "amlogic, bt-dev",
29300 + strncpy(bt_addr, line, sizeof(bt_addr)-1);
29301 + bt_addr[sizeof(bt_addr)-1] = '\0';
29310 diff -Naur a/vendor/amlogic/bluetooth/Kconfig b/vendor/amlogic/bluetooth/Kconfig
29311 --- a/vendor/amlogic/bluetooth/Kconfig 1970-01-01 08:00:00.000000000 +0800
29312 +++ b/vendor/amlogic/bluetooth/Kconfig 2022-06-06 09:23:20.004587331 +0800
29313 @@ -0,0 +1,5 @@
29319 diff -Naur a/vendor/amlogic/bluetooth/Makefile b/vendor/amlogic/bluetooth/Makefile
29320 --- a/vendor/amlogic/bluetooth/Makefile 1970-01-01 08:00:00.000000000 +0800
29321 +++ b/vendor/amlogic/bluetooth/Makefile 2022-05-31 11:56:47.709259537 +0800
29322 @@ -0,0 +1 @@
29323 +obj-y += bt_device.o
29324 diff -Naur a/vendor/amlogic/canvas/canvas.c b/vendor/amlogic/canvas/canvas.c
29325 --- a/vendor/amlogic/canvas/canvas.c 1970-01-01 08:00:00.000000000 +0800
29326 +++ b/vendor/amlogic/canvas/canvas.c 2022-06-30 15:17:45.712876428 +0800
29327 @@ -0,0 +1,385 @@
29356 +#include <linux/soc/amlogic/meson-canvas.h>
29377 + spin_lock_irqsave(&info->lock, f);\
29384 + spin_unlock_irqrestore(&info->lock, f);\
29424 +#define CANVAS_HEIGHT_HBIT (41 - 32)
29425 +#define CANVAS_WRAPX_HBIT (54 - 32)
29426 +#define CANVAS_WRAPY_HBIT (55 - 32)
29427 +#define CANVAS_BLKMODE_HBIT (56 - 32)
29428 +#define CANVAS_ENDIAN_HBIT (58 - 32)
29461 + canvas_lut_data_build(p->addr,
29462 + p->width,
29463 + p->height,
29464 + p->wrap,
29465 + p->blkmode,
29466 + p->endian, &datal, &datah);
29468 + meson_canvas_config(info->meson_canvas, (u8)index,
29469 + p->addr, p->width, p->height,
29470 + p->wrap, p->blkmode,
29471 + p->endian);
29473 + p->dataL = datal;
29474 + p->dataH = datah;
29487 + canvas = &info->canvasPool[index];
29488 + canvas->addr = addr;
29489 + canvas->width = width;
29490 + canvas->height = height;
29491 + canvas->wrap = wrap;
29492 + canvas->blkmode = blkmode;
29493 + canvas->endian = endian;
29501 + canvas_config_ex(index, cfg->phy_addr,
29502 + cfg->width, cfg->height, CANVAS_ADDR_NOWRAP,
29503 + cfg->block_mode, cfg->endian);
29519 + *p = info->canvasPool[index];
29526 + struct canvas_s *canvas_src = &info->canvasPool[src];
29527 + struct canvas_s *canvas_dst = &info->canvasPool[dst];
29534 + canvas_dst->addr = canvas_src->addr;
29535 + canvas_dst->width = canvas_src->width;
29536 + canvas_dst->height = canvas_src->height;
29537 + canvas_dst->wrap = canvas_src->wrap;
29538 + canvas_dst->blkmode = canvas_src->blkmode;
29539 + canvas_dst->endian = canvas_src->endian;
29540 + canvas_dst->dataH = canvas_src->dataH;
29541 + canvas_dst->dataL = canvas_src->dataL;
29555 + canvas = &info->canvasPool[index];
29558 + canvas->addr = addr;
29570 + return info->canvasPool[index].addr;
29581 + return info->canvasPool[index].width;
29592 + return info->canvasPool[index].height;
29601 + if (meson_canvas_alloc_spec(info->meson_canvas, i)) {
29604 + meson_canvas_free(info->meson_canvas, j);
29605 + info->canvasPool[j].used = 0;
29607 + return -1;
29609 + info->canvasPool[i].used = 1;
29621 + meson_canvas_free(info->meson_canvas, i);
29622 + info->canvasPool[i].used = 0;
29629 + struct device *dev = &pdev->dev;
29633 + info->meson_canvas = meson_canvas_get(dev);
29634 + if (IS_ERR(info->meson_canvas)) {
29636 + return -1;
29639 + spin_lock_init(&info->lock);
29641 + // Pre-Alloc canvas for "VDec" : [0x78, 0xbf]
29644 + return -EBUSY;
29647 + // Pre-Alloc canvas for "VEnc" : [0xe4, 0xef]
29650 + return -EBUSY;
29662 + struct device *dev = &pdev->dev;
29684 + .name = "amlogic-canvas-legacy",
29713 diff -Naur a/vendor/amlogic/canvas/Kconfig b/vendor/amlogic/canvas/Kconfig
29714 --- a/vendor/amlogic/canvas/Kconfig 1970-01-01 08:00:00.000000000 +0800
29715 +++ b/vendor/amlogic/canvas/Kconfig 2022-05-31 11:56:47.709259537 +0800
29716 @@ -0,0 +1,13 @@
29730 diff -Naur a/vendor/amlogic/canvas/Makefile b/vendor/amlogic/canvas/Makefile
29731 --- a/vendor/amlogic/canvas/Makefile 1970-01-01 08:00:00.000000000 +0800
29732 +++ b/vendor/amlogic/canvas/Makefile 2022-05-31 11:56:47.709259537 +0800
29733 @@ -0,0 +1,5 @@
29738 +obj-$(CONFIG_AMLOGIC_MEDIA_CANVAS) += canvas.o
29739 diff -Naur a/vendor/amlogic/codecs/es7243.c b/vendor/amlogic/codecs/es7243.c
29740 --- a/vendor/amlogic/codecs/es7243.c 1970-01-01 08:00:00.000000000 +0800
29741 +++ b/vendor/amlogic/codecs/es7243.c 2022-05-31 11:57:06.789097100 +0800
29742 @@ -0,0 +1,331 @@
29816 + return -EIO;
29826 + xfer[0].addr = client->addr;
29831 + xfer[1].addr = client->addr;
29836 + ret = i2c_transfer(client->adapter, xfer, 2);
29838 + dev_err(&client->dev, "i2c_transfer() returned %d\n", ret);
29854 + dev_err(&client->dev, "i2c write 0x%0x failed\n",
29870 + dev_err(&client->dev, "i2c write 0x%0x failed\n",
29874 + dev_info(&client->dev, "0x%0x -- 0x%0x\n",
29898 + dev_info(&es7243_i2c_client[i]->dev, "snd soc: es7243\n");
29916 + dev_err(&client->dev, "i2c write 0x%0x failed\n",
29920 + dev_info(&client->dev, "0x%0x -- 0x%0x\n",
29945 + bool playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
29955 + bool playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
29967 + .name = "es7243-mic-array",
29998 + snd_soc_unregister_component(&client->dev);
30015 + struct device *dev = &client->dev;
30019 + es7243 = devm_kzalloc(&client->dev, sizeof(*es7243), GFP_KERNEL);
30021 + return -ENOMEM;
30024 + if (dev->of_node) {
30028 + return -EINVAL;
30034 + ret = snd_soc_register_component(&client->dev,
30074 diff -Naur a/vendor/amlogic/codecs/es7243.h b/vendor/amlogic/codecs/es7243.h
30075 --- a/vendor/amlogic/codecs/es7243.h 1970-01-01 08:00:00.000000000 +0800
30076 +++ b/vendor/amlogic/codecs/es7243.h 2022-05-31 11:57:06.789097100 +0800
30077 @@ -0,0 +1,34 @@
30081 + * Author: David Yang, <yangxiaohua@everest-semi.com>
30083 + * <info@everest-semi.com>
30113 diff -Naur a/vendor/amlogic/codecs/Kconfig b/vendor/amlogic/codecs/Kconfig
30114 --- a/vendor/amlogic/codecs/Kconfig 1970-01-01 08:00:00.000000000 +0800
30115 +++ b/vendor/amlogic/codecs/Kconfig 2022-06-30 17:25:19.016549738 +0800
30116 @@ -0,0 +1,5 @@
30117 +# SPDX-License-Identifier: GPL-2.0-only
30122 diff -Naur a/vendor/amlogic/codecs/Makefile b/vendor/amlogic/codecs/Makefile
30123 --- a/vendor/amlogic/codecs/Makefile 1970-01-01 08:00:00.000000000 +0800
30124 +++ b/vendor/amlogic/codecs/Makefile 2022-06-30 17:27:14.915329125 +0800
30125 @@ -0,0 +1,3 @@
30126 +# SPDX-License-Identifier: GPL-2.0
30127 +snd-soc-es7243-objs := es7243.o
30128 +obj-$(CONFIG_SND_SOC_ES7243) += snd-soc-es7243.o
30129 diff -Naur a/vendor/amlogic/cpu_version/Kconfig b/vendor/amlogic/cpu_version/Kconfig
30130 --- a/vendor/amlogic/cpu_version/Kconfig 1970-01-01 08:00:00.000000000 +0800
30131 +++ b/vendor/amlogic/cpu_version/Kconfig 2022-05-31 11:56:47.709259537 +0800
30132 @@ -0,0 +1,26 @@
30146 + Amlogic gx-X
30159 diff -Naur a/vendor/amlogic/cpu_version/Makefile b/vendor/amlogic/cpu_version/Makefile
30160 --- a/vendor/amlogic/cpu_version/Makefile 1970-01-01 08:00:00.000000000 +0800
30161 +++ b/vendor/amlogic/cpu_version/Makefile 2022-05-31 11:56:47.709259537 +0800
30162 @@ -0,0 +1,2 @@
30163 +obj-$(CONFIG_AMLOGIC_MESON64_VERSION) += meson64_cpu.o
30164 +obj-$(CONFIG_AMLOGIC_M8B_MESON32_VERSION) += meson32_cpu.o
30166 diff -Naur a/vendor/amlogic/cpu_version/meson32_cpu.c b/vendor/amlogic/cpu_version/meson32_cpu.c
30167 --- a/vendor/amlogic/cpu_version/meson32_cpu.c 1970-01-01 08:00:00.000000000 +0800
30168 +++ b/vendor/amlogic/cpu_version/meson32_cpu.c 2022-06-24 14:37:49.436821008 +0800
30169 @@ -0,0 +1,95 @@
30196 +#include <linux/amlogic/meson-secure.h>
30247 + pr_info("Meson chip version = Rev%X (%X:%X - %X:%X)\n", ver,
30265 diff -Naur a/vendor/amlogic/cpu_version/meson64_cpu.c b/vendor/amlogic/cpu_version/meson64_cpu.c
30266 --- a/vendor/amlogic/cpu_version/meson64_cpu.c 1970-01-01 08:00:00.000000000 +0800
30267 +++ b/vendor/amlogic/cpu_version/meson64_cpu.c 2022-06-24 14:37:49.458054143 +0800
30268 @@ -0,0 +1,98 @@
30357 + pr_info("Meson chip version = Rev%X (%X:%X - %X:%X)\n",
30367 diff -Naur a/vendor/amlogic/ge2d/bitblt.c b/vendor/amlogic/ge2d/bitblt.c
30368 --- a/vendor/amlogic/ge2d/bitblt.c 1970-01-01 08:00:00.000000000 +0800
30369 +++ b/vendor/amlogic/ge2d/bitblt.c 2022-06-24 14:37:49.483067496 +0800
30370 @@ -0,0 +1,120 @@
30397 + ge2d_cmd_cfg->src1_x_start = src_x;
30398 + ge2d_cmd_cfg->src1_x_end = src_x + w - 1;
30399 + ge2d_cmd_cfg->src1_y_start = src_y;
30400 + ge2d_cmd_cfg->src1_y_end = src_y + h - 1;
30402 + ge2d_cmd_cfg->dst_x_start = dst_x;
30403 + ge2d_cmd_cfg->dst_x_end = dst_x + w - 1;
30404 + ge2d_cmd_cfg->dst_y_start = dst_y;
30405 + ge2d_cmd_cfg->dst_y_end = dst_y + h - 1;
30407 + ge2d_cmd_cfg->sc_hsc_en = 0;
30408 + ge2d_cmd_cfg->sc_vsc_en = 0;
30409 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30410 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30411 + ge2d_cmd_cfg->hsc_div_en = 0;
30412 + ge2d_cmd_cfg->hsc_adv_num = 0;
30414 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30415 + ge2d_cmd_cfg->color_logic_op = LOGIC_OPERATION_COPY;
30416 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30417 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_COPY;
30418 + ge2d_cmd_cfg->wait_done_flag = block;
30430 + if (dp_gen_cfg->alu_const_color != 0xff) {
30431 + dp_gen_cfg->alu_const_color = 0xff;
30432 + wq->config.update_flag |= UPDATE_DP_GEN;
30434 + ge2d_cmd_cfg->src1_x_start = src_x;
30435 + ge2d_cmd_cfg->src1_x_end = src_x + w - 1;
30436 + ge2d_cmd_cfg->src1_y_start = src_y;
30437 + ge2d_cmd_cfg->src1_y_end = src_y + h - 1;
30439 + ge2d_cmd_cfg->dst_x_start = dst_x;
30440 + ge2d_cmd_cfg->dst_x_end = dst_x + w - 1;
30441 + ge2d_cmd_cfg->dst_y_start = dst_y;
30442 + ge2d_cmd_cfg->dst_y_end = dst_y + h - 1;
30444 + ge2d_cmd_cfg->sc_hsc_en = 0;
30445 + ge2d_cmd_cfg->sc_vsc_en = 0;
30446 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30447 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30448 + ge2d_cmd_cfg->hsc_div_en = 0;
30449 + ge2d_cmd_cfg->hsc_adv_num = 0;
30451 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30452 + ge2d_cmd_cfg->color_logic_op = LOGIC_OPERATION_COPY;
30453 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30454 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_SET;
30455 + ge2d_cmd_cfg->wait_done_flag = block;
30491 diff -Naur a/vendor/amlogic/ge2d/blend.c b/vendor/amlogic/ge2d/blend.c
30492 --- a/vendor/amlogic/ge2d/blend.c 1970-01-01 08:00:00.000000000 +0800
30493 +++ b/vendor/amlogic/ge2d/blend.c 2022-06-24 14:37:49.506248515 +0800
30494 @@ -0,0 +1,297 @@
30526 + ge2d_cmd_cfg->src1_x_start = src_x;
30527 + ge2d_cmd_cfg->src1_x_end = src_x + src_w - 1;
30528 + ge2d_cmd_cfg->src1_y_start = src_y;
30529 + ge2d_cmd_cfg->src1_y_end = src_y + src_h - 1;
30531 + ge2d_cmd_cfg->src2_x_start = src2_x;
30532 + ge2d_cmd_cfg->src2_x_end = src2_x + src2_w - 1;
30533 + ge2d_cmd_cfg->src2_y_start = src2_y;
30534 + ge2d_cmd_cfg->src2_y_end = src2_y + src2_h - 1;
30536 + ge2d_cmd_cfg->dst_x_start = dst_x;
30537 + ge2d_cmd_cfg->dst_x_end = dst_x + dst_w - 1;
30538 + ge2d_cmd_cfg->dst_y_start = dst_y;
30539 + ge2d_cmd_cfg->dst_y_end = dst_y + dst_h - 1;
30543 + ge2d_cmd_cfg->sc_hsc_en = 1;
30544 + ge2d_cmd_cfg->sc_vsc_en = 1;
30545 + ge2d_cmd_cfg->hsc_rpt_p0_num = 1;
30546 + ge2d_cmd_cfg->vsc_rpt_l0_num = 1;
30547 + ge2d_cmd_cfg->hsc_div_en = 1;
30549 + ge2d_cmd_cfg->hsc_adv_num =
30550 + ((dst_w - 1) < 1024) ? (dst_w - 1) : 0;
30552 + ge2d_cmd_cfg->hsc_adv_num = 0;
30555 + ge2d_cmd_cfg->sc_hsc_en = 0;
30556 + ge2d_cmd_cfg->sc_vsc_en = 0;
30557 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30558 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30559 + ge2d_cmd_cfg->hsc_div_en = 0;
30560 + ge2d_cmd_cfg->hsc_adv_num = 0;
30563 + ge2d_cmd_cfg->color_blend_mode = (op >> 24) & 0xff;
30564 + ge2d_cmd_cfg->color_src_blend_factor = (op >> 20) & 0xf;
30565 + ge2d_cmd_cfg->color_dst_blend_factor = (op >> 16) & 0xf;
30566 + ge2d_cmd_cfg->alpha_src_blend_factor = (op >> 4) & 0xf;
30567 + ge2d_cmd_cfg->alpha_dst_blend_factor = (op >> 0) & 0xf;
30570 + if (ge2d_cmd_cfg->color_blend_mode >= BLENDOP_LOGIC) {
30571 + ge2d_cmd_cfg->color_logic_op =
30572 + ge2d_cmd_cfg->color_blend_mode - BLENDOP_LOGIC;
30573 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30576 + ge2d_cmd_cfg->alpha_blend_mode = (op >> 8) & 0xff;
30577 + if (ge2d_cmd_cfg->alpha_blend_mode >= BLENDOP_LOGIC) {
30578 + ge2d_cmd_cfg->alpha_logic_op =
30579 + ge2d_cmd_cfg->alpha_blend_mode - BLENDOP_LOGIC;
30580 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30583 + ge2d_cmd_cfg->wait_done_flag = 1;
30597 + ge2d_cmd_cfg->src1_x_start = src_x;
30598 + ge2d_cmd_cfg->src1_x_end = src_x + src_w - 1;
30599 + ge2d_cmd_cfg->src1_y_start = src_y;
30600 + ge2d_cmd_cfg->src1_y_end = src_y + src_h - 1;
30602 + ge2d_cmd_cfg->src2_x_start = src2_x;
30603 + ge2d_cmd_cfg->src2_x_end = src2_x + src2_w - 1;
30604 + ge2d_cmd_cfg->src2_y_start = src2_y;
30605 + ge2d_cmd_cfg->src2_y_end = src2_y + src2_h - 1;
30607 + ge2d_cmd_cfg->dst_x_start = dst_x;
30608 + ge2d_cmd_cfg->dst_x_end = dst_x + dst_w - 1;
30609 + ge2d_cmd_cfg->dst_y_start = dst_y;
30610 + ge2d_cmd_cfg->dst_y_end = dst_y + dst_h - 1;
30614 + ge2d_cmd_cfg->sc_hsc_en = 1;
30615 + ge2d_cmd_cfg->sc_vsc_en = 1;
30616 + ge2d_cmd_cfg->hsc_rpt_p0_num = 1;
30617 + ge2d_cmd_cfg->vsc_rpt_l0_num = 1;
30618 + ge2d_cmd_cfg->hsc_div_en = 1;
30620 + ge2d_cmd_cfg->hsc_adv_num =
30621 + ((dst_w - 1) < 1024) ? (dst_w - 1) : 0;
30623 + ge2d_cmd_cfg->hsc_adv_num = 0;
30626 + ge2d_cmd_cfg->sc_hsc_en = 0;
30627 + ge2d_cmd_cfg->sc_vsc_en = 0;
30628 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30629 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30630 + ge2d_cmd_cfg->hsc_div_en = 0;
30631 + ge2d_cmd_cfg->hsc_adv_num = 0;
30634 + ge2d_cmd_cfg->color_blend_mode = (op >> 24) & 0xff;
30635 + ge2d_cmd_cfg->color_src_blend_factor = (op >> 20) & 0xf;
30636 + ge2d_cmd_cfg->color_dst_blend_factor = (op >> 16) & 0xf;
30637 + ge2d_cmd_cfg->alpha_src_blend_factor = (op >> 4) & 0xf;
30638 + ge2d_cmd_cfg->alpha_dst_blend_factor = (op >> 0) & 0xf;
30640 + if (ge2d_cmd_cfg->color_blend_mode >= BLENDOP_LOGIC) {
30641 + ge2d_cmd_cfg->color_logic_op =
30642 + ge2d_cmd_cfg->color_blend_mode - BLENDOP_LOGIC;
30643 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30646 + ge2d_cmd_cfg->alpha_blend_mode = (op >> 8) & 0xff;
30647 + if (ge2d_cmd_cfg->alpha_blend_mode >= BLENDOP_LOGIC) {
30648 + ge2d_cmd_cfg->alpha_logic_op =
30649 + ge2d_cmd_cfg->alpha_blend_mode - BLENDOP_LOGIC;
30650 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30653 + ge2d_cmd_cfg->wait_done_flag = 0;
30666 + ge2d_cmd_cfg->src1_x_start = src_x;
30667 + ge2d_cmd_cfg->src1_x_end = src_x + src_w - 1;
30668 + ge2d_cmd_cfg->src1_y_start = src_y;
30669 + ge2d_cmd_cfg->src1_y_end = src_y + src_h - 1;
30671 + ge2d_cmd_cfg->src2_x_start = src2_x;
30672 + ge2d_cmd_cfg->src2_x_end = src2_x + src2_w - 1;
30673 + ge2d_cmd_cfg->src2_y_start = src2_y;
30674 + ge2d_cmd_cfg->src2_y_end = src2_y + src2_h - 1;
30676 + ge2d_cmd_cfg->dst_x_start = dst_x;
30677 + ge2d_cmd_cfg->dst_x_end = dst_x + dst_w - 1;
30678 + ge2d_cmd_cfg->dst_y_start = dst_y;
30679 + ge2d_cmd_cfg->dst_y_end = dst_y + dst_h - 1;
30683 + ge2d_cmd_cfg->sc_hsc_en = 1;
30684 + ge2d_cmd_cfg->sc_vsc_en = 1;
30685 + ge2d_cmd_cfg->hsc_rpt_p0_num = 1;
30686 + ge2d_cmd_cfg->vsc_rpt_l0_num = 1;
30687 + ge2d_cmd_cfg->hsc_div_en = 1;
30689 + ge2d_cmd_cfg->hsc_adv_num =
30690 + ((dst_w - 1) < 1024) ? (dst_w - 1) : 0;
30692 + ge2d_cmd_cfg->hsc_adv_num = 0;
30695 + ge2d_cmd_cfg->sc_hsc_en = 0;
30696 + ge2d_cmd_cfg->sc_vsc_en = 0;
30697 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30698 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30699 + ge2d_cmd_cfg->hsc_div_en = 0;
30700 + ge2d_cmd_cfg->hsc_adv_num = 0;
30703 + ge2d_cmd_cfg->color_blend_mode = (op >> 24) & 0xff;
30704 + ge2d_cmd_cfg->color_src_blend_factor = (op >> 20) & 0xf;
30705 + ge2d_cmd_cfg->color_dst_blend_factor = (op >> 16) & 0xf;
30706 + ge2d_cmd_cfg->alpha_src_blend_factor = (op >> 4) & 0xf;
30707 + ge2d_cmd_cfg->alpha_dst_blend_factor = (op >> 0) & 0xf;
30710 + if (ge2d_cmd_cfg->color_blend_mode >= BLENDOP_LOGIC) {
30711 + ge2d_cmd_cfg->color_logic_op =
30712 + ge2d_cmd_cfg->color_blend_mode - BLENDOP_LOGIC;
30713 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30716 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30717 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_SET;
30719 + ge2d_cmd_cfg->wait_done_flag = 1;
30734 + ge2d_cmd_cfg->src1_x_start = src_x;
30735 + ge2d_cmd_cfg->src1_x_end = src_x + src_w - 1;
30736 + ge2d_cmd_cfg->src1_y_start = src_y;
30737 + ge2d_cmd_cfg->src1_y_end = src_y + src_h - 1;
30739 + ge2d_cmd_cfg->src2_x_start = src2_x;
30740 + ge2d_cmd_cfg->src2_x_end = src2_x + src2_w - 1;
30741 + ge2d_cmd_cfg->src2_y_start = src2_y;
30742 + ge2d_cmd_cfg->src2_y_end = src2_y + src2_h - 1;
30744 + ge2d_cmd_cfg->dst_x_start = dst_x;
30745 + ge2d_cmd_cfg->dst_x_end = dst_x + dst_w - 1;
30746 + ge2d_cmd_cfg->dst_y_start = dst_y;
30747 + ge2d_cmd_cfg->dst_y_end = dst_y + dst_h - 1;
30751 + ge2d_cmd_cfg->sc_hsc_en = 1;
30752 + ge2d_cmd_cfg->sc_vsc_en = 1;
30753 + ge2d_cmd_cfg->hsc_rpt_p0_num = 1;
30754 + ge2d_cmd_cfg->vsc_rpt_l0_num = 1;
30755 + ge2d_cmd_cfg->hsc_div_en = 1;
30757 + ge2d_cmd_cfg->hsc_adv_num =
30758 + ((dst_w - 1) < 1024) ? (dst_w - 1) : 0;
30760 + ge2d_cmd_cfg->hsc_adv_num = 0;
30763 + ge2d_cmd_cfg->sc_hsc_en = 0;
30764 + ge2d_cmd_cfg->sc_vsc_en = 0;
30765 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30766 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30767 + ge2d_cmd_cfg->hsc_div_en = 0;
30768 + ge2d_cmd_cfg->hsc_adv_num = 0;
30771 + ge2d_cmd_cfg->color_blend_mode = (op >> 24) & 0xff;
30772 + ge2d_cmd_cfg->color_src_blend_factor = (op >> 20) & 0xf;
30773 + ge2d_cmd_cfg->color_dst_blend_factor = (op >> 16) & 0xf;
30774 + ge2d_cmd_cfg->alpha_src_blend_factor = (op >> 4) & 0xf;
30775 + ge2d_cmd_cfg->alpha_dst_blend_factor = (op >> 0) & 0xf;
30778 + if (ge2d_cmd_cfg->color_blend_mode >= BLENDOP_LOGIC) {
30779 + ge2d_cmd_cfg->color_logic_op =
30780 + ge2d_cmd_cfg->color_blend_mode - BLENDOP_LOGIC;
30781 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30784 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30785 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_SET;
30787 + ge2d_cmd_cfg->wait_done_flag = 0;
30792 diff -Naur a/vendor/amlogic/ge2d/fillrect.c b/vendor/amlogic/ge2d/fillrect.c
30793 --- a/vendor/amlogic/ge2d/fillrect.c 1970-01-01 08:00:00.000000000 +0800
30794 +++ b/vendor/amlogic/ge2d/fillrect.c 2022-06-24 14:37:49.528700252 +0800
30795 @@ -0,0 +1,74 @@
30828 + ge2d_cmd_cfg->src1_x_start = x;
30829 + ge2d_cmd_cfg->src1_x_end = x + w - 1;
30830 + ge2d_cmd_cfg->src1_y_start = y;
30831 + ge2d_cmd_cfg->src1_y_end = y + h - 1;
30833 + ge2d_cmd_cfg->dst_x_start = x;
30834 + ge2d_cmd_cfg->dst_x_end = x + w - 1;
30835 + ge2d_cmd_cfg->dst_y_start = y;
30836 + ge2d_cmd_cfg->dst_y_end = y + h - 1;
30838 + ge2d_cmd_cfg->sc_hsc_en = 0;
30839 + ge2d_cmd_cfg->sc_vsc_en = 0;
30840 + ge2d_cmd_cfg->hsc_rpt_p0_num = 0;
30841 + ge2d_cmd_cfg->vsc_rpt_l0_num = 0;
30842 + ge2d_cmd_cfg->hsc_div_en = 0;
30843 + ge2d_cmd_cfg->hsc_adv_num = 0;
30845 + ge2d_cmd_cfg->src1_fill_color_en = 1;
30847 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
30848 + ge2d_cmd_cfg->color_logic_op = LOGIC_OPERATION_COPY;
30849 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
30850 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_COPY;
30851 + ge2d_cmd_cfg->wait_done_flag = 1;
30870 diff -Naur a/vendor/amlogic/ge2d/ge2d_dmabuf.c b/vendor/amlogic/ge2d/ge2d_dmabuf.c
30871 --- a/vendor/amlogic/ge2d/ge2d_dmabuf.c 1970-01-01 08:00:00.000000000 +0800
30872 +++ b/vendor/amlogic/ge2d/ge2d_dmabuf.c 2022-06-24 14:37:49.642250255 +0800
30873 @@ -0,0 +1,763 @@
30902 +#include <linux/dma-buf.h>
30905 +#include <linux/dma-mapping.h>
30907 +#include <linux/dma-contiguous.h>
30910 +#include <linux/dma-map-ops.h>
30946 + ge2d_log_dbg("[HIGH-MEM-MAP] pa(%lx) to va(%p), size: %d\n",
30966 + void *vaddr = (void *)(PAGE_MASK & (ulong)buf->vaddr);
30968 + if (!atomic_dec_and_test(&buf->refcount)) {
30970 + atomic_read(&buf->refcount));
30973 + cma_pages = phys_to_page(buf->dma_addr);
30981 + if (!dma_release_from_contiguous(buf->dev, cma_pages,
30982 + buf->size >> PAGE_SHIFT)) {
30985 + buf->vaddr = NULL;
30986 + clear_dma_buffer((struct aml_dma_buffer *)buf->priv, buf->index);
30987 + put_device(buf->dev);
30988 + ge2d_log_dbg("ge2d free:aml_dma_buf=0x%p,buf->index=%d\n",
30989 + buf, buf->index);
31002 + return (void *)(-EINVAL);
31009 + buf->attrs = attrs;
31025 + buf->vaddr = aml_map_phyaddr_to_virt(paddr, size);
31026 + buf->dev = get_device(dev);
31027 + buf->size = size;
31028 + buf->dma_dir = dma_dir;
31029 + buf->dma_addr = paddr;
31030 + atomic_inc(&buf->refcount);
31032 + buf, atomic_read(&buf->refcount));
31042 + int ret = -1;
31046 + return -EINVAL;
31049 + vsize = vma->vm_end - vma->vm_start;
31051 + pfn = buf->dma_addr >> PAGE_SHIFT;
31052 + ret = remap_pfn_range(vma, vma->vm_start, pfn,
31053 + vsize, vma->vm_page_prot);
31058 + vma->vm_flags |= VM_DONTEXPAND;
31060 + (unsigned long)buf->dma_addr, vma->vm_start,
31061 + buf->size);
31082 + struct aml_dma_buf *buf = dbuf->priv;
31083 + int num_pages = PAGE_ALIGN(buf->size) / PAGE_SIZE;
31086 + phys_addr_t phys = buf->dma_addr;
31092 + return -ENOMEM;
31094 + sgt = &attach->sgt;
31095 + /* Copy the buf->base_sgt scatter list to the attachment, as we can't
31101 + return -ENOMEM;
31103 + for_each_sg(sgt->sgl, sg, sgt->nents, i) {
31110 + attach->dma_dir = DMA_NONE;
31111 + dbuf_attach->priv = attach;
31119 + struct aml_attachment *attach = db_attach->priv;
31125 + sgt = &attach->sgt;
31128 + if (attach->dma_dir != DMA_NONE)
31129 + dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
31130 + attach->dma_dir);
31133 + db_attach->priv = NULL;
31140 + struct aml_attachment *attach = db_attach->priv;
31142 + struct mutex *lock = &db_attach->dmabuf->lock;
31147 + sgt = &attach->sgt;
31149 + if (attach->dma_dir == dma_dir) {
31155 + if (attach->dma_dir != DMA_NONE) {
31156 + dma_unmap_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
31157 + attach->dma_dir);
31158 + attach->dma_dir = DMA_NONE;
31161 + sgt->nents = dma_map_sg(db_attach->dev, sgt->sgl, sgt->orig_nents,
31163 + if (!sgt->nents) {
31166 + return (void *)(-EIO);
31169 + attach->dma_dir = dma_dir;
31184 + aml_dma_put(dbuf->priv);
31189 + struct aml_dma_buf *buf = dbuf->priv;
31191 + return buf->vaddr ? buf->vaddr + pgnum * PAGE_SIZE : NULL;
31196 + struct aml_dma_buf *buf = dbuf->priv;
31198 + return buf->vaddr;
31204 + return aml_dma_mmap(dbuf->priv, vma);
31228 + exp_info.size = buf->size;
31231 + if (WARN_ON(!buf->vaddr))
31239 + atomic_inc(&buf->refcount);
31241 + atomic_read(&buf->refcount));
31245 +/* ge2d dma-buf api.h*/
31252 + if (buffer->gd_buffer[i].alloc)
31263 + return -1;
31268 + mutex_lock(&(buffer->lock));
31269 + buffer->gd_buffer[index].mem_priv = NULL;
31270 + buffer->gd_buffer[index].index = 0;
31271 + buffer->gd_buffer[index].alloc = 0;
31272 + mutex_unlock(&(buffer->lock));
31284 + mutex_init(&buffer->lock);
31286 + buffer->gd_buffer[i].mem_priv = NULL;
31287 + buffer->gd_buffer[i].index = 0;
31288 + buffer->gd_buffer[i].alloc = 0;
31308 + return (-EINVAL);
31310 + return (-EINVAL);
31312 + return (-EINVAL);
31314 + size = PAGE_ALIGN(ge2d_req_buf->len);
31316 + return (-EINVAL);
31317 + buf = aml_dma_alloc(dev, 0, size, ge2d_req_buf->dma_dir,
31320 + return (-ENOMEM);
31321 + mutex_lock(&(buffer->lock));
31325 + mutex_unlock(&(buffer->lock));
31327 + return (-ENOMEM);
31329 + ((struct aml_dma_buf *)buf)->priv = buffer;
31330 + ((struct aml_dma_buf *)buf)->index = index;
31331 + buffer->gd_buffer[index].mem_priv = buf;
31332 + buffer->gd_buffer[index].index = index;
31333 + buffer->gd_buffer[index].alloc = 1;
31334 + mutex_unlock(&(buffer->lock));
31335 + ge2d_req_buf->index = index;
31337 + if (dma_buf->dma_dir == DMA_FROM_DEVICE)
31338 + dma_sync_single_for_cpu(dma_buf->dev,
31339 + dma_buf->dma_addr,
31340 + dma_buf->size, DMA_FROM_DEVICE);
31349 + return (-EINVAL);
31351 + return (-EINVAL);
31353 + buf = buffer->gd_buffer[index].mem_priv;
31356 + return (-EINVAL);
31371 + return (-EINVAL);
31373 + return (-EINVAL);
31375 + index = ge2d_exp_buf->index;
31377 + return (-EINVAL);
31379 + flags = ge2d_exp_buf->flags;
31380 + buf = buffer->gd_buffer[index].mem_priv;
31383 + return (-EINVAL);
31389 + return -EINVAL;
31401 + buffer->gd_buffer[index].fd = ret;
31402 + buffer->gd_buffer[index].dbuf = dbuf;
31403 + ge2d_exp_buf->fd = ret;
31409 + long ret = -1;
31410 + int fd = -1;
31418 + if (cfg == NULL || (cfg->fd < 0) || cfg->dev == NULL) {
31420 + return -EINVAL;
31422 + fd = cfg->fd;
31423 + dev = cfg->dev;
31424 + dir = cfg->dir;
31429 + return -EINVAL;
31455 + cfg->dbuf = dbuf;
31456 + cfg->attach = d_att;
31457 + cfg->vaddr = vaddr;
31458 + cfg->sg = sg;
31480 + int i = 0, ret = -1;
31485 + if (buffer->gd_buffer[i].alloc) {
31486 + dbuf = dma_buf_get(cfg->fd);
31489 + __func__, cfg->fd, dbuf);
31490 + return -EINVAL;
31493 + if (dbuf == buffer->gd_buffer[i].dbuf) {
31494 + cfg->dbuf = dbuf;
31495 + dma_buf = buffer->gd_buffer[i].mem_priv;
31496 + *addr = dma_buf->dma_addr;
31510 + int ret = -1;
31512 + if (cfg == NULL || (cfg->fd < 0)) {
31514 + return -EINVAL;
31523 + if (cfg->sg) {
31524 + sg_table = cfg->sg;
31525 + page = sg_page(sg_table->sgl);
31538 + if (cfg == NULL || (cfg->fd < 0)) {
31540 + return -EINVAL;
31543 + if (buffer->gd_buffer[i].alloc) {
31544 + if (cfg->dbuf == buffer->gd_buffer[i].dbuf) {
31557 + int fd = -1;
31565 + if (cfg == NULL || (cfg->fd < 0) || cfg->dev == NULL
31566 + || cfg->dbuf == NULL || cfg->vaddr == NULL
31567 + || cfg->attach == NULL || cfg->sg == NULL) {
31571 + fd = cfg->fd;
31572 + dev = cfg->dev;
31573 + dir = cfg->dir;
31574 + dbuf = cfg->dbuf;
31575 + vaddr = cfg->vaddr;
31576 + d_att = cfg->attach;
31577 + sg = cfg->sg;
31603 + buf = dmabuf->priv;
31608 + if ((buf->size > 0) && (buf->dev == dev))
31609 + dma_sync_single_for_device(buf->dev, buf->dma_addr,
31610 + buf->size, DMA_TO_DEVICE);
31625 + buf = dmabuf->priv;
31630 + if ((buf->size > 0) && (buf->dev == dev))
31631 + dma_sync_single_for_cpu(buf->dev, buf->dma_addr,
31632 + buf->size, DMA_FROM_DEVICE);
31637 diff -Naur a/vendor/amlogic/ge2d/ge2d_dmabuf.h b/vendor/amlogic/ge2d/ge2d_dmabuf.h
31638 --- a/vendor/amlogic/ge2d/ge2d_dmabuf.h 1970-01-01 08:00:00.000000000 +0800
31639 +++ b/vendor/amlogic/ge2d/ge2d_dmabuf.h 2022-06-24 14:37:49.664974610 +0800
31640 @@ -0,0 +1,85 @@
31663 +#include <linux/dma-buf.h>
31726 diff -Naur a/vendor/amlogic/ge2d/ge2dgen.c b/vendor/amlogic/ge2d/ge2dgen.c
31727 --- a/vendor/amlogic/ge2d/ge2dgen.c 1970-01-01 08:00:00.000000000 +0800
31728 +++ b/vendor/amlogic/ge2d/ge2dgen.c 2022-06-24 14:37:49.583267498 +0800
31729 @@ -0,0 +1,454 @@
31756 + src1_data_cfg->format_all = format_src;
31758 + src1_data_cfg->format = (format_src >> 8) & 3;
31759 + src1_data_cfg->mode_8b_sel = (format_src >> 6) & 3;
31760 + src1_data_cfg->lut_en = (format_src >> 5) & 1;
31761 + src1_data_cfg->sep_en = (format_src >> 2) & 1;
31763 + src1_data_cfg->endian = (format_src & GE2D_ENDIAN_MASK) >>
31765 + src1_data_cfg->color_map = (format_src & GE2D_COLOR_MAP_MASK) >>
31769 + src1_gen_cfg->pic_struct = (format_src >> 3) & 3;
31770 + src1_data_cfg->x_yc_ratio = (format_src >> 1) & 1;
31771 + src1_data_cfg->y_yc_ratio = (format_src >> 0) & 1;
31774 + src1_data_cfg->deep_color = 1;
31776 + src1_data_cfg->deep_color = 0;
31780 + dp_gen_cfg->use_matrix_default = MATRIX_CUSTOM;
31781 + dp_gen_cfg->conv_matrix_en = 1;
31787 + dp_gen_cfg->use_matrix_default =
31790 + dp_gen_cfg->conv_matrix_en = 1;
31793 + dp_gen_cfg->use_matrix_default =
31796 + dp_gen_cfg->use_matrix_default |=
31799 + dp_gen_cfg->conv_matrix_en = 1;
31801 + dp_gen_cfg->conv_matrix_en = 0;
31809 + src2_dst_data_cfg->src2_format_all = format;
31811 + src2_dst_data_cfg->src2_format = (format >> 8) & 3;
31812 + src2_dst_data_cfg->src2_endian = (format & GE2D_ENDIAN_MASK) >>
31814 + src2_dst_data_cfg->src2_color_map = (format & GE2D_COLOR_MAP_MASK) >>
31817 + src2_dst_data_cfg->src2_mode_8b_sel = (format >> 6) & 3;
31819 + src2_dst_gen_cfg->src2_pic_struct = (format >> 3) & 3;
31831 + src2_dst_data_cfg->dst_format_all = format_dst;
31832 + src2_dst_data_cfg->dst_format = (format_dst >> 8) & 3;
31833 + src2_dst_data_cfg->dst_endian = (format_dst & GE2D_ENDIAN_MASK) >>
31835 + src2_dst_data_cfg->dst_color_map = (format_dst & GE2D_COLOR_MAP_MASK) >>
31838 + src2_dst_data_cfg->dst_mode_8b_sel = (format_dst >> 6) & 3;
31839 + src2_dst_gen_cfg->dst_pic_struct = (format_dst >> 3) & 3;
31846 + ((src2_dst_data_cfg->dst_color_map | 1) == 15)) {
31847 + src2_dst_data_cfg->dst_format = 0;
31848 + src2_dst_data_cfg->dst_mode_8b_sel = 0;
31849 + src2_dst_data_cfg->dst2_pixel_byte_width = 1;
31851 + src2_dst_data_cfg->dst2_discard_mode = 0xc;
31853 + src2_dst_data_cfg->dst2_discard_mode = 0xf;
31854 + src2_dst_data_cfg->dst2_enable = 1;
31855 + src2_dst_data_cfg->dst2_color_map =
31856 + src2_dst_data_cfg->dst_color_map - 5;
31858 + src2_dst_data_cfg->dst2_enable = 0;
31863 + dp_gen_cfg->use_matrix_default = MATRIX_CUSTOM;
31864 + dp_gen_cfg->conv_matrix_en = 1;
31870 + dp_gen_cfg->use_matrix_default =
31873 + dp_gen_cfg->conv_matrix_en = 1;
31876 + dp_gen_cfg->use_matrix_default =
31879 + dp_gen_cfg->use_matrix_default |=
31882 + dp_gen_cfg->conv_matrix_en = 1;
31884 + dp_gen_cfg->conv_matrix_en = 0;
31899 + if ((format != src1_data_cfg->format_all) ||
31900 + (canvas_addr != src1_data_cfg->canaddr) ||
31901 + (phy_addr != src1_data_cfg->phy_addr) ||
31902 + (stride != src1_data_cfg->stride)) {
31903 + src1_data_cfg->canaddr = canvas_addr;
31906 + format, src2_dst_data_cfg->dst_format_all);
31907 + src1_data_cfg->phy_addr = phy_addr;
31908 + src1_data_cfg->stride = stride;
31909 + wq->config.update_flag |= UPDATE_SRC_DATA;
31910 + wq->config.update_flag |= UPDATE_SRC_GEN;
31911 + wq->config.update_flag |= UPDATE_DP_GEN;
31921 + if (dp_gen_cfg->antiflick_en != enable) {
31922 + dp_gen_cfg->antiflick_en = enable;
31923 + wq->config.update_flag |= UPDATE_DP_GEN;
31931 + ge2d_cmd_cfg->src1_buffer = buffer;
31932 + ge2d_cmd_cfg->release_flag |= RELEASE_SRC1_BUFFER;
31939 + ge2d_cmd_cfg->release_flag |= RELEASE_SRC1_CANVAS;
31947 + ge2d_cmd_cfg->src2_buffer = buffer;
31948 + ge2d_cmd_cfg->release_flag |= RELEASE_SRC2_BUFFER;
31955 + ge2d_cmd_cfg->release_flag |= RELEASE_SRC2_CANVAS;
31963 + ge2d_cmd_cfg->cmd_cb = cmd_cb;
31964 + ge2d_cmd_cfg->cmd_cb_param = param;
31965 + ge2d_cmd_cfg->release_flag |= RELEASE_CB;
31978 + if ((format != src2_dst_data_cfg->src2_format_all) ||
31979 + (canvas_addr != src2_dst_data_cfg->src2_canaddr) ||
31980 + (phy_addr != src2_dst_data_cfg->src2_phyaddr) ||
31981 + (stride != src2_dst_data_cfg->src2_stride)) {
31983 + src2_dst_data_cfg->src2_canaddr = canvas_addr;
31986 + src2_dst_data_cfg->src2_phyaddr = phy_addr;
31987 + src2_dst_data_cfg->src2_stride = stride;
31988 + wq->config.update_flag |= UPDATE_DST_DATA;
31989 + wq->config.update_flag |= UPDATE_DST_GEN;
32005 + if ((format != src2_dst_data_cfg->dst_format_all) ||
32006 + (canvas_addr != src2_dst_data_cfg->dst_canaddr) ||
32007 + (phy_addr != src2_dst_data_cfg->dst_phyaddr) ||
32008 + (stride != src2_dst_data_cfg->dst_stride)) {
32009 + src2_dst_data_cfg->dst_canaddr = canvas_addr;
32012 + src1_data_cfg->format_all, format);
32013 + src2_dst_data_cfg->dst_phyaddr = phy_addr;
32014 + src2_dst_data_cfg->dst_stride = stride;
32015 + wq->config.update_flag |= UPDATE_DST_DATA;
32016 + wq->config.update_flag |= UPDATE_DST_GEN;
32017 + wq->config.update_flag |= UPDATE_DP_GEN;
32025 + /* adjust w->x_end h->y_end */
32026 + w = x + w - 1;
32027 + h = y + h - 1;
32028 + if (src1_gen_cfg->clipx_start != x ||
32029 + src1_gen_cfg->clipx_end != w ||
32030 + src1_gen_cfg->clipy_start != y ||
32031 + src1_gen_cfg->clipy_end != h) {
32032 + src1_gen_cfg->clipx_start = x;
32033 + src1_gen_cfg->clipx_end = w;
32034 + src1_gen_cfg->clipy_start = y;
32035 + src1_gen_cfg->clipy_end = h;
32036 + wq->config.update_flag |= UPDATE_SRC_GEN;
32045 + /* adjust w->x_end h->y_end */
32046 + w = x + w - 1;
32047 + h = y + h - 1;
32048 + if (src2_dst_gen_cfg->src2_clipx_start != x ||
32049 + src2_dst_gen_cfg->src2_clipx_end != w ||
32050 + src2_dst_gen_cfg->src2_clipy_start != y ||
32051 + src2_dst_gen_cfg->src2_clipy_end != h) {
32052 + src2_dst_gen_cfg->src2_clipx_start = x;
32053 + src2_dst_gen_cfg->src2_clipx_end = w;
32054 + src2_dst_gen_cfg->src2_clipy_start = y;
32055 + src2_dst_gen_cfg->src2_clipy_end = h;
32056 + wq->config.update_flag |= UPDATE_DST_GEN;
32061 + int en, int key, int keymask, int keymode)
32065 + if (dp_gen_cfg->src1_key_en != en ||
32066 + dp_gen_cfg->src1_key != key ||
32067 + dp_gen_cfg->src1_key_mask != keymask ||
32068 + dp_gen_cfg->src1_key_mode != keymode) {
32069 + dp_gen_cfg->src1_key_en = en & 0x1;
32070 + dp_gen_cfg->src1_key = key;
32071 + dp_gen_cfg->src1_key_mask = keymask;
32072 + dp_gen_cfg->src1_key_mode = keymode & 0x1;
32074 + dp_gen_cfg->src1_vsc_bank_length = 4;
32075 + dp_gen_cfg->src1_hsc_bank_length = 4;
32076 + wq->config.update_flag |= UPDATE_DP_GEN;
32086 + if ((dp_gen_cfg->src1_gb_alpha != alpha1)
32087 + || (dp_gen_cfg->src2_gb_alpha != alpha2)) {
32088 + dp_gen_cfg->src1_gb_alpha = alpha1;
32089 + dp_gen_cfg->src2_gb_alpha = alpha2;
32090 + wq->config.update_flag |= UPDATE_DP_GEN;
32093 + if (dp_gen_cfg->src1_gb_alpha != alpha1) {
32094 + dp_gen_cfg->src1_gb_alpha = alpha1;
32095 + wq->config.update_flag |= UPDATE_DP_GEN;
32105 + if (src1_data_cfg->def_color != color) {
32106 + src1_data_cfg->def_color = color;
32107 + wq->config.update_flag |= UPDATE_SRC_DATA;
32119 + ge2d_cmd_cfg->src1_x_rev = src_x_dir;
32120 + ge2d_cmd_cfg->src1_y_rev = src_y_dir;
32121 + ge2d_cmd_cfg->dst_x_rev = dst_x_dir;
32122 + ge2d_cmd_cfg->dst_y_rev = dst_y_dir;
32123 + ge2d_cmd_cfg->dst_xy_swap = dst_xy_swap;
32130 + /* adjust w->x_end h->y_end */
32131 + w = x + w - 1;
32132 + h = y + h - 1;
32133 + if (src2_dst_gen_cfg->dst_clipx_start != x ||
32134 + src2_dst_gen_cfg->dst_clipx_end != w ||
32135 + src2_dst_gen_cfg->dst_clipy_start != y ||
32136 + src2_dst_gen_cfg->dst_clipy_end != h ||
32137 + src2_dst_gen_cfg->dst_clip_mode != mode) {
32138 + src2_dst_gen_cfg->dst_clipx_start = x;
32139 + src2_dst_gen_cfg->dst_clipx_end = w;
32140 + src2_dst_gen_cfg->dst_clipy_start = y;
32141 + src2_dst_gen_cfg->dst_clipy_end = h;
32142 + src2_dst_gen_cfg->dst_clip_mode = mode;
32143 + wq->config.update_flag |= UPDATE_DST_GEN;
32151 + /* adjust w->x_end h->y_end */
32152 + w = x + w - 1;
32153 + h = y + h - 1;
32154 + if (src2_dst_gen_cfg->src2_clipx_start != x ||
32155 + src2_dst_gen_cfg->src2_clipx_end != w ||
32156 + src2_dst_gen_cfg->src2_clipy_start != y ||
32157 + src2_dst_gen_cfg->src2_clipy_end != h) {
32158 + src2_dst_gen_cfg->src2_clipx_start = x;
32159 + src2_dst_gen_cfg->src2_clipx_end = w;
32160 + src2_dst_gen_cfg->src2_clipy_start = y;
32161 + src2_dst_gen_cfg->src2_clipy_end = h;
32162 + wq->config.update_flag |= UPDATE_DST_GEN;
32171 + if (dp_gen_cfg->alu_const_color != color) {
32172 + dp_gen_cfg->alu_const_color = color;
32173 + wq->config.update_flag |= UPDATE_DP_GEN;
32181 + dp_gen_cfg->conv_matrix_en = 0;
32182 + wq->config.update_flag |= UPDATE_DP_GEN;
32184 diff -Naur a/vendor/amlogic/ge2d/ge2dgen.h b/vendor/amlogic/ge2d/ge2dgen.h
32185 --- a/vendor/amlogic/ge2d/ge2dgen.h 1970-01-01 08:00:00.000000000 +0800
32186 +++ b/vendor/amlogic/ge2d/ge2dgen.h 2022-06-24 14:37:49.605999374 +0800
32187 @@ -0,0 +1,89 @@
32250 + int en, int key, int keymask, int keymode);
32277 diff -Naur a/vendor/amlogic/ge2d/ge2d_hw.c b/vendor/amlogic/ge2d/ge2d_hw.c
32278 --- a/vendor/amlogic/ge2d/ge2d_hw.c 1970-01-01 08:00:00.000000000 +0800
32279 +++ b/vendor/amlogic/ge2d/ge2d_hw.c 2022-06-24 14:37:49.691432221 +0800
32280 @@ -0,0 +1,1161 @@
32581 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->urgent_en, 10, 1);
32583 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->ddr_burst_size_y, 20, 2);
32584 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->ddr_burst_size_cb, 18, 2);
32585 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->ddr_burst_size_cr, 16, 2);
32589 + cfg->phy_addr,
32590 + cfg->stride);
32593 + ((cfg->canaddr & 0xff) << 24) |
32594 + (((cfg->canaddr >> 8) & 0xff) << 16) |
32595 + (((cfg->canaddr >> 16) & 0xff) << 8));
32599 + ((cfg->x_yc_ratio << 1) | cfg->y_yc_ratio),
32601 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->sep_en, 0, 1);
32602 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->endian, 7, 1);
32603 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->color_map, 3, 4);
32604 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->format, 0, 2);
32606 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->deep_color, 2, 1);
32608 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->mult_rounding, 18, 1);
32609 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->alpha_conv_mode0, 31, 1);
32610 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->alpha_conv_mode1, 10, 1);
32611 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->color_conv_mode0, 30, 1);
32612 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->color_conv_mode1, 26, 1);
32614 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->mode_8b_sel, 5, 2);
32615 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->lut_en, 3, 1);
32617 + ge2d_reg_write(GE2D_SRC1_DEF_COLOR, cfg->def_color);
32618 + if (cfg->x_yc_ratio)
32624 + if (cfg->y_yc_ratio)
32693 + (cfg->clipx_start_ex << 31) |
32694 + (cfg->clipx_start << 16) |
32695 + (cfg->clipx_end_ex << 15) |
32696 + (cfg->clipx_end << 0)
32700 + (cfg->clipy_start_ex << 31) |
32701 + (cfg->clipy_start << 16) |
32702 + (cfg->clipy_end_ex << 15) |
32703 + (cfg->clipy_end << 0)
32706 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->pic_struct, 1, 2);
32707 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, (cfg->fill_mode & 0x1), 4, 1);
32710 + ((cfg->fill_mode & 0x2) << 7) |
32711 + cfg->outside_alpha, 0, 9);
32713 + ge2d_reg_set_bits(GE2D_SRC1_FMT_CTRL, cfg->chfmt_rpt_pix, 19, 1);
32714 + ge2d_reg_set_bits(GE2D_SRC1_FMT_CTRL, cfg->cvfmt_rpt_pix, 17, 1);
32719 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->urgent_en, 9, 1);
32720 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->ddr_burst_size, 22, 2);
32724 + cfg->src2_phyaddr,
32725 + cfg->src2_stride);
32727 + cfg->dst_phyaddr,
32728 + cfg->dst_stride);
32731 + ge2d_reg_write(GE2D_SRC2_DST_CANVAS, (cfg->src2_canaddr << 8) |
32732 + ((cfg->dst_canaddr & 0xff) << 0) |
32733 + ((cfg->dst_canaddr & 0xff00) << 8)
32737 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->src2_endian, 15, 1);
32738 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->src2_color_map, 11, 4);
32739 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->src2_format, 8, 2);
32740 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->dst_endian, 23, 1);
32741 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->dst_color_map, 19, 4);
32742 + ge2d_reg_set_bits(GE2D_GEN_CTRL2, cfg->dst_format, 16, 2);
32743 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->src2_mode_8b_sel, 15, 2);
32744 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->dst_mode_8b_sel, 24, 2);
32746 + ge2d_reg_set_bits(GE2D_GEN_CTRL3, cfg->dst2_pixel_byte_width, 16, 2);
32747 + ge2d_reg_set_bits(GE2D_GEN_CTRL3, cfg->dst2_color_map, 19, 4);
32748 + ge2d_reg_set_bits(GE2D_GEN_CTRL3, cfg->dst2_discard_mode, 10, 4);
32750 + ge2d_reg_set_bits(GE2D_GEN_CTRL3, cfg->dst2_enable, 8, 1);
32751 + ge2d_reg_write(GE2D_SRC2_DEF_COLOR, cfg->src2_def_color);
32757 + (cfg->src2_clipx_start << 16) |
32758 + (cfg->src2_clipx_end << 0)
32762 + (cfg->src2_clipy_start << 16) |
32763 + (cfg->src2_clipy_end << 0)
32766 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->src2_pic_struct, 12, 2);
32767 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, (cfg->src2_fill_mode & 0x1), 14, 1);
32770 + ((cfg->src2_fill_mode & 0x2) << 7) |
32771 + cfg->src2_outside_alpha, 16, 9);
32774 + (cfg->dst_clipx_start << 16) |
32775 + (cfg->dst_clipx_end << 0)
32779 + (cfg->dst_clipy_start << 16) |
32780 + (cfg->dst_clipy_end << 0)
32783 + ge2d_reg_set_bits(GE2D_GEN_CTRL0, cfg->dst_clip_mode, 23, 1);
32784 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->dst_pic_struct, 14, 2);
32789 + struct ge2d_dp_gen_s *cfg = &config->dp_gen;
32800 + if (cfg->conv_matrix_en) {
32801 + cfg->antiflick_ycbcr_rgb_sel = 0; /* 0: yuv2rgb 1:rgb2rgb */
32802 + cfg->antiflick_cbcr_en = 1;
32803 + cfg->antiflick_r_coef = 0;
32804 + cfg->antiflick_g_coef = 0;
32805 + cfg->antiflick_b_coef = 0;
32807 + cfg->antiflick_ycbcr_rgb_sel = 1; /* 0: yuv2rgb 1:rgb2rgb */
32808 + cfg->antiflick_cbcr_en = 1;
32809 + cfg->antiflick_r_coef = 0x42; /* 0.257 */
32810 + cfg->antiflick_g_coef = 0x81; /* 0.504 */
32811 + cfg->antiflick_b_coef = 0x19; /* 0.098 */
32813 + memcpy(cfg->antiflick_color_filter_n1, antiflick_color_filter_n1,
32815 + memcpy(cfg->antiflick_color_filter_n2, antiflick_color_filter_n2,
32817 + memcpy(cfg->antiflick_color_filter_n3, antiflick_color_filter_n3,
32819 + memcpy(cfg->antiflick_color_filter_th, antiflick_color_filter_th,
32821 + memcpy(cfg->antiflick_alpha_filter_n1, antiflick_alpha_filter_n1,
32823 + memcpy(cfg->antiflick_alpha_filter_n2, antiflick_alpha_filter_n2,
32825 + memcpy(cfg->antiflick_alpha_filter_n3, antiflick_alpha_filter_n3,
32827 + memcpy(cfg->antiflick_alpha_filter_th, antiflick_alpha_filter_th,
32829 + cfg->src1_vsc_bank_length = 4;
32830 + cfg->src1_hsc_bank_length = 4;
32832 + ((cfg->src1_hsc_rpt_ctrl << 9) |
32833 + (cfg->src1_vsc_rpt_ctrl << 8) |
32834 + (cfg->src1_vsc_phase0_always_en << 7) |
32835 + (cfg->src1_vsc_bank_length << 4) |
32836 + (cfg->src1_hsc_phase0_always_en << 3) |
32837 + (cfg->src1_hsc_bank_length << 0)), 0, 10);
32840 + ((cfg->src1_vsc_nearest_en << 1) |
32841 + (cfg->src1_hsc_nearest_en << 0)), 29, 2);
32842 + if (cfg->antiflick_en == 1) {
32846 + (cfg->antiflick_ycbcr_rgb_sel << 25) |
32847 + (cfg->antiflick_cbcr_en << 24) |
32848 + ((cfg->antiflick_r_coef & 0xff) << 16) |
32849 + ((cfg->antiflick_g_coef & 0xff) << 8) |
32850 + ((cfg->antiflick_b_coef & 0xff) << 0)
32854 + ((cfg->antiflick_color_filter_th[0] & 0xff) << 24) |
32855 + ((cfg->antiflick_color_filter_n3[0] & 0xff) << 16) |
32856 + ((cfg->antiflick_color_filter_n2[0] & 0xff) << 8) |
32857 + ((cfg->antiflick_color_filter_n1[0] & 0xff) << 0)
32861 + ((cfg->antiflick_color_filter_th[1] & 0xff) << 24) |
32862 + ((cfg->antiflick_color_filter_n3[1] & 0xff) << 16) |
32863 + ((cfg->antiflick_color_filter_n2[1] & 0xff) << 8) |
32864 + ((cfg->antiflick_color_filter_n1[1] & 0xff) << 0)
32868 + ((cfg->antiflick_color_filter_th[2] & 0xff) << 24) |
32869 + ((cfg->antiflick_color_filter_n3[2] & 0xff) << 16) |
32870 + ((cfg->antiflick_color_filter_n2[2] & 0xff) << 8) |
32871 + ((cfg->antiflick_color_filter_n1[2] & 0xff) << 0)
32875 + ((cfg->antiflick_color_filter_n3[3] & 0xff) << 16) |
32876 + ((cfg->antiflick_color_filter_n2[3] & 0xff) << 8) |
32877 + ((cfg->antiflick_color_filter_n1[3] & 0xff) << 0)
32881 + ((cfg->antiflick_alpha_filter_th[0] & 0xff) << 24) |
32882 + ((cfg->antiflick_alpha_filter_n3[0] & 0xff) << 16) |
32883 + ((cfg->antiflick_alpha_filter_n2[0] & 0xff) << 8) |
32884 + ((cfg->antiflick_alpha_filter_n1[0] & 0xff) << 0)
32888 + ((cfg->antiflick_alpha_filter_th[1] & 0xff) << 24) |
32889 + ((cfg->antiflick_alpha_filter_n3[1] & 0xff) << 16) |
32890 + ((cfg->antiflick_alpha_filter_n2[1] & 0xff) << 8) |
32891 + ((cfg->antiflick_alpha_filter_n1[1] & 0xff) << 0)
32895 + ((cfg->antiflick_alpha_filter_th[2] & 0xff) << 24) |
32896 + ((cfg->antiflick_alpha_filter_n3[2] & 0xff) << 16) |
32897 + ((cfg->antiflick_alpha_filter_n2[2] & 0xff) << 8) |
32898 + ((cfg->antiflick_alpha_filter_n1[2] & 0xff) << 0)
32902 + ((cfg->antiflick_alpha_filter_n3[3] & 0xff) << 16) |
32903 + ((cfg->antiflick_alpha_filter_n2[3] & 0xff) << 8) |
32904 + ((cfg->antiflick_alpha_filter_n1[3] & 0xff) << 0)
32909 + if (cfg->use_matrix_default & MATRIX_CUSTOM) {
32910 + struct ge2d_matrix_s *matrix = &config->matrix_custom;
32913 + cfg->matrix_coef[0] = matrix->coef0;
32914 + cfg->matrix_coef[1] = matrix->coef1;
32915 + cfg->matrix_coef[2] = matrix->coef2;
32916 + cfg->matrix_coef[3] = matrix->coef3;
32917 + cfg->matrix_coef[4] = matrix->coef4;
32918 + cfg->matrix_coef[5] = matrix->coef5;
32919 + cfg->matrix_coef[6] = matrix->coef6;
32920 + cfg->matrix_coef[7] = matrix->coef7;
32921 + cfg->matrix_coef[8] = matrix->coef8;
32922 + cfg->matrix_offset[0] = matrix->offset0;
32923 + cfg->matrix_offset[1] = matrix->offset1;
32924 + cfg->matrix_offset[2] = matrix->offset2;
32925 + cfg->matrix_sat_in_en = matrix->sat_in_en;
32928 + (matrix->pre_offset0 << 20) |
32929 + (matrix->pre_offset1 << 10) |
32930 + matrix->pre_offset2);
32932 + if (cfg->use_matrix_default & MATRIX_YCC_TO_RGB) {
32933 + /* ycbcr(16-235) to rgb(0-255) */
32934 + cfg->matrix_coef[0] = 0x4a8;
32935 + cfg->matrix_coef[1] = 0;
32936 + cfg->matrix_coef[2] = 0x662;
32937 + cfg->matrix_coef[3] = 0x4a8;
32938 + cfg->matrix_coef[4] = 0x1e6f;
32939 + cfg->matrix_coef[5] = 0x1cbf;
32940 + cfg->matrix_coef[6] = 0x4a8;
32941 + cfg->matrix_coef[7] = 0x811;
32942 + cfg->matrix_coef[8] = 0x0;
32943 + cfg->matrix_offset[0] = 0;
32944 + cfg->matrix_offset[1] = 0;
32945 + cfg->matrix_offset[2] = 0;
32946 + cfg->matrix_sat_in_en = 1;
32947 + cfg->matrix_minus_16_ctrl = 0x4;
32948 + cfg->matrix_sign_ctrl = 0x3;
32949 + } else if (cfg->use_matrix_default & MATRIX_RGB_TO_YCC) {
32950 + if (cfg->use_matrix_default & MATRIX_BT_709) {
32953 + /* 0 -0.101 -0.338 0.439 128 */
32954 + /* 0 0.439 -0.399 -0.04 128 */
32955 + cfg->matrix_coef[0] = 0xbb;
32956 + cfg->matrix_coef[1] = 0x275;
32957 + cfg->matrix_coef[2] = 0x3f;
32958 + cfg->matrix_coef[3] = 0x1f99;
32959 + cfg->matrix_coef[4] = 0x1ea6;
32960 + cfg->matrix_coef[5] = 0x1c2;
32961 + cfg->matrix_coef[6] = 0x1c2;
32962 + cfg->matrix_coef[7] = 0x1e67;
32963 + cfg->matrix_coef[8] = 0x1fd7;
32965 + /* rgb(0-255) to ycbcr(16-235) */
32967 + /* -0.148 -0.291 0.439 */
32968 + /* 0.439 -0.368 -0.071 */
32969 + cfg->matrix_coef[0] = 0x107;
32970 + cfg->matrix_coef[1] = 0x204;
32971 + cfg->matrix_coef[2] = 0x64;
32972 + cfg->matrix_coef[3] = 0x1f68;
32973 + cfg->matrix_coef[4] = 0x1ed6;
32974 + cfg->matrix_coef[5] = 0x1c2;
32975 + cfg->matrix_coef[6] = 0x1c2;
32976 + cfg->matrix_coef[7] = 0x1e87;
32977 + cfg->matrix_coef[8] = 0x1fb7;
32979 + cfg->matrix_offset[0] = 16;
32980 + cfg->matrix_offset[1] = 128;
32981 + cfg->matrix_offset[2] = 128;
32982 + cfg->matrix_sat_in_en = 0;
32983 + cfg->matrix_minus_16_ctrl = 0;
32984 + cfg->matrix_sign_ctrl = 0;
32985 + } else if (cfg->use_matrix_default &
32987 + /* ycbcr (0-255) to rgb(0-255) */
32989 + /* 1, -0.34414, -0.71414 */
32991 + cfg->matrix_coef[0] = 0x400;
32992 + cfg->matrix_coef[1] = 0;
32993 + cfg->matrix_coef[2] = 0x59c;
32994 + cfg->matrix_coef[3] = 0x400;
32995 + cfg->matrix_coef[4] = 0x1ea0;
32996 + cfg->matrix_coef[5] = 0x1d25;
32997 + cfg->matrix_coef[6] = 0x400;
32998 + cfg->matrix_coef[7] = 0x717;
32999 + cfg->matrix_coef[8] = 0;
33000 + cfg->matrix_offset[0] = 0;
33001 + cfg->matrix_offset[1] = 0;
33002 + cfg->matrix_offset[2] = 0;
33003 + cfg->matrix_sat_in_en = 0;
33004 + cfg->matrix_minus_16_ctrl = 0;
33005 + cfg->matrix_sign_ctrl = 0x3;
33006 + } else if (cfg->use_matrix_default &
33008 + cfg->matrix_coef[0] = 0x132;
33009 + cfg->matrix_coef[1] = 0x259;
33010 + cfg->matrix_coef[2] = 0x75;
33011 + cfg->matrix_coef[3] = 0x1f53;
33012 + cfg->matrix_coef[4] = 0x1ead;
33013 + cfg->matrix_coef[5] = 0x200;
33014 + cfg->matrix_coef[6] = 0x200;
33015 + cfg->matrix_coef[7] = 0x1e53;
33016 + cfg->matrix_coef[8] = 0x1fad;
33017 + cfg->matrix_offset[0] = 0;
33018 + cfg->matrix_offset[1] = 128;
33019 + cfg->matrix_offset[2] = 128;
33020 + cfg->matrix_sat_in_en = 0;
33021 + cfg->matrix_minus_16_ctrl = 0;
33022 + cfg->matrix_sign_ctrl = 0;
33025 + if (cfg->matrix_minus_16_ctrl)
33030 + if (cfg->matrix_sign_ctrl & 3)
33038 + (cfg->matrix_coef[0] << 16) |
33039 + (cfg->matrix_coef[1] << 0)
33043 + (cfg->matrix_coef[2] << 16) |
33044 + (cfg->matrix_coef[3] << 0)
33048 + (cfg->matrix_coef[4] << 16) |
33049 + (cfg->matrix_coef[5] << 0)
33053 + (cfg->matrix_coef[6] << 16) |
33054 + (cfg->matrix_coef[7] << 0)
33058 + (cfg->matrix_coef[8] << 16) |
33059 + (cfg->matrix_sat_in_en << 7) |
33061 + (cfg->matrix_minus_16_ctrl << 4) |
33062 + (cfg->matrix_sign_ctrl << 1) |
33064 + (cfg->conv_matrix_en << 0)
33068 + (cfg->matrix_offset[0] << 20) |
33069 + (cfg->matrix_offset[1] << 10) |
33070 + (cfg->matrix_offset[2] << 0)
33073 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->src1_gb_alpha, 0, 8);
33075 + cfg->src1_gb_alpha_en, 29, 1);
33078 + ge2d_reg_set_bits(GE2D_GEN_CTRL5, cfg->src2_gb_alpha, 0, 8);
33080 + cfg->src2_gb_alpha_en, 8, 1);
33083 + ge2d_reg_write(GE2D_ALU_CONST_COLOR, cfg->alu_const_color);
33084 + ge2d_reg_write(GE2D_SRC1_KEY, cfg->src1_key);
33085 + ge2d_reg_write(GE2D_SRC1_KEY_MASK, cfg->src1_key_mask);
33087 + ge2d_reg_write(GE2D_SRC2_KEY, cfg->src2_key);
33088 + ge2d_reg_write(GE2D_SRC2_KEY_MASK, cfg->src2_key_mask);
33090 + ge2d_reg_write(GE2D_DST_BITMASK, cfg->bitmask);
33093 + ((cfg->bytemask_only << 5) |
33094 + (cfg->bitmask_en << 4) |
33095 + (cfg->src2_key_en << 3) |
33096 + (cfg->src2_key_mode << 2) |
33097 + (cfg->src1_key_en << 1) |
33098 + (cfg->src1_key_mode << 0)), 26, 6);
33117 + unsigned int src1_y_end = cfg->src1_y_end + 1;
33126 + if ((cfg->src1_fmt & GE2D_FORMAT_YUV) &&
33127 + ((cfg->dst_fmt & GE2D_FORMAT_YUV) == 0)) {
33129 + if ((cfg->src1_x_rev + cfg->dst_x_rev) == 1) {
33140 + if ((cfg->src1_y_rev + cfg->dst_y_rev) == 1) {
33152 + if ((cfg->src1_x_rev + cfg->dst_x_rev) == 1) {
33164 + if ((cfg->src1_y_rev + cfg->dst_y_rev) == 1) {
33177 + ((cfg->src1_x_start & 0x3fff) << 16) |
33179 + ((cfg->src1_x_end & 0x3fff) << 0)
33184 + ((cfg->src1_y_start & 0x3fff) << 16) |
33192 + if (((cfg->src1_x_end - cfg->src1_x_start) ==
33193 + (cfg->dst_x_end - cfg->dst_x_start)) &&
33194 + ((cfg->src1_y_end - cfg->src1_y_start) ==
33195 + (cfg->dst_y_end - cfg->dst_y_start))) {
33202 + (cfg->src2_x_start << 16) |
33203 + (cfg->src2_x_end << 0)
33207 + (cfg->src2_y_start << 16) |
33208 + (cfg->src2_y_end << 0)
33212 + (cfg->dst_x_start << 16) |
33213 + (cfg->dst_x_end << 0)
33217 + (cfg->dst_y_start << 16) |
33218 + (cfg->dst_y_end << 0)
33221 + widthi = cfg->src1_x_end - cfg->src1_x_start + 1;
33222 + heighti = cfg->src1_y_end - cfg->src1_y_start + 1;
33224 + widtho = cfg->dst_xy_swap ? (cfg->dst_y_end - cfg->dst_y_start + 1) :
33225 + (cfg->dst_x_end - cfg->dst_x_start + 1);
33226 + heighto = cfg->dst_xy_swap ? (cfg->dst_x_end - cfg->dst_x_start + 1) :
33227 + (cfg->dst_y_end - cfg->dst_y_start + 1);
33235 + if (cfg->hsc_phase_step == 0)
33236 + cfg->hsc_phase_step = ((tmp_widthi << 18) / widtho) <<
33239 + if (cfg->vsc_phase_step == 0)
33240 + cfg->vsc_phase_step = ((tmp_heighti << 18) / heighto) <<
33243 + if ((cfg->sc_hsc_en) && (cfg->hsc_div_en)) {
33244 + cfg->hsc_div_length = (124 << 24) / cfg->hsc_phase_step;
33246 + multo = cfg->hsc_phase_step * cfg->hsc_div_length;
33247 + cfg->hsc_adv_num = multo >> 24;
33248 + cfg->hsc_adv_phase = multo & 0xffffff;
33256 + cfg->vsc_ini_phase = 0;
33261 + cfg->sc_vsc_en = 1;
33262 + cfg->vsc_rpt_l0_num = 1;
33264 + cfg->vsc_ini_phase =
33265 + 0x5000000/rate_h - 0x800000;
33267 + cfg->vsc_ini_phase = 0x5000000;
33270 + cfg->sc_vsc_en = 1;
33271 + cfg->vsc_rpt_l0_num = 2;
33272 + cfg->vsc_ini_phase =
33278 + cfg->hsc_ini_phase = 0;
33283 + cfg->sc_hsc_en = 1;
33284 + cfg->hsc_rpt_p0_num = 1;
33286 + cfg->hsc_ini_phase =
33287 + 0x5000000/rate_w - 0x800000;
33289 + cfg->hsc_ini_phase = 0x5000000;
33292 + cfg->sc_hsc_en = 1;
33293 + cfg->hsc_rpt_p0_num = 2;
33294 + cfg->hsc_ini_phase =
33303 + ((cfg->hsc_div_en << 17) |
33304 + (cfg->hsc_div_length << 4) |
33307 + (cfg->sc_vsc_en << 1) |
33308 + (cfg->sc_hsc_en << 0)), 11, 18);
33310 + ge2d_reg_write(GE2D_HSC_START_PHASE_STEP, cfg->hsc_phase_step);
33312 + ge2d_reg_write(GE2D_HSC_PHASE_SLOPE, cfg->hsc_phase_slope);
33316 + (cfg->hsc_adv_num << 24) |
33317 + (cfg->hsc_adv_phase << 0)
33319 + if (cfg->hsc_adv_num > 255)
33320 + cfg->hsc_adv_num = cfg->hsc_adv_num >> 8;
33322 + cfg->hsc_adv_num = 0;
33324 + (cfg->hsc_rpt_p0_num << 29) |
33325 + (cfg->hsc_adv_num << 24) |
33326 + ((cfg->hsc_ini_phase & 0xffffff) << 0)
33330 + (cfg->hsc_adv_num << 24) |
33331 + (cfg->hsc_adv_phase << 0)
33334 + (cfg->hsc_rpt_p0_num << 29) |
33335 + ((cfg->hsc_ini_phase & 0xffffff) << 0)
33339 + ge2d_reg_write(GE2D_VSC_START_PHASE_STEP, cfg->vsc_phase_step);
33341 + ge2d_reg_write(GE2D_VSC_PHASE_SLOPE, cfg->vsc_phase_slope);
33344 + (cfg->vsc_rpt_l0_num << 29) |
33345 + (cfg->vsc_ini_phase << 0)
33350 + (cfg->src2_cmult_ad << 27) |
33351 + (cfg->src1_cmult_asel << 25) |
33352 + (cfg->src2_cmult_asel << 23) |
33353 + (cfg->color_blend_mode << 20) |
33354 + (cfg->color_src_blend_factor << 16) |
33355 + (((cfg->color_blend_mode == 5) ?
33356 + cfg->color_logic_op :
33357 + cfg->color_dst_blend_factor) << 12) |
33358 + (cfg->alpha_blend_mode << 8) |
33359 + (cfg->alpha_src_blend_factor << 4) |
33360 + (((cfg->alpha_blend_mode == 5) ?
33361 + cfg->alpha_logic_op :
33362 + cfg->alpha_dst_blend_factor) << 0)
33367 + (cfg->src1_cmult_asel << 25) |
33368 + (cfg->src2_cmult_asel << 24) |
33369 + (cfg->color_blend_mode << 20) |
33370 + (cfg->color_src_blend_factor << 16) |
33371 + (((cfg->color_blend_mode == 5) ? cfg->color_logic_op :
33372 + cfg->color_dst_blend_factor) << 12) |
33373 + (cfg->alpha_blend_mode << 8) |
33374 + (cfg->alpha_src_blend_factor << 4) |
33375 + (((cfg->alpha_blend_mode == 5) ? cfg->alpha_logic_op :
33376 + cfg->alpha_dst_blend_factor) << 0)
33384 + ge2d_reg_set_bits(GE2D_GEN_CTRL4, cfg->hang_flag, 0, 1);
33386 + (cfg->src2_fill_color_en << 9) |
33387 + (cfg->src1_fill_color_en << 8) |
33388 + (cfg->dst_xy_swap << 7) |
33389 + (cfg->dst_x_rev << 6) |
33390 + (cfg->dst_y_rev << 5) |
33391 + (cfg->src2_x_rev << 4) |
33392 + (cfg->src2_y_rev << 3) |
33393 + (cfg->src1_x_rev << 2) |
33394 + (cfg->src1_y_rev << 1) |
33397 + cfg->release_flag |= START_FLAG;
33422 + ge2d_reg_set_bits(GE2D_GEN_CTRL1, cfg->interrupt_ctrl, 24, 2);
33425 + (cfg->dp_onoff_mode << 31) |
33426 + (cfg->dp_on_cnt << 16) |
33427 + (cfg->vfmt_onoff_en << 15) |
33428 + (cfg->dp_off_cnt << 0)
33432 + (cfg->fifo_size << 26) |
33433 + (cfg->fifo_size << 24) |
33434 + (cfg->fifo_size << 22) |
33435 + (cfg->fifo_size << 20) |
33436 + (cfg->burst_ctrl << 18) |
33437 + (cfg->burst_ctrl << 16),
33442 diff -Naur a/vendor/amlogic/ge2d/ge2d_io.h b/vendor/amlogic/ge2d/ge2d_io.h
33443 --- a/vendor/amlogic/ge2d/ge2d_io.h 1970-01-01 08:00:00.000000000 +0800
33444 +++ b/vendor/amlogic/ge2d/ge2d_io.h 2022-06-24 14:37:49.714608731 +0800
33445 @@ -0,0 +1,191 @@
33474 +#define GE2DBUS_REG_ADDR(reg) (((reg - 0x1800) << 2))
33552 + ge2d_dump_reg_cnt--;
33567 + val = (ge2d_reg_read(reg) >> (start)) & ((1L << (len)) - 1);
33577 + ~(((1L << (len)) - 1) << (start))) |
33578 + (((value) & ((1L << (len)) - 1)) << (start))));
33585 + ~(((1L << (_len))-1) << (_start))) |
33586 + (((_value)&((1L<<(_len))-1)) << (_start))));
33593 + ~(((1L << (_len))-1) << (_start))) |
33594 + (((_value)&((1L<<(_len))-1)) << (_start))));
33601 + ~(((1L << (_len))-1) << (_start))) |
33602 + (((_value)&((1L<<(_len))-1)) << (_start))));
33637 diff -Naur a/vendor/amlogic/ge2d/ge2d_log.h b/vendor/amlogic/ge2d/ge2d_log.h
33638 --- a/vendor/amlogic/ge2d/ge2d_log.h 1970-01-01 08:00:00.000000000 +0800
33639 +++ b/vendor/amlogic/ge2d/ge2d_log.h 2022-06-24 14:37:49.735290506 +0800
33640 @@ -0,0 +1,52 @@
33693 diff -Naur a/vendor/amlogic/ge2d/ge2d_main.c b/vendor/amlogic/ge2d/ge2d_main.c
33694 --- a/vendor/amlogic/ge2d/ge2d_main.c 1970-01-01 08:00:00.000000000 +0800
33695 +++ b/vendor/amlogic/ge2d/ge2d_main.c 2022-06-24 14:37:49.764406249 +0800
33696 @@ -0,0 +1,1404 @@
33856 + return -EINVAL;
33859 + ge2d_log_info("ge2d dump_reg_enbale: %d->%d\n",
33883 + return -EINVAL;
33886 + ge2d_log_info("ge2d dump_reg: %d->%d\n", ge2d_dump_reg_cnt, res);
33908 + return -EINVAL;
33911 + ge2d_log_info("ge2d log_level: %d->%d\n", ge2d_log_level, res);
33925 + return -1;
33927 + file->private_data = context;
33959 + &uf_ge2d_para->para_config_memtype.ge2d_magic);
33969 + &(ge2d_config_ex_mem->_ge2d_config_ex);
33971 + &pge2d_config_ex->src_para,
33972 + &uf_ex_mem->_ge2d_config_ex.src_para,
33975 + &pge2d_config_ex->src2_para,
33976 + &uf_ex_mem->_ge2d_config_ex.src2_para,
33979 + &pge2d_config_ex->dst_para,
33980 + &uf_ex_mem->_ge2d_config_ex.dst_para,
33982 + r |= copy_from_user(&pge2d_config_ex->src_key,
33983 + &uf_ex_mem->_ge2d_config_ex.src_key,
33985 + r |= copy_from_user(&pge2d_config_ex->src2_key,
33986 + &uf_ex_mem->_ge2d_config_ex.src2_key,
33989 + r |= get_user(pge2d_config_ex->src1_cmult_asel,
33990 + &uf_ex_mem->_ge2d_config_ex.src1_cmult_asel);
33991 + r |= get_user(pge2d_config_ex->src2_cmult_asel,
33992 + &uf_ex_mem->_ge2d_config_ex.src2_cmult_asel);
33993 + r |= get_user(pge2d_config_ex->alu_const_color,
33994 + &uf_ex_mem->_ge2d_config_ex.alu_const_color);
33995 + r |= get_user(pge2d_config_ex->src1_gb_alpha_en,
33996 + &uf_ex_mem->_ge2d_config_ex.src1_gb_alpha_en);
33997 + r |= get_user(pge2d_config_ex->src1_gb_alpha,
33998 + &uf_ex_mem->_ge2d_config_ex.src1_gb_alpha);
34000 + r |= get_user(pge2d_config_ex->src2_gb_alpha_en,
34001 + &uf_ex_mem->_ge2d_config_ex.src2_gb_alpha_en);
34002 + r |= get_user(pge2d_config_ex->src2_gb_alpha,
34003 + &uf_ex_mem->_ge2d_config_ex.src2_gb_alpha);
34005 + r |= get_user(pge2d_config_ex->op_mode,
34006 + &uf_ex_mem->_ge2d_config_ex.op_mode);
34007 + r |= get_user(pge2d_config_ex->bitmask_en,
34008 + &uf_ex_mem->_ge2d_config_ex.bitmask_en);
34009 + r |= get_user(pge2d_config_ex->bytemask_only,
34010 + &uf_ex_mem->_ge2d_config_ex.bytemask_only);
34011 + r |= get_user(pge2d_config_ex->bitmask,
34012 + &uf_ex_mem->_ge2d_config_ex.bitmask);
34013 + r |= get_user(pge2d_config_ex->dst_xy_swap,
34014 + &uf_ex_mem->_ge2d_config_ex.dst_xy_swap);
34015 + r |= get_user(pge2d_config_ex->hf_init_phase,
34016 + &uf_ex_mem->_ge2d_config_ex.hf_init_phase);
34017 + r |= get_user(pge2d_config_ex->hf_rpt_num,
34018 + &uf_ex_mem->_ge2d_config_ex.hf_rpt_num);
34019 + r |= get_user(pge2d_config_ex->hsc_start_phase_step,
34020 + &uf_ex_mem->_ge2d_config_ex
34022 + r |= get_user(pge2d_config_ex->hsc_phase_slope,
34023 + &uf_ex_mem->_ge2d_config_ex.hsc_phase_slope);
34024 + r |= get_user(pge2d_config_ex->vf_init_phase,
34025 + &uf_ex_mem->_ge2d_config_ex.vf_init_phase);
34026 + r |= get_user(pge2d_config_ex->vf_rpt_num,
34027 + &uf_ex_mem->_ge2d_config_ex.vf_rpt_num);
34028 + r |= get_user(pge2d_config_ex->vsc_start_phase_step,
34029 + &uf_ex_mem->_ge2d_config_ex
34031 + r |= get_user(pge2d_config_ex->vsc_phase_slope,
34032 + &uf_ex_mem->_ge2d_config_ex.vsc_phase_slope);
34034 + pge2d_config_ex->src1_vsc_phase0_always_en,
34035 + &uf_ex_mem->_ge2d_config_ex
34038 + pge2d_config_ex->src1_hsc_phase0_always_en,
34039 + &uf_ex_mem->_ge2d_config_ex
34042 + pge2d_config_ex->src1_hsc_rpt_ctrl,
34043 + &uf_ex_mem->_ge2d_config_ex.src1_hsc_rpt_ctrl);
34045 + pge2d_config_ex->src1_vsc_rpt_ctrl,
34046 + &uf_ex_mem->_ge2d_config_ex.src1_vsc_rpt_ctrl);
34052 + &pge2d_config_ex->src_planes[i];
34053 + r |= get_user(psrc_planes->addr,
34054 + &uf_ex_mem->_ge2d_config_ex
34056 + r |= get_user(psrc_planes->w,
34057 + &uf_ex_mem->_ge2d_config_ex
34059 + r |= get_user(psrc_planes->h,
34060 + &uf_ex_mem->_ge2d_config_ex
34062 + r |= get_user(psrc_planes->shared_fd,
34063 + &uf_ex_mem->_ge2d_config_ex
34071 + &pge2d_config_ex->src2_planes[i];
34072 + r |= get_user(psrc2_planes->addr,
34073 + &uf_ex_mem->_ge2d_config_ex
34075 + r |= get_user(psrc2_planes->w,
34076 + &uf_ex_mem->_ge2d_config_ex
34078 + r |= get_user(psrc2_planes->h,
34079 + &uf_ex_mem->_ge2d_config_ex
34081 + r |= get_user(psrc2_planes->shared_fd,
34082 + &uf_ex_mem->_ge2d_config_ex
34090 + &pge2d_config_ex->dst_planes[j];
34091 + r |= get_user(pdst_planes->addr,
34092 + &uf_ex_mem->_ge2d_config_ex
34094 + r |= get_user(pdst_planes->w,
34095 + &uf_ex_mem->_ge2d_config_ex
34097 + r |= get_user(pdst_planes->h,
34098 + &uf_ex_mem->_ge2d_config_ex
34100 + r |= get_user(pdst_planes->shared_fd,
34101 + &uf_ex_mem->_ge2d_config_ex
34105 + r |= get_user(ge2d_config_ex_mem->src1_mem_alloc_type,
34106 + &uf_ex_mem->src1_mem_alloc_type);
34107 + r |= get_user(ge2d_config_ex_mem->src2_mem_alloc_type,
34108 + &uf_ex_mem->src2_mem_alloc_type);
34109 + r |= get_user(ge2d_config_ex_mem->dst_mem_alloc_type,
34110 + &uf_ex_mem->dst_mem_alloc_type);
34115 + return -EFAULT;
34145 + context = (struct ge2d_context_s *)filp->private_data;
34158 + return -EINVAL;
34174 + r = get_user(ge2d_config.src_dst_type, &uf->src_dst_type);
34176 + &uf->alu_const_color);
34177 + r |= get_user(ge2d_config.src_format, &uf->src_format);
34178 + r |= get_user(ge2d_config.dst_format, &uf->dst_format);
34181 + &uf->src_planes[i].addr);
34183 + &uf->src_planes[i].w);
34185 + &uf->src_planes[i].h);
34189 + &uf->dst_planes[j].addr);
34191 + &uf->dst_planes[j].w);
34193 + &uf->dst_planes[j].h);
34195 + r |= copy_from_user(&ge2d_config.src_key, &uf->src_key,
34199 + return -EFAULT;
34206 + r = get_user(ge2d_config.src_dst_type, &uf->src_dst_type);
34208 + &uf->alu_const_color);
34209 + r |= get_user(ge2d_config.src_format, &uf->src_format);
34210 + r |= get_user(ge2d_config.dst_format, &uf->dst_format);
34213 + &uf->src_planes[i].addr);
34215 + &uf->src_planes[i].w);
34217 + &uf->src_planes[i].h);
34221 + &uf->dst_planes[j].addr);
34223 + &uf->dst_planes[j].w);
34225 + &uf->dst_planes[j].h);
34227 + r |= copy_from_user(&ge2d_config.src_key, &uf->src_key,
34231 + return -EFAULT;
34243 + r = copy_from_user(&ge2d_config_ex.src_para, &uf_ex->src_para,
34246 + &uf_ex->src2_para,
34248 + r |= copy_from_user(&ge2d_config_ex.dst_para, &uf_ex->dst_para,
34251 + r |= copy_from_user(&ge2d_config_ex.src_key, &uf_ex->src_key,
34253 + r |= copy_from_user(&ge2d_config_ex.src2_key, &uf_ex->src2_key,
34257 + &uf_ex->alu_const_color);
34259 + &uf_ex->src1_gb_alpha);
34260 + r |= get_user(ge2d_config_ex.op_mode, &uf_ex->op_mode);
34261 + r |= get_user(ge2d_config_ex.bitmask_en, &uf_ex->bitmask_en);
34263 + &uf_ex->bytemask_only);
34264 + r |= get_user(ge2d_config_ex.bitmask, &uf_ex->bitmask);
34265 + r |= get_user(ge2d_config_ex.dst_xy_swap, &uf_ex->dst_xy_swap);
34267 + &uf_ex->hf_init_phase);
34268 + r |= get_user(ge2d_config_ex.hf_rpt_num, &uf_ex->hf_rpt_num);
34270 + &uf_ex->hsc_start_phase_step);
34272 + &uf_ex->hsc_phase_slope);
34274 + &uf_ex->vf_init_phase);
34275 + r |= get_user(ge2d_config_ex.vf_rpt_num, &uf_ex->vf_rpt_num);
34277 + &uf_ex->vsc_start_phase_step);
34279 + &uf_ex->vsc_phase_slope);
34281 + &uf_ex->src1_vsc_phase0_always_en);
34283 + &uf_ex->src1_hsc_phase0_always_en);
34285 + &uf_ex->src1_hsc_rpt_ctrl);
34287 + &uf_ex->src1_vsc_rpt_ctrl);
34291 + &uf_ex->src_planes[i].addr);
34293 + &uf_ex->src_planes[i].w);
34295 + &uf_ex->src_planes[i].h);
34300 + &uf_ex->src2_planes[i].addr);
34302 + &uf_ex->src2_planes[i].w);
34304 + &uf_ex->src2_planes[i].h);
34309 + &uf_ex->dst_planes[j].addr);
34311 + &uf_ex->dst_planes[j].w);
34313 + &uf_ex->dst_planes[j].h);
34318 + return -EFAULT;
34331 + &uf_ex_ion->src_para,
34335 + &uf_ex_ion->src2_para,
34339 + &uf_ex_ion->dst_para,
34343 + &uf_ex_ion->src_key,
34346 + &uf_ex_ion->src2_key,
34350 + &uf_ex_ion->src1_cmult_asel);
34352 + &uf_ex_ion->src2_cmult_asel);
34354 + &uf_ex_ion->alu_const_color);
34356 + &uf_ex_ion->src1_gb_alpha_en);
34358 + &uf_ex_ion->src1_gb_alpha);
34361 + &uf_ex_ion->src2_gb_alpha_en);
34363 + &uf_ex_ion->src2_gb_alpha);
34366 + &uf_ex_ion->op_mode);
34368 + &uf_ex_ion->bitmask_en);
34370 + &uf_ex_ion->bytemask_only);
34372 + &uf_ex_ion->bitmask);
34374 + &uf_ex_ion->dst_xy_swap);
34376 + &uf_ex_ion->hf_init_phase);
34378 + &uf_ex_ion->hf_rpt_num);
34380 + &uf_ex_ion->hsc_start_phase_step);
34382 + &uf_ex_ion->hsc_phase_slope);
34384 + &uf_ex_ion->vf_init_phase);
34386 + &uf_ex_ion->vf_rpt_num);
34388 + &uf_ex_ion->vsc_start_phase_step);
34390 + &uf_ex_ion->vsc_phase_slope);
34393 + &uf_ex_ion->src1_vsc_phase0_always_en);
34396 + &uf_ex_ion->src1_hsc_phase0_always_en);
34399 + &uf_ex_ion->src1_hsc_rpt_ctrl);
34402 + &uf_ex_ion->src1_vsc_rpt_ctrl);
34409 + r |= get_user(psrc_planes->addr,
34410 + &uf_ex_ion->src_planes[i].addr);
34411 + r |= get_user(psrc_planes->w,
34412 + &uf_ex_ion->src_planes[i].w);
34413 + r |= get_user(psrc_planes->h,
34414 + &uf_ex_ion->src_planes[i].h);
34415 + r |= get_user(psrc_planes->shared_fd,
34416 + &uf_ex_ion->src_planes[i].shared_fd);
34424 + r |= get_user(psrc2_planes->addr,
34425 + &uf_ex_ion->src2_planes[i].addr);
34426 + r |= get_user(psrc2_planes->w,
34427 + &uf_ex_ion->src2_planes[i].w);
34428 + r |= get_user(psrc2_planes->h,
34429 + &uf_ex_ion->src2_planes[i].h);
34430 + r |= get_user(psrc2_planes->shared_fd,
34431 + &uf_ex_ion->src2_planes[i].shared_fd);
34439 + r |= get_user(pdst_planes->addr,
34440 + &uf_ex_ion->dst_planes[j].addr);
34441 + r |= get_user(pdst_planes->w,
34442 + &uf_ex_ion->dst_planes[j].w);
34443 + r |= get_user(pdst_planes->h,
34444 + &uf_ex_ion->dst_planes[j].h);
34445 + r |= get_user(pdst_planes->shared_fd,
34446 + &uf_ex_ion->dst_planes[j].shared_fd);
34450 + return -EFAULT;
34462 + return -EINVAL;
34470 + return -EINVAL;
34478 + return -EINVAL;
34487 + return -EINVAL;
34494 + return -EINVAL;
34744 + context = (struct ge2d_context_s *)file->private_data;
34750 + return -1;
34867 + .compatible = "amlogic, ge2d-gxl",
34871 + .compatible = "amlogic, ge2d-gxm",
34875 + .compatible = "amlogic, ge2d-txl",
34879 + .compatible = "amlogic, ge2d-txlx",
34883 + .compatible = "amlogic, ge2d-axg",
34887 + .compatible = "amlogic, ge2d-g12a",
34891 + .compatible = "amlogic, ge2d-sm1",
34908 + if (pdev->dev.of_node) {
34911 + struct device_node *of_node = pdev->dev.of_node;
34915 + ge2d_meson = (struct ge2d_device_data_s *)match->data;
34921 + return -ENODEV;
34925 + return -ENODEV;
34930 + if (irq == -ENXIO) {
34932 + ret = -ENXIO;
34936 + clk_gate = devm_clk_get(&pdev->dev, "clk_ge2d_gate");
34940 + ret = -ENOENT;
34946 + clk = devm_clk_get(&pdev->dev, "clk_ge2d");
34950 + ret = -ENOENT;
34956 + clk_vapb0 = devm_clk_get(&pdev->dev, "clk_vapb_0");
34957 + if (PTR_ERR(clk_vapb0) != -ENOENT) {
34987 + ret = of_address_to_resource(pdev->dev.of_node, 0, &res);
35005 + ret = of_reserved_mem_device_init(&(pdev->dev));
35015 + ge2d_ion_client = meson_ion_client_create(-1, "meson-ge2d");
35063 + return -1;
35086 + return -ENODEV;
35101 diff -Naur a/vendor/amlogic/ge2d/ge2d_reg.h b/vendor/amlogic/ge2d/ge2d_reg.h
35102 --- a/vendor/amlogic/ge2d/ge2d_reg.h 1970-01-01 08:00:00.000000000 +0800
35103 +++ b/vendor/amlogic/ge2d/ge2d_reg.h 2022-06-24 14:37:49.791691734 +0800
35104 @@ -0,0 +1,104 @@
35209 diff -Naur a/vendor/amlogic/ge2d/ge2d_wq.c b/vendor/amlogic/ge2d/ge2d_wq.c
35210 --- a/vendor/amlogic/ge2d/ge2d_wq.c 1970-01-01 08:00:00.000000000 +0800
35211 +++ b/vendor/amlogic/ge2d/ge2d_wq.c 2022-06-24 14:37:49.831094403 +0800
35212 @@ -0,0 +1,2708 @@
35280 +static int ge2d_irq = -ENXIO;
35373 + return -1;
35390 + power_table = ge2d_meson_dev.poweron_table->power_table;
35391 + table_size = ge2d_meson_dev.poweron_table->table_size;
35394 + ge2d_meson_dev.poweroff_table->power_table;
35395 + table_size = ge2d_meson_dev.poweroff_table->table_size;
35438 + get_queue_member_count(&wq->work_queue));
35449 + get_queue_member_count(&wq->free_queue));
35454 + return list_empty(&queue->free_queue);
35460 + cfg->src1_x_start, cfg->src1_y_start);
35462 + cfg->src1_x_end, cfg->src1_y_end);
35464 + cfg->src1_x_rev, cfg->src1_y_rev);
35466 + cfg->src1_fill_color_en);
35469 + cfg->src2_x_start, cfg->src2_y_start);
35471 + cfg->src2_x_end, cfg->src2_y_end);
35473 + cfg->src2_x_rev, cfg->src2_y_rev);
35475 + cfg->src2_fill_color_en);
35478 + cfg->dst_x_start, cfg->dst_y_start);
35480 + cfg->dst_x_end, cfg->dst_y_end);
35482 + cfg->dst_x_rev, cfg->dst_y_rev);
35484 + cfg->dst_xy_swap);
35487 + cfg->color_blend_mode);
35489 + cfg->color_src_blend_factor);
35491 + cfg->color_dst_blend_factor);
35493 + cfg->color_logic_op);
35495 + cfg->alpha_blend_mode);
35497 + cfg->alpha_src_blend_factor);
35499 + cfg->alpha_dst_blend_factor);
35501 + cfg->alpha_logic_op);
35503 + ge2d_log_dbg("sc_prehsc_en=%d\n", cfg->sc_prehsc_en);
35504 + ge2d_log_dbg("sc_prevsc_en=%d\n", cfg->sc_prevsc_en);
35505 + ge2d_log_dbg("sc_hsc_en=%d\n", cfg->sc_hsc_en);
35506 + ge2d_log_dbg("sc_vsc_en=%d\n", cfg->sc_vsc_en);
35507 + ge2d_log_dbg("vsc_phase_step=%d\n", cfg->vsc_phase_step);
35508 + ge2d_log_dbg("vsc_phase_slope=%d\n", cfg->vsc_phase_slope);
35509 + ge2d_log_dbg("vsc_rpt_l0_num=%d\n", cfg->vsc_rpt_l0_num);
35510 + ge2d_log_dbg("vsc_ini_phase=%d\n", cfg->vsc_ini_phase);
35511 + ge2d_log_dbg("hsc_phase_step=%d\n", cfg->hsc_phase_step);
35512 + ge2d_log_dbg("hsc_phase_slope=%d\n", cfg->hsc_phase_slope);
35513 + ge2d_log_dbg("hsc_rpt_p0_num=%d\n", cfg->hsc_rpt_p0_num);
35514 + ge2d_log_dbg("hsc_ini_phase=%d\n", cfg->hsc_ini_phase);
35515 + ge2d_log_dbg("hsc_div_en=%d\n", cfg->hsc_div_en);
35516 + ge2d_log_dbg("hsc_div_length=%d\n", cfg->hsc_div_length);
35517 + ge2d_log_dbg("hsc_adv_num=%d\n", cfg->hsc_adv_num);
35518 + ge2d_log_dbg("hsc_adv_phase=%d\n", cfg->hsc_adv_phase);
35519 + ge2d_log_dbg("src1_cmult_asel=%d\n", cfg->src1_cmult_asel);
35520 + ge2d_log_dbg("src2_cmult_asel=%d\n", cfg->src2_cmult_asel);
35534 + if (cfg->src_canvas_cfg[i].canvas_used) {
35537 + cfg->src_canvas_cfg[i].phys_addr,
35538 + cfg->src_canvas_cfg[i].stride,
35539 + cfg->src_canvas_cfg[i].height,
35543 + cfg->src_canvas_cfg[i].canvas_used = 0;
35545 + cfg->src_canvas_cfg[i].phys_addr,
35546 + cfg->src_canvas_cfg[i].stride,
35547 + cfg->src_canvas_cfg[i].height);
35552 + cfg->src1_data.canaddr = index_src;
35557 + if (cfg->src2_canvas_cfg[i].canvas_used) {
35560 + cfg->src2_canvas_cfg[i].phys_addr,
35561 + cfg->src2_canvas_cfg[i].stride,
35562 + cfg->src2_canvas_cfg[i].height,
35566 + cfg->src2_canvas_cfg[i].canvas_used = 0;
35568 + cfg->src2_canvas_cfg[i].phys_addr,
35569 + cfg->src2_canvas_cfg[i].stride,
35570 + cfg->src2_canvas_cfg[i].height);
35575 + cfg->src2_dst_data.src2_canaddr = index_src2;
35581 + if (cfg->dst_canvas_cfg[i].canvas_used) {
35584 + cfg->dst_canvas_cfg[i].phys_addr,
35585 + cfg->dst_canvas_cfg[i].stride,
35586 + cfg->dst_canvas_cfg[i].height,
35590 + cfg->dst_canvas_cfg[i].canvas_used = 0;
35592 + cfg->dst_canvas_cfg[i].phys_addr,
35593 + cfg->dst_canvas_cfg[i].stride,
35594 + cfg->dst_canvas_cfg[i].height);
35599 + cfg->src2_dst_data.dst_canaddr = index_dst;
35610 + struct list_head *head = &wq->work_queue, *pos;
35614 + if (wq->ge2d_request_exit)
35617 + pos = head->next;
35623 + pitem->config.update_flag = UPDATE_ALL;
35626 + ret = -1;
35634 + ret = -1;
35639 + cfg = &pitem->config;
35642 + while (cfg->update_flag && mask <= UPDATE_SCALE_COEF) {
35644 + switch (cfg->update_flag & mask) {
35646 + ge2d_set_src1_data(&cfg->src1_data);
35649 + ge2d_set_src1_gen(&cfg->src1_gen);
35652 + ge2d_set_src2_dst_data(&cfg->src2_dst_data);
35655 + ge2d_set_src2_dst_gen(&cfg->src2_dst_gen);
35661 + ge2d_set_src1_scale_coef(cfg->v_scale_coef_type,
35662 + cfg->h_scale_coef_type);
35666 + cfg->update_flag &= ~mask;
35670 + pitem->cmd.hang_flag = 1;
35671 + ge2d_set_cmd(&pitem->cmd);/* set START_FLAG in this func. */
35673 + block_mode = pitem->cmd.wait_done_flag;
35674 + /* spin_lock(&wq->lock); */
35675 + /* pos=pos->next; */
35676 + /* list_move_tail(&pitem->list,&wq->free_queue); */
35677 + /* spin_unlock(&wq->lock); */
35686 + ge2d_dump_cmd(&pitem->cmd);
35693 + pitem->cmd.wait_done_flag = 0;
35694 + wake_up_interruptible(&wq->cmd_complete);
35696 + spin_lock(&wq->lock);
35697 + pos = pos->next;
35698 + list_move_tail(&pitem->list, &wq->free_queue);
35699 + spin_unlock(&wq->lock);
35702 + if (pitem->config.src_dma_cfg[i].dma_used) {
35704 + )pitem->config.src_dma_cfg[i].dma_cfg);
35705 + pitem->config.src_dma_cfg[i].dma_used = 0;
35706 + kfree(pitem->config.src_dma_cfg[i].dma_cfg);
35708 + if (pitem->config.src2_dma_cfg[i].dma_used) {
35710 + )pitem->config.src2_dma_cfg[i].dma_cfg);
35711 + pitem->config.src2_dma_cfg[i].dma_used = 0;
35712 + kfree(pitem->config.src2_dma_cfg[i].dma_cfg);
35714 + if (pitem->config.dst_dma_cfg[i].dma_used) {
35716 + )pitem->config.dst_dma_cfg[i].dma_cfg);
35717 + pitem->config.dst_dma_cfg[i].dma_used = 0;
35718 + kfree(pitem->config.dst_dma_cfg[i].dma_cfg);
35725 + if (wq->ge2d_request_exit)
35742 + canvas_cfg->canvas_used = 1;
35743 + canvas_cfg->phys_addr = phys_addr;
35744 + canvas_cfg->stride = stride;
35745 + canvas_cfg->height = height;
35756 + canvas_cfg = &wq->config.src_canvas_cfg[plane_id];
35759 + canvas_cfg = &wq->config.src2_canvas_cfg[plane_id];
35762 + canvas_cfg = &wq->config.dst_canvas_cfg[plane_id];
35779 + dma_cfg = &wq->config.src_dma_cfg[plane_id];
35782 + dma_cfg = &wq->config.src2_dma_cfg[plane_id];
35785 + dma_cfg = &wq->config.dst_dma_cfg[plane_id];
35797 + return &wq->config.src1_data;
35802 + return &wq->config.src1_gen;
35807 + return &wq->config.src2_dst_data;
35812 + return &wq->config.src2_dst_gen;
35817 + return &wq->config.dp_gen;
35822 + return &wq->cmd;
35831 + wq->config.v_scale_coef_type = v_scale_coef_type;
35832 + wq->config.h_scale_coef_type = h_scale_coef_type;
35833 + wq->config.update_flag |= UPDATE_SCALE_COEF;
35851 + return -1;
35854 + pitem = list_entry(wq->free_queue.next, struct ge2d_queue_item_s, list);
35857 + memcpy(&pitem->cmd, &wq->cmd, sizeof(struct ge2d_cmd_s));
35858 + memset(&wq->cmd, 0, sizeof(struct ge2d_cmd_s));
35859 + memcpy(&pitem->config, &wq->config, sizeof(struct ge2d_config_s));
35860 + wq->config.update_flag = 0; /* reset config set flag */
35861 + spin_lock(&wq->lock);
35862 + list_move_tail(&pitem->list, &wq->work_queue);
35863 + spin_unlock(&wq->lock);
35869 + if (pitem->cmd.wait_done_flag) {
35870 + wait_event_interruptible(wq->cmd_complete,
35871 + pitem->cmd.wait_done_flag == 0);
35872 + /* interruptible_sleep_on(&wq->cmd_complete); */
35876 + return -1;
35885 + list_for_each_entry(pcontext, &manager->process_queue, list) {
35887 + if (!list_empty(&pcontext->work_queue)) {
35889 + list_move(&manager->process_queue, &pcontext->list);
35906 + ret = down_interruptible(&manager->event.cmd_in_sem);
35908 + while ((manager->current_wq =
35910 + ge2d_process_work_queue(manager->current_wq);
35973 + src->xres = cfg->src_planes[0].w;
35974 + src->yres = cfg->src_planes[0].h;
35975 + src->ge2d_color_index = cfg->src_format;
35976 + src->bpp = bpp(cfg->src_format);
35978 + if (cfg->src_planes[0].addr) {
35981 + src->canvas_index = 0;
35982 + src->phy_addr =
35983 + cfg->src_planes[0].addr;
35984 + src->stride =
35985 + cfg->src_planes[0].w *
35986 + src->bpp / 8;
35991 + src->canvas_index = 0;
35995 + return -1;
35997 + cfg->src_planes[i].addr,
35998 + cfg->src_planes[i].w *
35999 + src->bpp / 8,
36000 + cfg->src_planes[i].h);
36006 + dst->xres = cfg->dst_planes[0].w;
36007 + dst->yres = cfg->dst_planes[0].h;
36008 + dst->ge2d_color_index = cfg->dst_format;
36009 + dst->bpp = bpp(cfg->dst_format);
36011 + if (cfg->dst_planes[i].addr) {
36014 + dst->canvas_index = 0;
36015 + dst->phy_addr =
36016 + cfg->dst_planes[0].addr;
36017 + dst->stride =
36018 + cfg->dst_planes[0].w *
36019 + dst->bpp / 8;
36024 + dst->canvas_index = 0;
36028 + return -1;
36030 + cfg->dst_planes[i].addr,
36031 + cfg->dst_planes[i].w *
36032 + dst->bpp / 8,
36033 + cfg->dst_planes[i].h);
36054 + src_dst->canvas_index = index;
36070 + src_dst->canvas_index = (data32 >> 16) & 0xff;
36072 + src_dst->canvas_index = 0;
36075 + src_dst->phy_addr = cs_addr;
36076 + src_dst->stride = cs_width;
36080 + canvas_read(src_dst->canvas_index, &canvas);
36093 + return -1;
36095 + src_dst->bpp = bpp;
36096 + src_dst->xres = cs_width / (bpp >> 3);
36097 + src_dst->yres = cs_height;
36099 + src_dst->ge2d_color_index = GE2D_FORMAT_S16_YUV422;
36102 + index = bpp - 16 + ((data32 >> 2) & 0xf);
36105 + src_dst->ge2d_color_index = default_ge2d_color_lut[index];
36107 + if (src_dst->xres <= 0 ||
36108 + src_dst->yres <= 0 ||
36109 + src_dst->ge2d_color_index == 0)
36110 + return -2;
36139 + int type = ge2d_config->src_dst_type;
36151 + return -1;
36162 + return -1;
36216 + ge2dgen_const_color(context, ge2d_config->alu_const_color);
36234 + int ret = -1;
36246 + /* not support multi-src_planes */
36251 + ret = -1;
36264 + int ret = -1;
36290 + /* not support multi-src_planes */
36295 + ret = -1;
36311 + int ret = -1;
36325 + return -1;
36326 + cfg->dma_used = 1;
36328 + dma_cfg->fd = plane[0].shared_fd;
36329 + dma_cfg->dev = &(ge2d_manager.pdev->dev);
36330 + dma_cfg->dir = dir;
36331 + cfg->dma_cfg = dma_cfg;
36342 + /* not support multi-src_planes */
36347 + ret = -1;
36360 + int ret = -1, i = 0;
36369 + return -1;
36389 + int ret = -1, i;
36397 + /* multi-src_planes */
36418 + return -1;
36439 + int ret = -1, i;
36446 + /* multi-src_planes */
36455 + return -1;
36456 + cfg->dma_used = 1;
36460 + dma_cfg->fd = plane[i].shared_fd;
36461 + dma_cfg->dev = &(ge2d_manager.pdev->dev);
36462 + dma_cfg->dir = dir;
36463 + cfg->dma_cfg = dma_cfg;
36477 + return -1;
36503 + switch (ge2d_config->src_para.mem_type) {
36507 + (ge2d_config->src_para.mem_type == CANVAS_OSD0) ?
36509 + return -1;
36510 + ge2d_config->src_para.canvas_index = tmp.canvas_index;
36511 + ge2d_config->src_para.format = tmp.ge2d_color_index;
36514 + ge2d_log_dbg("ge2d: src1-->type: osd%d, format: 0x%x !!\n",
36515 + ge2d_config->src_para.mem_type - CANVAS_OSD0,
36516 + ge2d_config->src_para.format);
36518 + top = ge2d_config->src_para.top;
36519 + left = ge2d_config->src_para.left;
36520 + width = ge2d_config->src_para.width;
36521 + height = ge2d_config->src_para.height;
36525 + return -1;
36527 + ge2d_config->src_para.width = tmp.xres;
36528 + ge2d_config->src_para.height = tmp.yres;
36532 + ge2d_config->src_para.format);
36535 + top = ge2d_config->src_para.top;
36536 + left = ge2d_config->src_para.left;
36537 + width = ge2d_config->src_para.width;
36538 + height = ge2d_config->src_para.height;
36539 + if ((left + width > ge2d_config->src_planes[0].w)
36540 + || (top + height > ge2d_config->src_planes[0].h)) {
36542 + return -1;
36546 + &ge2d_config->src_planes[0],
36547 + ge2d_config->src_para.format,
36550 + return -1;
36554 + ge2d_config->src_para.format);
36557 + &ge2d_config->src_planes[0],
36558 + ge2d_config->src_para.format,
36560 + return -1;
36561 + ge2d_config->src_para.canvas_index = 0;
36563 + ge2d_config->src_para.format);
36570 + switch (ge2d_config->src2_para.mem_type) {
36574 + (ge2d_config->src2_para.mem_type == CANVAS_OSD0) ?
36576 + return -1;
36577 + ge2d_config->src2_para.canvas_index = tmp.canvas_index;
36578 + ge2d_config->src2_para.format = tmp.ge2d_color_index;
36581 + ge2d_log_dbg("ge2d: src2-->type: osd%d, format: 0x%x !!\n",
36582 + ge2d_config->src2_para.mem_type - CANVAS_OSD0,
36583 + ge2d_config->src2_para.format);
36585 + top = ge2d_config->src2_para.top;
36586 + left = ge2d_config->src2_para.left;
36587 + width = ge2d_config->src2_para.width;
36588 + height = ge2d_config->src2_para.height;
36591 + ge2d_config->src2_para.mem_type - CANVAS_OSD0);
36592 + return -1;
36594 + ge2d_config->src2_para.width = tmp.xres;
36595 + ge2d_config->src2_para.height = tmp.yres;
36599 + ge2d_config->src2_para.format);
36602 + top = ge2d_config->src2_para.top;
36603 + left = ge2d_config->src2_para.left;
36604 + width = ge2d_config->src2_para.width;
36605 + height = ge2d_config->src2_para.height;
36606 + if ((left + width > ge2d_config->src2_planes[0].w)
36607 + || (top + height > ge2d_config->src2_planes[0].h)) {
36609 + return -1;
36611 + if (ge2d_config->src2_planes[0].addr ==
36612 + ge2d_config->src_planes[0].addr) {
36613 + ge2d_config->src2_para.canvas_index =
36614 + ge2d_config->src_para.canvas_index;
36620 + &ge2d_config->src2_planes[0],
36621 + ge2d_config->src2_para.format,
36624 + return -1;
36628 + ge2d_config->src2_para.format);
36631 + &ge2d_config->src2_planes[0],
36632 + ge2d_config->src2_para.format,
36634 + return -1;
36635 + ge2d_config->src2_para.canvas_index = 0;
36637 + ge2d_config->src2_para.format);
36645 + switch (ge2d_config->dst_para.mem_type) {
36649 + (ge2d_config->dst_para.mem_type == CANVAS_OSD0) ?
36651 + return -1;
36652 + ge2d_config->dst_para.canvas_index = tmp.canvas_index;
36653 + ge2d_config->dst_para.format = tmp.ge2d_color_index;
36657 + ge2d_log_dbg("ge2d: dst-->type: osd%d, format: 0x%x !!\n",
36658 + ge2d_config->dst_para.mem_type - CANVAS_OSD0,
36659 + ge2d_config->dst_para.format);
36661 + top = ge2d_config->dst_para.top;
36662 + left = ge2d_config->dst_para.left;
36663 + width = ge2d_config->dst_para.width;
36664 + height = ge2d_config->dst_para.height;
36667 + ge2d_config->dst_para.mem_type - CANVAS_OSD0);
36668 + return -1;
36670 + ge2d_config->dst_para.width = tmp.xres;
36671 + ge2d_config->dst_para.height = tmp.yres;
36675 + ge2d_config->dst_para.format);
36678 + top = ge2d_config->dst_para.top;
36679 + left = ge2d_config->dst_para.left;
36680 + width = ge2d_config->dst_para.width;
36681 + height = ge2d_config->dst_para.height;
36682 + if ((left + width > ge2d_config->dst_planes[0].w)
36683 + || (top + height > ge2d_config->dst_planes[0].h)) {
36685 + return -1;
36687 + if (ge2d_config->dst_planes[0].addr ==
36688 + ge2d_config->src_planes[0].addr) {
36689 + ge2d_config->dst_para.canvas_index =
36690 + ge2d_config->src_para.canvas_index;
36694 + else if (ge2d_config->dst_planes[0].addr ==
36695 + ge2d_config->src2_planes[0].addr) {
36696 + ge2d_config->dst_para.canvas_index =
36697 + ge2d_config->src2_para.canvas_index;
36703 + &ge2d_config->dst_planes[0],
36704 + ge2d_config->dst_para.format,
36707 + return -1;
36711 + ge2d_config->dst_para.format);
36714 + &ge2d_config->dst_planes[0],
36715 + ge2d_config->dst_para.format,
36717 + return -1;
36718 + ge2d_config->dst_para.canvas_index = 0;
36720 + ge2d_config->dst_para.format);
36728 + ge2dgen_rendering_dir(context, ge2d_config->src_para.x_rev,
36729 + ge2d_config->src_para.y_rev,
36730 + ge2d_config->dst_para.x_rev,
36731 + ge2d_config->dst_para.y_rev,
36732 + ge2d_config->dst_xy_swap);
36733 + ge2dgen_const_color(context, ge2d_config->alu_const_color);
36735 + ge2dgen_src(context, ge2d_config->src_para.canvas_index,
36736 + ge2d_config->src_para.format,
36739 + ge2dgen_src_clip(context, ge2d_config->src_para.left,
36740 + ge2d_config->src_para.top,
36741 + ge2d_config->src_para.width,
36742 + ge2d_config->src_para.height);
36743 + ge2dgen_src_key(context, ge2d_config->src_key.key_enable,
36744 + ge2d_config->src_key.key_color,
36745 + ge2d_config->src_key.key_mask,
36746 + ge2d_config->src_key.key_mode);
36748 + ge2dgent_src_gbalpha(context, ge2d_config->src1_gb_alpha,
36749 + ge2d_config->src2_gb_alpha);
36751 + ge2dgent_src_gbalpha(context, ge2d_config->src1_gb_alpha, 0);
36753 + ge2dgen_src_color(context, ge2d_config->src_para.color);
36755 + ge2dgen_src2(context, ge2d_config->src2_para.canvas_index,
36756 + ge2d_config->src2_para.format,
36759 + ge2dgen_src2_clip(context, ge2d_config->src2_para.left,
36760 + ge2d_config->src2_para.top,
36761 + ge2d_config->src2_para.width,
36762 + ge2d_config->src2_para.height);
36764 + ge2dgen_dst(context, ge2d_config->dst_para.canvas_index,
36765 + ge2d_config->dst_para.format,
36768 + ge2dgen_dst_clip(context, ge2d_config->dst_para.left,
36769 + ge2d_config->dst_para.top,
36770 + ge2d_config->dst_para.width,
36771 + ge2d_config->dst_para.height,
36775 + src1_gen_cfg->fill_mode = ge2d_config->src_para.fill_mode;
36776 + src1_gen_cfg->chfmt_rpt_pix = 0;
36777 + src1_gen_cfg->cvfmt_rpt_pix = 0;
36778 + /* src1_gen_cfg->clipx_start_ex = 0; */
36779 + /* src1_gen_cfg->clipx_end_ex = 1; */
36780 + /* src1_gen_cfg->clipy_start_ex = 1; */
36781 + /* src1_gen_cfg->clipy_end_ex = 1; */
36784 + src2_dst_data_cfg->src2_def_color = ge2d_config->src2_para.color;
36787 + src2_dst_gen_cfg->src2_fill_mode = ge2d_config->src2_para.fill_mode;
36791 + dp_gen_cfg->src1_vsc_phase0_always_en =
36792 + ge2d_config->src1_hsc_phase0_always_en;
36793 + dp_gen_cfg->src1_hsc_phase0_always_en =
36794 + ge2d_config->src1_vsc_phase0_always_en;
36795 + if ((context->config.v_scale_coef_type == FILTER_TYPE_GAU0) ||
36796 + (context->config.v_scale_coef_type == FILTER_TYPE_GAU0_BOT) ||
36797 + (context->config.v_scale_coef_type == FILTER_TYPE_GAU1) ||
36798 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU0) ||
36799 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU0_BOT) ||
36800 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU1)) {
36802 + dp_gen_cfg->src1_hsc_rpt_ctrl = ge2d_config->src1_hsc_rpt_ctrl;
36804 + dp_gen_cfg->src1_vsc_rpt_ctrl = ge2d_config->src1_vsc_rpt_ctrl;
36807 + dp_gen_cfg->src1_hsc_rpt_ctrl = 1;
36809 + dp_gen_cfg->src1_vsc_rpt_ctrl = 1;
36811 + dp_gen_cfg->src1_gb_alpha = 0xff;
36812 + dp_gen_cfg->src1_gb_alpha_en = 0;
36814 + dp_gen_cfg->src2_gb_alpha = 0xff;
36815 + dp_gen_cfg->src2_gb_alpha_en = 0;
36817 + dp_gen_cfg->src2_key_en = ge2d_config->src2_key.key_enable;
36818 + dp_gen_cfg->src2_key_mode = ge2d_config->src2_key.key_mode;
36819 + dp_gen_cfg->src2_key = ge2d_config->src2_key.key_color;
36820 + dp_gen_cfg->src2_key_mask = ge2d_config->src2_key.key_mask;
36822 + dp_gen_cfg->bitmask_en = ge2d_config->bitmask_en;
36823 + dp_gen_cfg->bitmask = ge2d_config->bitmask;
36824 + dp_gen_cfg->bytemask_only = ge2d_config->bytemask_only;
36828 + ge2d_cmd_cfg->src1_fill_color_en = ge2d_config->src_para.fill_color_en;
36830 + ge2d_cmd_cfg->src2_x_rev = ge2d_config->src2_para.x_rev;
36831 + ge2d_cmd_cfg->src2_y_rev = ge2d_config->src2_para.y_rev;
36832 + ge2d_cmd_cfg->src2_fill_color_en =
36833 + ge2d_config->src2_para.fill_color_en;
36835 + ge2d_cmd_cfg->vsc_phase_slope = ge2d_config->vsc_phase_slope;
36836 + ge2d_cmd_cfg->vsc_ini_phase = ge2d_config->vf_init_phase;
36837 + ge2d_cmd_cfg->vsc_phase_step = ge2d_config->vsc_start_phase_step;
36838 + ge2d_cmd_cfg->vsc_rpt_l0_num = ge2d_config->vf_rpt_num;
36841 + ge2d_cmd_cfg->hsc_phase_slope = ge2d_config->hsc_phase_slope;
36842 + ge2d_cmd_cfg->hsc_ini_phase = ge2d_config->hf_init_phase;
36843 + ge2d_cmd_cfg->hsc_phase_step = ge2d_config->hsc_start_phase_step;
36844 + ge2d_cmd_cfg->hsc_rpt_p0_num = ge2d_config->hf_rpt_num;
36846 + ge2d_cmd_cfg->src1_cmult_asel = 0;
36847 + ge2d_cmd_cfg->src2_cmult_asel = 0;
36848 + context->config.update_flag = UPDATE_ALL;
36849 + /* context->config.src1_data.ddr_burst_size_y = 3; */
36850 + /* context->config.src1_data.ddr_burst_size_cb = 3; */
36851 + /* context->config.src1_data.ddr_burst_size_cr = 3; */
36852 + /* context->config.src2_dst_data.ddr_burst_size= 3; */
36872 + switch (ge2d_config->src_para.mem_type) {
36876 + (ge2d_config->src_para.mem_type == CANVAS_OSD0) ?
36878 + return -1;
36879 + ge2d_config->src_para.canvas_index = tmp.canvas_index;
36880 + ge2d_config->src_para.format = tmp.ge2d_color_index;
36884 + ge2d_log_dbg("ge2d: src1-->type: osd%d, format: 0x%x !!\n",
36885 + ge2d_config->src_para.mem_type - CANVAS_OSD0,
36886 + ge2d_config->src_para.format);
36888 + top = ge2d_config->src_para.top;
36889 + left = ge2d_config->src_para.left;
36890 + width = ge2d_config->src_para.width;
36891 + height = ge2d_config->src_para.height;
36895 + return -1;
36897 + ge2d_config->src_para.width = tmp.xres;
36898 + ge2d_config->src_para.height = tmp.yres;
36902 + ge2d_config->src_para.format);
36905 + top = ge2d_config->src_para.top;
36906 + left = ge2d_config->src_para.left;
36907 + width = ge2d_config->src_para.width;
36908 + height = ge2d_config->src_para.height;
36909 + if ((left + width > ge2d_config->src_planes[0].w)
36910 + || (top + height > ge2d_config->src_planes[0].h)) {
36912 + return -1;
36916 + &ge2d_config->src_planes[0],
36917 + ge2d_config->src_para.format,
36920 + return -1;
36924 + ge2d_config->src_para.format);
36929 + &ge2d_config->src_planes[0],
36930 + ge2d_config->src_para.format,
36932 + return -1;
36933 + ge2d_config->src_para.canvas_index = 0;
36935 + ge2d_config->src_para.format);
36942 + switch (ge2d_config->src2_para.mem_type) {
36946 + (ge2d_config->src2_para.mem_type == CANVAS_OSD0) ?
36948 + return -1;
36949 + ge2d_config->src2_para.canvas_index = tmp.canvas_index;
36950 + ge2d_config->src2_para.format = tmp.ge2d_color_index;
36954 + ge2d_log_dbg("ge2d: src2-->type: osd%d, format: 0x%x !!\n",
36955 + ge2d_config->src2_para.mem_type - CANVAS_OSD0,
36956 + ge2d_config->src2_para.format);
36958 + top = ge2d_config->src2_para.top;
36959 + left = ge2d_config->src2_para.left;
36960 + width = ge2d_config->src2_para.width;
36961 + height = ge2d_config->src2_para.height;
36964 + ge2d_config->src2_para.mem_type - CANVAS_OSD0);
36965 + return -1;
36967 + ge2d_config->src2_para.width = tmp.xres;
36968 + ge2d_config->src2_para.height = tmp.yres;
36972 + ge2d_config->src2_para.format);
36975 + top = ge2d_config->src2_para.top;
36976 + left = ge2d_config->src2_para.left;
36977 + width = ge2d_config->src2_para.width;
36978 + height = ge2d_config->src2_para.height;
36979 + if ((left + width > ge2d_config->src2_planes[0].w)
36980 + || (top + height > ge2d_config->src2_planes[0].h)) {
36982 + return -1;
36984 + /*if (ge2d_config->src2_planes[0].addr ==
36985 + * ge2d_config->src_planes[0].addr)
36986 + * index = ge2d_config->src_para.canvas_index;
36991 + &ge2d_config->src2_planes[0],
36992 + ge2d_config->src2_para.format,
36995 + return -1;
36999 + ge2d_config->src2_para.format);
37003 + &ge2d_config->src2_planes[0],
37004 + ge2d_config->src2_para.format,
37006 + return -1;
37007 + ge2d_config->src2_para.canvas_index = 0;
37009 + ge2d_config->src2_para.format);
37016 + switch (ge2d_config->dst_para.mem_type) {
37020 + (ge2d_config->dst_para.mem_type == CANVAS_OSD0) ?
37022 + return -1;
37023 + ge2d_config->dst_para.canvas_index = tmp.canvas_index;
37024 + ge2d_config->dst_para.format = tmp.ge2d_color_index;
37028 + ge2d_log_dbg("ge2d: dst-->type: osd%d, format: 0x%x !!\n",
37029 + ge2d_config->dst_para.mem_type - CANVAS_OSD0,
37030 + ge2d_config->dst_para.format);
37032 + top = ge2d_config->dst_para.top;
37033 + left = ge2d_config->dst_para.left;
37034 + width = ge2d_config->dst_para.width;
37035 + height = ge2d_config->dst_para.height;
37038 + ge2d_config->dst_para.mem_type - CANVAS_OSD0);
37039 + return -1;
37041 + ge2d_config->dst_para.width = tmp.xres;
37042 + ge2d_config->dst_para.height = tmp.yres;
37046 + ge2d_config->dst_para.format);
37049 + top = ge2d_config->dst_para.top;
37050 + left = ge2d_config->dst_para.left;
37051 + width = ge2d_config->dst_para.width;
37052 + height = ge2d_config->dst_para.height;
37053 + if ((left + width > ge2d_config->dst_planes[0].w)
37054 + || (top + height > ge2d_config->dst_planes[0].h)) {
37056 + return -1;
37058 + /*if (ge2d_config->dst_planes[0].addr ==
37059 + * ge2d_config->src_planes[0].addr)
37060 + * index = ge2d_config->src_para.canvas_index;
37061 + * else if (ge2d_config->dst_planes[0].addr ==
37062 + * ge2d_config->src2_planes[0].addr)
37063 + * index = ge2d_config->src2_para.canvas_index;
37068 + &ge2d_config->dst_planes[0],
37069 + ge2d_config->dst_para.format,
37072 + return -1;
37076 + ge2d_config->dst_para.format);
37080 + &ge2d_config->dst_planes[0],
37081 + ge2d_config->dst_para.format,
37083 + return -1;
37084 + ge2d_config->dst_para.canvas_index = 0;
37086 + ge2d_config->dst_para.format);
37093 + ge2dgen_rendering_dir(context, ge2d_config->src_para.x_rev,
37094 + ge2d_config->src_para.y_rev,
37095 + ge2d_config->dst_para.x_rev,
37096 + ge2d_config->dst_para.y_rev,
37097 + ge2d_config->dst_xy_swap);
37098 + ge2dgen_const_color(context, ge2d_config->alu_const_color);
37100 + ge2dgen_src(context, ge2d_config->src_para.canvas_index,
37101 + ge2d_config->src_para.format,
37104 + ge2dgen_src_clip(context, ge2d_config->src_para.left,
37105 + ge2d_config->src_para.top,
37106 + ge2d_config->src_para.width,
37107 + ge2d_config->src_para.height);
37108 + ge2dgen_src_key(context, ge2d_config->src_key.key_enable,
37109 + ge2d_config->src_key.key_color,
37110 + ge2d_config->src_key.key_mask,
37111 + ge2d_config->src_key.key_mode);
37113 + ge2dgent_src_gbalpha(context, ge2d_config->src1_gb_alpha,
37114 + ge2d_config->src2_gb_alpha);
37116 + ge2dgent_src_gbalpha(context, ge2d_config->src1_gb_alpha, 0);
37118 + ge2dgen_src_color(context, ge2d_config->src_para.color);
37120 + ge2dgen_src2(context, ge2d_config->src2_para.canvas_index,
37121 + ge2d_config->src2_para.format,
37124 + ge2dgen_src2_clip(context, ge2d_config->src2_para.left,
37125 + ge2d_config->src2_para.top,
37126 + ge2d_config->src2_para.width,
37127 + ge2d_config->src2_para.height);
37129 + ge2dgen_dst(context, ge2d_config->dst_para.canvas_index,
37130 + ge2d_config->dst_para.format,
37133 + ge2dgen_dst_clip(context, ge2d_config->dst_para.left,
37134 + ge2d_config->dst_para.top,
37135 + ge2d_config->dst_para.width,
37136 + ge2d_config->dst_para.height,
37140 + src1_gen_cfg->fill_mode = ge2d_config->src_para.fill_mode;
37141 + src1_gen_cfg->chfmt_rpt_pix = 0;
37142 + src1_gen_cfg->cvfmt_rpt_pix = 0;
37143 + /* src1_gen_cfg->clipx_start_ex = 0; */
37144 + /* src1_gen_cfg->clipx_end_ex = 1; */
37145 + /* src1_gen_cfg->clipy_start_ex = 1; */
37146 + /* src1_gen_cfg->clipy_end_ex = 1; */
37149 + src2_dst_data_cfg->src2_def_color = ge2d_config->src2_para.color;
37152 + src2_dst_gen_cfg->src2_fill_mode = ge2d_config->src2_para.fill_mode;
37156 + dp_gen_cfg->src1_vsc_phase0_always_en =
37157 + ge2d_config->src1_hsc_phase0_always_en;
37158 + dp_gen_cfg->src1_hsc_phase0_always_en =
37159 + ge2d_config->src1_vsc_phase0_always_en;
37160 + if ((context->config.v_scale_coef_type == FILTER_TYPE_GAU0) ||
37161 + (context->config.v_scale_coef_type == FILTER_TYPE_GAU0_BOT) ||
37162 + (context->config.v_scale_coef_type == FILTER_TYPE_GAU1) ||
37163 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU0) ||
37164 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU0_BOT) ||
37165 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU1)) {
37167 + dp_gen_cfg->src1_hsc_rpt_ctrl = ge2d_config->src1_hsc_rpt_ctrl;
37169 + dp_gen_cfg->src1_vsc_rpt_ctrl = ge2d_config->src1_vsc_rpt_ctrl;
37172 + dp_gen_cfg->src1_hsc_rpt_ctrl = 1;
37174 + dp_gen_cfg->src1_vsc_rpt_ctrl = 1;
37176 + dp_gen_cfg->src1_gb_alpha = ge2d_config->src1_gb_alpha & 0xff;
37177 + dp_gen_cfg->src1_gb_alpha_en = ge2d_config->src1_gb_alpha_en & 1;
37179 + dp_gen_cfg->src2_gb_alpha = ge2d_config->src2_gb_alpha & 0xff;
37180 + dp_gen_cfg->src2_gb_alpha_en = ge2d_config->src2_gb_alpha_en & 1;
37182 + dp_gen_cfg->src2_key_en = ge2d_config->src2_key.key_enable;
37183 + dp_gen_cfg->src2_key_mode = ge2d_config->src2_key.key_mode;
37184 + dp_gen_cfg->src2_key = ge2d_config->src2_key.key_color;
37185 + dp_gen_cfg->src2_key_mask = ge2d_config->src2_key.key_mask;
37187 + dp_gen_cfg->bitmask_en = ge2d_config->bitmask_en;
37188 + dp_gen_cfg->bitmask = ge2d_config->bitmask;
37189 + dp_gen_cfg->bytemask_only = ge2d_config->bytemask_only;
37193 + ge2d_cmd_cfg->src1_fill_color_en = ge2d_config->src_para.fill_color_en;
37195 + ge2d_cmd_cfg->src2_x_rev = ge2d_config->src2_para.x_rev;
37196 + ge2d_cmd_cfg->src2_y_rev = ge2d_config->src2_para.y_rev;
37197 + ge2d_cmd_cfg->src2_fill_color_en =
37198 + ge2d_config->src2_para.fill_color_en;
37200 + ge2d_cmd_cfg->src2_cmult_ad = ge2d_config->src2_cmult_ad;
37203 + ge2d_cmd_cfg->vsc_phase_slope = ge2d_config->vsc_phase_slope;
37204 + ge2d_cmd_cfg->vsc_ini_phase = ge2d_config->vf_init_phase;
37205 + ge2d_cmd_cfg->vsc_phase_step = ge2d_config->vsc_start_phase_step;
37206 + ge2d_cmd_cfg->vsc_rpt_l0_num = ge2d_config->vf_rpt_num;
37209 + ge2d_cmd_cfg->hsc_phase_slope = ge2d_config->hsc_phase_slope;
37210 + ge2d_cmd_cfg->hsc_ini_phase = ge2d_config->hf_init_phase;
37211 + ge2d_cmd_cfg->hsc_phase_step = ge2d_config->hsc_start_phase_step;
37212 + ge2d_cmd_cfg->hsc_rpt_p0_num = ge2d_config->hf_rpt_num;
37213 + ge2d_cmd_cfg->src1_cmult_asel = ge2d_config->src1_cmult_asel;
37214 + ge2d_cmd_cfg->src2_cmult_asel = ge2d_config->src2_cmult_asel;
37216 + ge2d_cmd_cfg->src1_fmt = ge2d_config->src_para.format;
37217 + ge2d_cmd_cfg->src2_fmt = ge2d_config->src2_para.format;
37218 + ge2d_cmd_cfg->dst_fmt = ge2d_config->dst_para.format;
37220 + context->config.update_flag = UPDATE_ALL;
37221 + /* context->config.src1_data.ddr_burst_size_y = 3; */
37222 + /* context->config.src1_data.ddr_burst_size_cb = 3; */
37223 + /* context->config.src1_data.ddr_burst_size_cr = 3; */
37224 + /* context->config.src2_dst_data.ddr_burst_size= 3; */
37243 + ge2d_config = &(ge2d_config_mem->_ge2d_config_ex);
37246 + context->config.src_dma_cfg[i].dma_used = 0;
37247 + context->config.src2_dma_cfg[i].dma_used = 0;
37248 + context->config.dst_dma_cfg[i].dma_used = 0;
37251 + switch (ge2d_config->src_para.mem_type) {
37255 + (ge2d_config->src_para.mem_type == CANVAS_OSD0) ?
37257 + return -1;
37258 + ge2d_config->src_para.canvas_index = tmp.canvas_index;
37259 + ge2d_config->src_para.format = tmp.ge2d_color_index;
37263 + ge2d_log_dbg("ge2d: src1-->type: osd%d, format: 0x%x !!\n",
37264 + ge2d_config->src_para.mem_type - CANVAS_OSD0,
37265 + ge2d_config->src_para.format);
37267 + top = ge2d_config->src_para.top;
37268 + left = ge2d_config->src_para.left;
37269 + width = ge2d_config->src_para.width;
37270 + height = ge2d_config->src_para.height;
37274 + return -1;
37276 + ge2d_config->src_para.width = tmp.xres;
37277 + ge2d_config->src_para.height = tmp.yres;
37281 + ge2d_config->src_para.format);
37284 + top = ge2d_config->src_para.top;
37285 + left = ge2d_config->src_para.left;
37286 + width = ge2d_config->src_para.width;
37287 + height = ge2d_config->src_para.height;
37288 + if ((left + width > ge2d_config->src_planes[0].w)
37289 + || (top + height > ge2d_config->src_planes[0].h)) {
37291 + return -1;
37294 + if (ge2d_config_mem->src1_mem_alloc_type ==
37297 + &ge2d_config->src_planes[0],
37298 + ge2d_config->src_para.format,
37301 + return -1;
37305 + ge2d_config->src_para.format);
37306 + } else if (ge2d_config_mem->src1_mem_alloc_type ==
37310 + &ge2d_config->src_planes[0],
37311 + ge2d_config->src_para.format,
37316 + return -1;
37320 + ge2d_config->src_para.format);
37323 + if (ge2d_config_mem->src1_mem_alloc_type ==
37327 + &ge2d_config->src_planes[0],
37328 + ge2d_config->src_para.format,
37330 + return -1;
37331 + ge2d_config->src_para.canvas_index = 0;
37333 + ge2d_config->src_para.format);
37334 + } else if (ge2d_config_mem->src1_mem_alloc_type ==
37338 + &ge2d_config->src_planes[0],
37339 + ge2d_config->src_para.format,
37342 + return -1;
37343 + ge2d_config->src_para.canvas_index = 0;
37345 + ge2d_config->src_para.format);
37353 + switch (ge2d_config->src2_para.mem_type) {
37357 + (ge2d_config->src2_para.mem_type == CANVAS_OSD0) ?
37359 + return -1;
37360 + ge2d_config->src2_para.canvas_index = tmp.canvas_index;
37361 + ge2d_config->src2_para.format = tmp.ge2d_color_index;
37365 + ge2d_log_dbg("ge2d: src2-->type: osd%d, format: 0x%x !!\n",
37366 + ge2d_config->src2_para.mem_type - CANVAS_OSD0,
37367 + ge2d_config->src2_para.format);
37369 + top = ge2d_config->src2_para.top;
37370 + left = ge2d_config->src2_para.left;
37371 + width = ge2d_config->src2_para.width;
37372 + height = ge2d_config->src2_para.height;
37375 + ge2d_config->src2_para.mem_type - CANVAS_OSD0);
37376 + return -1;
37378 + ge2d_config->src2_para.width = tmp.xres;
37379 + ge2d_config->src2_para.height = tmp.yres;
37383 + ge2d_config->src2_para.format);
37386 + top = ge2d_config->src2_para.top;
37387 + left = ge2d_config->src2_para.left;
37388 + width = ge2d_config->src2_para.width;
37389 + height = ge2d_config->src2_para.height;
37390 + if ((left + width > ge2d_config->src2_planes[0].w)
37391 + || (top + height > ge2d_config->src2_planes[0].h)) {
37393 + return -1;
37395 + /*if (ge2d_config->src2_planes[0].addr ==
37396 + * ge2d_config->src_planes[0].addr)
37397 + * index = ge2d_config->src_para.canvas_index;
37401 + if (ge2d_config_mem->src2_mem_alloc_type ==
37404 + &ge2d_config->src2_planes[0],
37405 + ge2d_config->src2_para.format,
37408 + return -1;
37412 + ge2d_config->src2_para.format);
37413 + } else if (ge2d_config_mem->src2_mem_alloc_type ==
37417 + &ge2d_config->src2_planes[0],
37418 + ge2d_config->src2_para.format,
37423 + return -1;
37427 + ge2d_config->src2_para.format);
37430 + if (ge2d_config_mem->src2_mem_alloc_type ==
37434 + &ge2d_config->src2_planes[0],
37435 + ge2d_config->src2_para.format,
37437 + return -1;
37438 + ge2d_config->src2_para.canvas_index = 0;
37440 + ge2d_config->src2_para.format);
37441 + } else if (ge2d_config_mem->src2_mem_alloc_type ==
37445 + &ge2d_config->src2_planes[0],
37446 + ge2d_config->src2_para.format,
37449 + return -1;
37450 + ge2d_config->src2_para.canvas_index = 0;
37452 + ge2d_config->src2_para.format);
37460 + switch (ge2d_config->dst_para.mem_type) {
37464 + (ge2d_config->dst_para.mem_type == CANVAS_OSD0) ?
37466 + return -1;
37467 + ge2d_config->dst_para.canvas_index = tmp.canvas_index;
37468 + ge2d_config->dst_para.format = tmp.ge2d_color_index;
37472 + ge2d_log_dbg("ge2d: dst-->type: osd%d, format: 0x%x !!\n",
37473 + ge2d_config->dst_para.mem_type - CANVAS_OSD0,
37474 + ge2d_config->dst_para.format);
37476 + top = ge2d_config->dst_para.top;
37477 + left = ge2d_config->dst_para.left;
37478 + width = ge2d_config->dst_para.width;
37479 + height = ge2d_config->dst_para.height;
37482 + ge2d_config->dst_para.mem_type - CANVAS_OSD0);
37483 + return -1;
37485 + ge2d_config->dst_para.width = tmp.xres;
37486 + ge2d_config->dst_para.height = tmp.yres;
37490 + ge2d_config->dst_para.format);
37493 + top = ge2d_config->dst_para.top;
37494 + left = ge2d_config->dst_para.left;
37495 + width = ge2d_config->dst_para.width;
37496 + height = ge2d_config->dst_para.height;
37497 + if ((left + width > ge2d_config->dst_planes[0].w)
37498 + || (top + height > ge2d_config->dst_planes[0].h)) {
37500 + return -1;
37502 + /*if (ge2d_config->dst_planes[0].addr ==
37503 + * ge2d_config->src_planes[0].addr)
37504 + * index = ge2d_config->src_para.canvas_index;
37505 + * else if (ge2d_config->dst_planes[0].addr ==
37506 + * ge2d_config->src2_planes[0].addr)
37507 + * index = ge2d_config->src2_para.canvas_index;
37511 + if (ge2d_config_mem->dst_mem_alloc_type ==
37514 + &ge2d_config->dst_planes[0],
37515 + ge2d_config->dst_para.format,
37518 + return -1;
37522 + ge2d_config->dst_para.format);
37523 + } else if (ge2d_config_mem->dst_mem_alloc_type ==
37527 + &ge2d_config->dst_planes[0],
37528 + ge2d_config->dst_para.format,
37533 + return -1;
37537 + ge2d_config->dst_para.format);
37540 + if (ge2d_config_mem->dst_mem_alloc_type ==
37544 + &ge2d_config->dst_planes[0],
37545 + ge2d_config->dst_para.format,
37547 + return -1;
37548 + ge2d_config->dst_para.canvas_index = 0;
37550 + ge2d_config->dst_para.format);
37551 + } else if (ge2d_config_mem->dst_mem_alloc_type ==
37555 + &ge2d_config->dst_planes[0],
37556 + ge2d_config->dst_para.format,
37559 + return -1;
37560 + ge2d_config->dst_para.canvas_index = 0;
37562 + ge2d_config->dst_para.format);
37570 + ge2dgen_rendering_dir(context, ge2d_config->src_para.x_rev,
37571 + ge2d_config->src_para.y_rev,
37572 + ge2d_config->dst_para.x_rev,
37573 + ge2d_config->dst_para.y_rev,
37574 + ge2d_config->dst_xy_swap);
37575 + ge2dgen_const_color(context, ge2d_config->alu_const_color);
37577 + ge2dgen_src(context, ge2d_config->src_para.canvas_index,
37578 + ge2d_config->src_para.format,
37581 + ge2dgen_src_clip(context, ge2d_config->src_para.left,
37582 + ge2d_config->src_para.top,
37583 + ge2d_config->src_para.width,
37584 + ge2d_config->src_para.height);
37585 + ge2dgen_src_key(context, ge2d_config->src_key.key_enable,
37586 + ge2d_config->src_key.key_color,
37587 + ge2d_config->src_key.key_mask,
37588 + ge2d_config->src_key.key_mode);
37590 + ge2dgent_src_gbalpha(context, ge2d_config->src1_gb_alpha,
37591 + ge2d_config->src2_gb_alpha);
37593 + ge2dgent_src_gbalpha(context, ge2d_config->src1_gb_alpha, 0);
37595 + ge2dgen_src_color(context, ge2d_config->src_para.color);
37597 + ge2dgen_src2(context, ge2d_config->src2_para.canvas_index,
37598 + ge2d_config->src2_para.format,
37601 + ge2dgen_src2_clip(context, ge2d_config->src2_para.left,
37602 + ge2d_config->src2_para.top,
37603 + ge2d_config->src2_para.width,
37604 + ge2d_config->src2_para.height);
37606 + ge2dgen_dst(context, ge2d_config->dst_para.canvas_index,
37607 + ge2d_config->dst_para.format,
37610 + ge2dgen_dst_clip(context, ge2d_config->dst_para.left,
37611 + ge2d_config->dst_para.top,
37612 + ge2d_config->dst_para.width,
37613 + ge2d_config->dst_para.height,
37617 + src1_gen_cfg->fill_mode = ge2d_config->src_para.fill_mode;
37618 + src1_gen_cfg->chfmt_rpt_pix = 0;
37619 + src1_gen_cfg->cvfmt_rpt_pix = 0;
37620 + /* src1_gen_cfg->clipx_start_ex = 0; */
37621 + /* src1_gen_cfg->clipx_end_ex = 1; */
37622 + /* src1_gen_cfg->clipy_start_ex = 1; */
37623 + /* src1_gen_cfg->clipy_end_ex = 1; */
37626 + src2_dst_data_cfg->src2_def_color = ge2d_config->src2_para.color;
37629 + src2_dst_gen_cfg->src2_fill_mode = ge2d_config->src2_para.fill_mode;
37633 + dp_gen_cfg->src1_vsc_phase0_always_en =
37634 + ge2d_config->src1_hsc_phase0_always_en;
37635 + dp_gen_cfg->src1_hsc_phase0_always_en =
37636 + ge2d_config->src1_vsc_phase0_always_en;
37637 + if ((context->config.v_scale_coef_type == FILTER_TYPE_GAU0) ||
37638 + (context->config.v_scale_coef_type == FILTER_TYPE_GAU0_BOT) ||
37639 + (context->config.v_scale_coef_type == FILTER_TYPE_GAU1) ||
37640 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU0) ||
37641 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU0_BOT) ||
37642 + (context->config.h_scale_coef_type == FILTER_TYPE_GAU1)) {
37644 + dp_gen_cfg->src1_hsc_rpt_ctrl = ge2d_config->src1_hsc_rpt_ctrl;
37646 + dp_gen_cfg->src1_vsc_rpt_ctrl = ge2d_config->src1_vsc_rpt_ctrl;
37649 + dp_gen_cfg->src1_hsc_rpt_ctrl = 1;
37651 + dp_gen_cfg->src1_vsc_rpt_ctrl = 1;
37653 + dp_gen_cfg->src1_gb_alpha = ge2d_config->src1_gb_alpha & 0xff;
37654 + dp_gen_cfg->src1_gb_alpha_en = ge2d_config->src1_gb_alpha_en & 1;
37656 + dp_gen_cfg->src2_gb_alpha = ge2d_config->src2_gb_alpha & 0xff;
37657 + dp_gen_cfg->src2_gb_alpha_en = ge2d_config->src2_gb_alpha_en & 1;
37659 + dp_gen_cfg->src2_key_en = ge2d_config->src2_key.key_enable;
37660 + dp_gen_cfg->src2_key_mode = ge2d_config->src2_key.key_mode;
37661 + dp_gen_cfg->src2_key = ge2d_config->src2_key.key_color;
37662 + dp_gen_cfg->src2_key_mask = ge2d_config->src2_key.key_mask;
37664 + dp_gen_cfg->bitmask_en = ge2d_config->bitmask_en;
37665 + dp_gen_cfg->bitmask = ge2d_config->bitmask;
37666 + dp_gen_cfg->bytemask_only = ge2d_config->bytemask_only;
37670 + ge2d_cmd_cfg->src1_fill_color_en = ge2d_config->src_para.fill_color_en;
37672 + ge2d_cmd_cfg->src2_x_rev = ge2d_config->src2_para.x_rev;
37673 + ge2d_cmd_cfg->src2_y_rev = ge2d_config->src2_para.y_rev;
37674 + ge2d_cmd_cfg->src2_fill_color_en =
37675 + ge2d_config->src2_para.fill_color_en;
37677 + ge2d_cmd_cfg->src2_cmult_ad = ge2d_config->src2_cmult_ad;
37680 + ge2d_cmd_cfg->vsc_phase_slope = ge2d_config->vsc_phase_slope;
37681 + ge2d_cmd_cfg->vsc_ini_phase = ge2d_config->vf_init_phase;
37682 + ge2d_cmd_cfg->vsc_phase_step = ge2d_config->vsc_start_phase_step;
37683 + ge2d_cmd_cfg->vsc_rpt_l0_num = ge2d_config->vf_rpt_num;
37686 + ge2d_cmd_cfg->hsc_phase_slope = ge2d_config->hsc_phase_slope;
37687 + ge2d_cmd_cfg->hsc_ini_phase = ge2d_config->hf_init_phase;
37688 + ge2d_cmd_cfg->hsc_phase_step = ge2d_config->hsc_start_phase_step;
37689 + ge2d_cmd_cfg->hsc_rpt_p0_num = ge2d_config->hf_rpt_num;
37690 + ge2d_cmd_cfg->src1_cmult_asel = ge2d_config->src1_cmult_asel;
37691 + ge2d_cmd_cfg->src2_cmult_asel = ge2d_config->src2_cmult_asel;
37692 + context->config.update_flag = UPDATE_ALL;
37693 + /* context->config.src1_data.ddr_burst_size_y = 3; */
37694 + /* context->config.src1_data.ddr_burst_size_cb = 3; */
37695 + /* context->config.src1_data.ddr_burst_size_cr = 3; */
37696 + /* context->config.src2_dst_data.ddr_burst_size= 3; */
37697 + memcpy(&context->config.matrix_custom, &ge2d_config_mem->matrix_custom,
37707 + dev = &(ge2d_manager.pdev->dev);
37727 + dev = &(ge2d_manager.pdev->dev);
37735 + dev = &(ge2d_manager.pdev->dev);
37759 + ge2d_work_queue->config.h_scale_coef_type = FILTER_TYPE_BILINEAR;
37760 + ge2d_work_queue->config.v_scale_coef_type = FILTER_TYPE_BILINEAR;
37761 + ge2d_work_queue->ge2d_request_exit = 0;
37766 + INIT_LIST_HEAD(&ge2d_work_queue->work_queue);
37767 + INIT_LIST_HEAD(&ge2d_work_queue->free_queue);
37768 + init_waitqueue_head(&ge2d_work_queue->cmd_complete);
37769 + spin_lock_init(&ge2d_work_queue->lock); /* for process lock. */
37778 + list_add_tail(&p_item->list, &ge2d_work_queue->free_queue);
37785 + list_add_tail(&ge2d_work_queue->list, &ge2d_manager.process_queue);
37801 + list_del(&ge2d_work_queue->list);
37806 + ge2d_work_queue->ge2d_request_exit = 1;
37816 + head = &ge2d_work_queue->work_queue;
37819 + list_del(&pitem->list);
37823 + head = &ge2d_work_queue->free_queue;
37826 + list_del(&pitem->list);
37836 + return -1;
37851 + ge2d_manager.canvas = meson_canvas_get(&pdev->dev);
37854 + return -1;
37859 + // free pre-alloced canvas
37863 + return -1;
37875 + return -1;
37888 + return -1;
37892 + return -1;
37904 + ge2d_manager.irq_num = -1;
37906 + ge2d_irq = -1;
37921 diff -Naur a/vendor/amlogic/ge2d/ge2d_wq.h b/vendor/amlogic/ge2d/ge2d_wq.h
37922 --- a/vendor/amlogic/ge2d/ge2d_wq.h 1970-01-01 08:00:00.000000000 +0800
37923 +++ b/vendor/amlogic/ge2d/ge2d_wq.h 2022-06-24 14:37:49.854257283 +0800
37924 @@ -0,0 +1,43 @@
37968 diff -Naur a/vendor/amlogic/ge2d/Kconfig b/vendor/amlogic/ge2d/Kconfig
37969 --- a/vendor/amlogic/ge2d/Kconfig 1970-01-01 08:00:00.000000000 +0800
37970 +++ b/vendor/amlogic/ge2d/Kconfig 2022-05-31 11:56:47.713259502 +0800
37971 @@ -0,0 +1,16 @@
37988 diff -Naur a/vendor/amlogic/ge2d/Makefile b/vendor/amlogic/ge2d/Makefile
37989 --- a/vendor/amlogic/ge2d/Makefile 1970-01-01 08:00:00.000000000 +0800
37990 +++ b/vendor/amlogic/ge2d/Makefile 2022-05-31 11:56:47.713259502 +0800
37991 @@ -0,0 +1,11 @@
37992 +ge2d-objs = bitblt.o \
38002 +obj-$(CONFIG_AMLOGIC_MEDIA_GE2D) += ge2d.o
38003 diff -Naur a/vendor/amlogic/ge2d/stretchblt.c b/vendor/amlogic/ge2d/stretchblt.c
38004 --- a/vendor/amlogic/ge2d/stretchblt.c 1970-01-01 08:00:00.000000000 +0800
38005 +++ b/vendor/amlogic/ge2d/stretchblt.c 2022-06-24 14:37:49.897553335 +0800
38006 @@ -0,0 +1,141 @@
38034 + ge2d_cmd_cfg->src1_x_start = src_x;
38035 + ge2d_cmd_cfg->src1_x_end = src_x + src_w - 1;
38036 + ge2d_cmd_cfg->src1_y_start = src_y;
38037 + ge2d_cmd_cfg->src1_y_end = src_y + src_h - 1;
38039 + ge2d_cmd_cfg->dst_x_start = dst_x;
38040 + ge2d_cmd_cfg->dst_x_end = dst_x + dst_w - 1;
38041 + ge2d_cmd_cfg->dst_y_start = dst_y;
38042 + ge2d_cmd_cfg->dst_y_end = dst_y + dst_h - 1;
38044 + ge2d_cmd_cfg->sc_hsc_en = 1;
38045 + ge2d_cmd_cfg->sc_vsc_en = 1;
38046 + ge2d_cmd_cfg->hsc_rpt_p0_num = 1;
38047 + ge2d_cmd_cfg->vsc_rpt_l0_num = 1;
38048 + ge2d_cmd_cfg->hsc_div_en = 1;
38050 + ge2d_cmd_cfg->hsc_adv_num =
38051 + ((dst_w - 1) < 1024) ? (dst_w - 1) : 0;
38053 + ge2d_cmd_cfg->hsc_adv_num = 0;
38055 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
38056 + ge2d_cmd_cfg->color_logic_op = LOGIC_OPERATION_COPY;
38057 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
38058 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_COPY;
38059 + ge2d_cmd_cfg->wait_done_flag = block;
38092 + if (dp_gen_cfg->alu_const_color != 0xff) {
38093 + dp_gen_cfg->alu_const_color = 0xff;
38094 + wq->config.update_flag |= UPDATE_DP_GEN;
38099 + ge2d_cmd_cfg->src1_x_start = src_x;
38100 + ge2d_cmd_cfg->src1_x_end = src_x + src_w - 1;
38101 + ge2d_cmd_cfg->src1_y_start = src_y;
38102 + ge2d_cmd_cfg->src1_y_end = src_y + src_h - 1;
38104 + ge2d_cmd_cfg->dst_x_start = dst_x;
38105 + ge2d_cmd_cfg->dst_x_end = dst_x + dst_w - 1;
38106 + ge2d_cmd_cfg->dst_y_start = dst_y;
38107 + ge2d_cmd_cfg->dst_y_end = dst_y + dst_h - 1;
38109 + ge2d_cmd_cfg->sc_hsc_en = 1;
38110 + ge2d_cmd_cfg->sc_vsc_en = 1;
38111 + ge2d_cmd_cfg->hsc_rpt_p0_num = 1;
38112 + ge2d_cmd_cfg->vsc_rpt_l0_num = 1;
38113 + ge2d_cmd_cfg->hsc_div_en = 1;
38115 + ge2d_cmd_cfg->hsc_adv_num =
38116 + ((dst_w - 1) < 1024) ? (dst_w - 1) : 0;
38118 + ge2d_cmd_cfg->hsc_adv_num = 0;
38120 + ge2d_cmd_cfg->color_blend_mode = OPERATION_LOGIC;
38121 + ge2d_cmd_cfg->color_logic_op = LOGIC_OPERATION_COPY;
38122 + ge2d_cmd_cfg->alpha_blend_mode = OPERATION_LOGIC;
38123 + ge2d_cmd_cfg->alpha_logic_op = LOGIC_OPERATION_SET;
38124 + ge2d_cmd_cfg->wait_done_flag = 1;
38148 diff -Naur a/vendor/amlogic/input/Kconfig b/vendor/amlogic/input/Kconfig
38149 --- a/vendor/amlogic/input/Kconfig 1970-01-01 08:00:00.000000000 +0800
38150 +++ b/vendor/amlogic/input/Kconfig 2022-06-06 09:15:34.505066937 +0800
38151 @@ -0,0 +1,10 @@
38162 diff -Naur a/vendor/amlogic/input/keyboard/gpio_keypad.c b/vendor/amlogic/input/keyboard/gpio_keypa…
38163 --- a/vendor/amlogic/input/keyboard/gpio_keypad.c 1970-01-01 08:00:00.000000000 +0800
38164 +++ b/vendor/amlogic/input/keyboard/gpio_keypad.c 2022-07-05 11:21:56.933871769 +0800
38165 @@ -0,0 +1,466 @@
38166 +// SPDX-License-Identifier: GPL-2.0-only
38171 + * Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
38196 +#define DRV_NAME "gpio-keypad"
38237 + unsigned int type = button->type ?: EV_KEY;
38241 + input_event(input, type, button->code, button->value);
38242 + __set_bit(button->code, bdev->rel_axis_seen);
38246 + input_event(input, type, button->code, button->value);
38247 + __set_bit(button->code, bdev->abs_axis_seen);
38250 + input_event(input, type, button->code, state);
38261 + state = gpiod_get_value_cansleep(bdata->gpiod);
38263 + dev_err(input->dev.parent,
38268 + if (state != bdata->last_state) {
38269 + bdata->count = 0;
38270 + bdata->last_state = state;
38278 + if (button->code == KEY_POWER) {
38290 + const struct gpio_keys_platform_data *pdata = bdev->pdata;
38293 + memset(bdev->rel_axis_seen, 0, sizeof(bdev->rel_axis_seen));
38294 + memset(bdev->abs_axis_seen, 0, sizeof(bdev->abs_axis_seen));
38296 + for (i = 0; i < pdata->nbuttons; i++) {
38297 + struct gpio_keys_button_data *bdata = &bdev->data[i];
38299 + if (bdata->count < bdata->threshold) {
38300 + bdata->count++;
38301 + gpio_keys_button_event(input, &pdata->buttons[i],
38302 + bdata->last_state);
38304 + gpio_keypad_check_state(input, &pdata->buttons[i],
38309 + for_each_set_bit(i, input->relbit, REL_CNT) {
38310 + if (!test_bit(i, bdev->rel_axis_seen))
38314 + for_each_set_bit(i, input->absbit, ABS_CNT) {
38315 + if (!test_bit(i, bdev->abs_axis_seen))
38325 + const struct gpio_keys_platform_data *pdata = bdev->pdata;
38327 + if (pdata->enable)
38328 + pdata->enable(bdev->dev);
38336 + const struct gpio_keys_platform_data *pdata = bdev->pdata;
38338 + if (pdata->disable)
38339 + pdata->disable(bdev->dev);
38352 + return ERR_PTR(-EINVAL);
38357 + return ERR_PTR(-ENOMEM);
38361 + pdata->buttons = button;
38362 + pdata->nbuttons = nbuttons;
38364 + pdata->rep = device_property_present(dev, "autorepeat");
38365 + device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
38367 + device_property_read_string(dev, "label", &pdata->name);
38371 + &button->code)) {
38374 + return ERR_PTR(-EINVAL);
38377 + fwnode_property_read_string(child, "label", &button->desc);
38379 + if (fwnode_property_read_u32(child, "linux,input-type",
38380 + &button->type))
38381 + button->type = EV_KEY;
38383 + if (fwnode_property_read_u32(child, "linux,input-value",
38384 + (u32 *)&button->value))
38385 + button->value = 1;
38387 + button->wakeup =
38388 + fwnode_property_read_bool(child, "wakeup-source") ||
38390 + fwnode_property_read_bool(child, "gpio-key,wakeup");
38392 + if (fwnode_property_read_u32(child, "debounce-interval",
38393 + &button->debounce_interval))
38394 + button->debounce_interval = 5;
38407 + for (i = 0; i < pdata->nbuttons; i++) {
38408 + const struct gpio_keys_button *button = &pdata->buttons[i];
38410 + if (button->type != EV_ABS || button->code != code)
38413 + if (button->value < min)
38414 + min = button->value;
38415 + if (button->value > max)
38416 + max = button->value;
38430 + struct device *dev = &pdev->dev;
38444 + if (!pdata->poll_interval) {
38446 + return -EINVAL;
38449 + bdev = devm_kzalloc(dev, struct_size(bdev, data, pdata->nbuttons),
38453 + return -ENOMEM;
38459 + return -ENOMEM;
38464 + input->name = "gpio_keypad";
38465 + input->phys = "gpio_keypad/input0";
38467 + input->id.bustype = BUS_HOST;
38468 + input->id.vendor = 0x0001;
38469 + input->id.product = 0x0001;
38470 + input->id.version = 0x0100;
38472 + input->open = gpio_keypad_open;
38473 + input->close = gpio_keypad_close;
38475 + __set_bit(EV_KEY, input->evbit);
38476 + if (pdata->rep)
38477 + __set_bit(EV_REP, input->evbit);
38479 + for (i = 0; i < pdata->nbuttons; i++) {
38480 + const struct gpio_keys_button *button = &pdata->buttons[i];
38481 + struct gpio_keys_button_data *bdata = &bdev->data[i];
38482 + unsigned int type = button->type ?: EV_KEY;
38484 + if (button->wakeup) {
38487 + return -EINVAL;
38495 + return -EINVAL;
38498 + bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
38500 + button->desc);
38501 + if (IS_ERR(bdata->gpiod)) {
38502 + error = PTR_ERR(bdata->gpiod);
38503 + if (error != -EPROBE_DEFER)
38510 + } else if (gpio_is_valid(button->gpio)) {
38517 + if (button->active_low)
38520 + error = devm_gpio_request_one(dev, button->gpio,
38521 + flags, button->desc ? : DRV_NAME);
38525 + button->gpio, error);
38529 + bdata->gpiod = gpio_to_desc(button->gpio);
38530 + if (!bdata->gpiod) {
38533 + button->gpio);
38534 + return -EINVAL;
38538 + bdata->last_state = -1;
38539 + bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
38540 + pdata->poll_interval);
38542 + input_set_capability(input, type, button->code);
38545 + button->code);
38550 + bdev->input = input;
38551 + bdev->dev = dev;
38552 + bdev->pdata = pdata;
38560 + input_set_poll_interval(input, pdata->poll_interval);
38570 + for (i = 0; i < pdata->nbuttons; i++)
38571 + gpio_keypad_check_state(input, &pdata->buttons[i],
38572 + &bdev->data[i]);
38580 + return -EINVAL;
38583 + info->devName = input->name;
38584 + memcpy(info->devProp, input->propbit, sizeof(unsigned long) * BITS_TO_LONGS(INPUT_PROP_CNT));
38585 + memcpy(info->eventType, input->evbit, sizeof(unsigned long) * BITS_TO_LONGS(EV_CNT));
38586 + memcpy(info->keyCode, input->keybit, sizeof(unsigned long) * BITS_TO_LONGS(KEY_CNT));
38587 + memcpy(info->relCode, input->relbit, sizeof(unsigned long) * BITS_TO_LONGS(REL_CNT));
38588 + memcpy(info->absCode, input->absbit, sizeof(unsigned long) * BITS_TO_LONGS(ABS_CNT));
38589 + memcpy(info->miscCode, input->mscbit, sizeof(unsigned long) * BITS_TO_LONGS(MSC_CNT));
38590 + memcpy(info->ledCode, input->ledbit, sizeof(unsigned long) * BITS_TO_LONGS(LED_CNT));
38591 + memcpy(info->soundCode, input->sndbit, sizeof(unsigned long) * BITS_TO_LONGS(SND_CNT));
38592 + memcpy(info->forceCode, input->ffbit, sizeof(unsigned long) * BITS_TO_LONGS(FF_CNT));
38593 + memcpy(info->switchCode, input->swbit, sizeof(unsigned long) * BITS_TO_LONGS(SW_CNT));
38595 + if (input->absbit[i] != 0) {
38596 + memcpy(info->axisInfo, input->absinfo, sizeof(struct input_absinfo) * ABS_CNT);
38601 + info->bustype = input->id.bustype;
38602 + info->vendor = input->id.vendor;
38603 + info->product = input->id.product;
38604 + info->version = input->id.version;
38612 + return -EINVAL;
38632 diff -Naur a/vendor/amlogic/input/keyboard/Kconfig b/vendor/amlogic/input/keyboard/Kconfig
38633 --- a/vendor/amlogic/input/keyboard/Kconfig 1970-01-01 08:00:00.000000000 +0800
38634 +++ b/vendor/amlogic/input/keyboard/Kconfig 2022-01-25 04:25:14.000000000 +0800
38635 @@ -0,0 +1,27 @@
38663 diff -Naur a/vendor/amlogic/input/keyboard/Makefile b/vendor/amlogic/input/keyboard/Makefile
38664 --- a/vendor/amlogic/input/keyboard/Makefile 1970-01-01 08:00:00.000000000 +0800
38665 +++ b/vendor/amlogic/input/keyboard/Makefile 2022-06-30 16:25:40.030803814 +0800
38666 @@ -0,0 +1,20 @@
38675 +HDF_ROOT_DIR = -I$(srctree)/drivers/hdf
38676 +ccflags-$(CONFIG_DRIVERS_HDF_INPUT) += $(HDF_ROOT_DIR)/framework/model/input/driver \
38686 +obj-y += gpio_keypad.o
38687 diff -Naur a/vendor/amlogic/input/Makefile b/vendor/amlogic/input/Makefile
38688 --- a/vendor/amlogic/input/Makefile 1970-01-01 08:00:00.000000000 +0800
38689 +++ b/vendor/amlogic/input/Makefile 2022-05-18 15:00:36.550000000 +0800
38690 @@ -0,0 +1,8 @@
38697 +obj-y += keyboard/
38699 diff -Naur a/vendor/amlogic/iomap/iomap.c b/vendor/amlogic/iomap/iomap.c
38700 --- a/vendor/amlogic/iomap/iomap.c 1970-01-01 08:00:00.000000000 +0800
38701 +++ b/vendor/amlogic/iomap/iomap.c 2022-06-24 14:37:49.996000883 +0800
38702 @@ -0,0 +1,328 @@
38756 + return -1;
38769 + return -1;
38804 + return -1;
38841 + return -1;
38880 + return -1;
38922 + return -1;
38959 + return -1;
38993 + np = pdev->dev.of_node;
38997 + return -1;
38999 + meson_reg_max[i] = res.end - res.start;
39031 diff -Naur a/vendor/amlogic/iomap/Kconfig b/vendor/amlogic/iomap/Kconfig
39032 --- a/vendor/amlogic/iomap/Kconfig 1970-01-01 08:00:00.000000000 +0800
39033 +++ b/vendor/amlogic/iomap/Kconfig 2022-05-31 11:56:47.713259502 +0800
39034 @@ -0,0 +1,7 @@
39042 diff -Naur a/vendor/amlogic/iomap/Makefile b/vendor/amlogic/iomap/Makefile
39043 --- a/vendor/amlogic/iomap/Makefile 1970-01-01 08:00:00.000000000 +0800
39044 +++ b/vendor/amlogic/iomap/Makefile 2022-05-31 11:56:47.713259502 +0800
39045 @@ -0,0 +1 @@
39046 +obj-y +=iomap.o
39047 diff -Naur a/vendor/amlogic/Kconfig b/vendor/amlogic/Kconfig
39048 --- a/vendor/amlogic/Kconfig 1970-01-01 08:00:00.000000000 +0800
39049 +++ b/vendor/amlogic/Kconfig 2022-07-04 10:15:10.802006361 +0800
39050 @@ -0,0 +1,38 @@
39089 diff -Naur a/vendor/amlogic/make-boot.sh b/vendor/amlogic/make-boot.sh
39090 --- a/vendor/amlogic/make-boot.sh 1970-01-01 08:00:00.000000000 +0800
39091 +++ b/vendor/amlogic/make-boot.sh 2022-06-30 16:01:00.580474631 +0800
39092 @@ -0,0 +1,32 @@
39108 +set -e
39110 +BOOT_LINUX=${1}/kernel/src_tmp/linux-5.10
39116 …--kernel ${BOOT_LINUX}/arch/arm64/boot/Image.gz --base 0x0 --kernel_offset 0x1080000 --cmdline "" …
39118 + mkdir -p ${BOOT_LINUX}/unionpi_tiger
39125 diff -Naur a/vendor/amlogic/Makefile b/vendor/amlogic/Makefile
39126 --- a/vendor/amlogic/Makefile 1970-01-01 08:00:00.000000000 +0800
39127 +++ b/vendor/amlogic/Makefile 2022-07-04 10:16:21.050763386 +0800
39128 @@ -0,0 +1,18 @@
39132 +obj-$(CONFIG_AMLOGIC_BATTERY) += battery/
39133 +obj-$(CONFIG_AMLOGIC_BLUETOOTH) += bluetooth/
39134 +obj-$(CONFIG_AMLOGIC_MEDIA_CANVAS) += canvas/
39135 +obj-$(CONFIG_SND_SOC) += codecs/
39136 +obj-$(CONFIG_AMLOGIC_REBOOT) += reboot/
39137 +obj-$(CONFIG_AMLOGIC_SEC) += secmon/
39138 +obj-$(CONFIG_AMLOGIC_EFUSE_UNIFYKEY) += unifykey/
39139 +obj-$(CONFIG_MMC_MESON_GX) += mmc/
39140 +obj-$(CONFIG_AMLOGIC_IOMAP) += iomap/
39141 +obj-$(CONFIG_AMLOGIC_CPU_VERSION) += cpu_version/
39142 +obj-$(CONFIG_AMLOGIC_MEDIA) += media/
39143 +obj-$(CONFIG_AMLOGIC_MEDIA_GE2D) += ge2d/
39144 +obj-$(CONFIG_AMLOGIC_INPUT) += input/
39145 +obj-$(CONFIG_AMLOGIC_WIFI) += wifi/
39146 +obj-$(CONFIG_MESON_GX_PM) += pm/
39148 diff -Naur a/vendor/amlogic/media/common/codec_mm/codec_mm.c b/vendor/amlogic/media/common/codec_mm…
39149 --- a/vendor/amlogic/media/common/codec_mm/codec_mm.c 1970-01-01 08:00:00.000000000 +0800
39150 +++ b/vendor/amlogic/media/common/codec_mm/codec_mm.c 2022-06-24 14:37:50.106498487 +0800
39151 @@ -0,0 +1,2628 @@
39185 +#include <linux/dma-mapping.h>
39186 +#include <linux/dma-map-ops.h>
39199 +#include <linux/page-flags.h>
39211 +#define MM_ALIGN_DOWN(addr, size) ((addr) & (~((size) - 1)))
39212 +#define MM_ALIGN_UP2N(addr, alg2n) ((addr+(1<<alg2n)-1)&(~((1<<alg2n)-1)))
39246 + return -EINVAL;
39420 + for (i = 0; i < tvp_pool->slot_num; i++) {
39421 + if (!tvp_pool->gen_pool[i])
39424 + tvp_pool->gen_pool[i],
39427 + *from_pool = tvp_pool->gen_pool[i];
39449 + if (!list_empty(&mgt->mem_list)) {
39450 + list_for_each_entry(mem, &mgt->mem_list, list) {
39477 + if (aligned_size <= mgt->total_reserved_size - mgt->alloced_res_size)
39479 + if (aligned_size <= mgt->cma_res_pool.total_size -
39480 + mgt->cma_res_pool.alloced_size)
39483 + if (aligned_size <= mgt->total_cma_size - mgt->alloced_cma_size)
39486 + if (aligned_size / PAGE_SIZE <= mgt->alloc_from_sys_pages_max)
39488 + if (aligned_size <= mgt->tvp_pool.total_size -
39489 + mgt->tvp_pool.alloced_size)
39500 + if (mgt->total_alloced_size >
39501 + mgt->total_codec_mem_size / 2) {
39519 + spin_lock_irqsave(&mgt->lock, flags);
39521 + list_for_each_entry(mem, &mgt->mem_list, list) {
39522 + if (vaddr - mem->vbuffer >= 0 &&
39523 + vaddr - mem->vbuffer < mem->buffer_size) {
39525 + if (mem->phy_addr)
39526 + phy_addr = mem->phy_addr +
39527 + (vaddr - mem->vbuffer);
39532 + spin_unlock_irqrestore(&mgt->lock, flags);
39547 + spin_lock_irqsave(&mgt->lock, flags);
39549 + list_for_each_entry(mem, &mgt->mem_list, list) {
39550 + if (phy_addr >= mem->phy_addr &&
39551 + phy_addr < mem->phy_addr + mem->buffer_size) {
39553 + if (mem->vbuffer)
39554 + vaddr = mem->vbuffer +
39555 + (phy_addr - mem->phy_addr);
39560 + spin_unlock_irqrestore(&mgt->lock, flags);
39577 + page_start = addr - offset;
39600 + pr_info("[HIGH-MEM-MAP] %s, pa(%lx) to va(%p), size: %d\n",
39620 + unsigned int phys = mem->phy_addr;
39621 + unsigned int size = mem->buffer_size;
39629 + mem->flags |= CODEC_MM_FLAGS_FOR_PHYS_VMAPED;
39639 + int align_2n = mem->align2n < PAGE_SHIFT ? PAGE_SHIFT : mem->align2n;
39640 + int try_cma_first = mem->flags & CODEC_MM_FLAGS_CMA_FIRST;
39645 + int can_from_res = (((mgt->res_pool != NULL) ||
39646 + (mgt->cma_res_pool.total_size > 0)) && /*have res */
39647 + !(mem->flags & CODEC_MM_FLAGS_CMA)) || /*must not CMA */
39648 + ((mem->flags & CODEC_MM_FLAGS_RESERVED) ||/*need RESERVED */
39649 + CODEC_MM_FOR_DMA_ONLY(mem->flags) || /*NO CPU */
39650 + ((mem->flags & CODEC_MM_FLAGS_CPU) &&
39651 + (mgt->res_mem_flags & RES_MEM_FLAGS_HAVE_MAPED)));
39653 + int can_from_cma = ((mgt->total_cma_size > 0) &&/*have cma */
39654 + !(mem->flags & CODEC_MM_FLAGS_RESERVED)) ||
39655 + (mem->flags & CODEC_MM_FLAGS_CMA); /*can from CMA */
39658 + int can_from_sys = (mem->flags & CODEC_MM_FLAGS_DMA_CPU) &&
39659 + (mem->page_count <= mgt->alloc_from_sys_pages_max);
39661 + int can_from_tvp = (mem->flags & CODEC_MM_FLAGS_TVP);
39669 + have_space = codec_mm_alloc_pre_check_in(mgt, mem->buffer_size, 0);
39671 + return -10001;
39682 + return -10002;
39686 + if ((mem->flags & CODEC_MM_FLAGS_DMA_CPU) &&
39687 + mem->page_count <= mgt->alloc_from_sys_pages_max &&
39690 + mem->mem_handle = (void *)__get_free_pages(GFP_KERNEL,
39691 + get_order(mem->buffer_size));
39692 + mem->from_flags =
39694 + if (mem->mem_handle) {
39695 + mem->vbuffer = mem->mem_handle;
39696 + mem->phy_addr = virt_to_phys(mem->mem_handle);
39707 + mem->mem_handle = dma_alloc_from_contiguous(mgt->dev,
39708 + mem->page_count,
39709 + align_2n - PAGE_SHIFT, false);
39710 + mem->from_flags = AMPORTS_MEM_FLAGS_FROM_GET_FROM_CMA;
39711 + if (mem->mem_handle) {
39712 + mem->vbuffer = mem->mem_handle;
39713 + mem->phy_addr =
39714 + page_to_phys((struct page *)mem->mem_handle);
39716 + if (mem->flags & CODEC_MM_FLAGS_CMA_CLEAR) {
39718 + /*mem->vbuffer, mem->buffer_size);*/
39725 + if ((can_from_res && mgt->res_pool) &&
39727 + int aligned_buffer_size = ALIGN(mem->buffer_size,
39730 + mem->mem_handle = (void *)gen_pool_alloc(mgt->res_pool,
39732 + mem->from_flags =
39734 + if (mem->mem_handle) {
39736 + mem->vbuffer = NULL;
39737 + mem->phy_addr = (unsigned long)mem->mem_handle;
39738 + mem->buffer_size = aligned_buffer_size;
39745 + if (mgt->cma_res_pool.total_size > 0 &&
39746 + (mgt->cma_res_pool.alloced_size +
39747 + mem->buffer_size) <
39748 + mgt->cma_res_pool.total_size) {
39753 + ALIGN(mem->buffer_size,
39756 + mem->mem_handle =
39758 + &mgt->cma_res_pool,
39759 + &mem->from_ext,
39761 + mem->from_flags =
39763 + if (mem->mem_handle) {
39765 + mem->vbuffer = NULL;
39766 + mem->phy_addr =
39767 + (unsigned long)mem->mem_handle;
39768 + mem->buffer_size = aligned_buffer_size;
39779 + mem->mem_handle = dma_alloc_from_contiguous(mgt->dev,
39780 + mem->page_count,
39781 + align_2n - PAGE_SHIFT, false);
39782 + mem->from_flags = AMPORTS_MEM_FLAGS_FROM_GET_FROM_CMA;
39783 + if (mem->mem_handle) {
39784 + mem->phy_addr =
39786 + mem->mem_handle);
39788 + if (mem->flags & CODEC_MM_FLAGS_CPU)
39789 + mem->vbuffer =
39792 + if (mem->flags & CODEC_MM_FLAGS_CMA_CLEAR) {
39794 + /*mem->vbuffer, mem->buffer_size);*/
39803 + int aligned_buffer_size = ALIGN(mem->buffer_size,
39806 + mem->mem_handle = (void *)codec_mm_extpool_alloc(
39807 + &mgt->tvp_pool,
39808 + &mem->from_ext,
39810 + mem->from_flags =
39812 + if (mem->mem_handle) {
39814 + mem->vbuffer = NULL;
39815 + mem->phy_addr = (unsigned long)mem->mem_handle;
39816 + mem->buffer_size = aligned_buffer_size;
39821 + if ((mem->flags & CODEC_MM_FLAGS_DMA_CPU) &&
39822 + mgt->enable_kmalloc_on_nomem &&
39825 + mem->mem_handle = (void *)__get_free_pages(GFP_KERNEL,
39826 + get_order(mem->buffer_size));
39827 + mem->from_flags =
39829 + if (mem->mem_handle) {
39830 + mem->vbuffer = mem->mem_handle;
39831 + mem->phy_addr =
39832 + virt_to_phys((void *)mem->mem_handle);
39836 + } while (--max_retry > 0);
39837 + if (mem->mem_handle)
39849 + mem->flags,
39850 + mem->align2n,
39852 + mem->page_count,
39853 + mem->buffer_size);
39857 + return -10003;
39864 + int ret = -1;
39867 + if (mgt->tvp_pool.alloced_size <= 0) {
39868 + for (i = 0; i < tvp_pool->slot_num; i++) {
39870 + i, tvp_pool->mm[i]->tvp_handle);
39871 + if (tvp_pool->mm[i]->tvp_handle > 0) {
39873 + tvp_pool->mm[i]->tvp_handle);
39874 + tvp_pool->mm[i]->tvp_handle = -1;
39886 + if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_CMA) {
39887 + if (mem->flags & CODEC_MM_FLAGS_FOR_PHYS_VMAPED)
39888 + codec_mm_unmap_phyaddr(mem->vbuffer);
39890 + dma_release_from_contiguous(mgt->dev,
39891 + mem->mem_handle, mem->page_count);
39892 + } else if (mem->from_flags ==
39894 + gen_pool_free(mgt->res_pool,
39895 + (unsigned long)mem->mem_handle, mem->buffer_size);
39896 + } else if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_TVP) {
39898 + (struct gen_pool *)mem->from_ext,
39899 + mem->mem_handle,
39900 + mem->buffer_size);
39901 + } else if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_PAGES) {
39902 + free_pages((unsigned long)mem->mem_handle,
39903 + get_order(mem->buffer_size));
39904 + } else if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_CMA_RES) {
39906 + (struct gen_pool *)mem->from_ext,
39907 + mem->mem_handle,
39908 + mem->buffer_size);
39910 + spin_lock_irqsave(&mgt->lock, flags);
39911 + if (!(mem->flags & CODEC_MM_FLAGS_FOR_LOCAL_MGR))
39912 + mgt->total_alloced_size -= mem->buffer_size;
39913 + if (mem->flags & CODEC_MM_FLAGS_FOR_SCATTER) {
39914 + mgt->alloced_for_sc_size -= mem->buffer_size;
39915 + mgt->alloced_for_sc_cnt--;
39918 + if (mem->flags & CODEC_MM_FLAGS_FOR_PHYS_VMAPED)
39919 + mgt->phys_vmaped_page_cnt -= mem->page_count;
39921 + if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_CMA) {
39922 + mgt->alloced_cma_size -= mem->buffer_size;
39923 + } else if (mem->from_flags ==
39925 + mgt->alloced_res_size -= mem->buffer_size;
39926 + } else if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_TVP) {
39927 + mgt->tvp_pool.alloced_size -= mem->buffer_size;
39928 + } else if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_PAGES) {
39929 + mgt->alloced_sys_size -= mem->buffer_size;
39930 + } else if (mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_CMA_RES) {
39931 + mgt->cma_res_pool.alloced_size -= mem->buffer_size;
39934 + spin_unlock_irqrestore(&mgt->lock, flags);
39935 + if ((mem->from_flags == AMPORTS_MEM_FLAGS_FROM_GET_FROM_TVP) &&
39937 + mutex_lock(&mgt->tvp_protect_lock);
39938 + if (atomic_read(&mgt->tvp_user_count) == 0) {
39939 + if (codec_mm_tvp_pool_unprotect(&mgt->tvp_pool) == 0) {
39940 + codec_mm_extpool_pool_release(&mgt->tvp_pool);
39941 + mgt->tvp_enable = 0;
39945 + mutex_unlock(&mgt->tvp_protect_lock);
39965 + if (mgt->tvp_enable & 3) {
39983 + mem->buffer_size = PAGE_ALIGN(size);
39984 + count = mem->buffer_size / PAGE_SIZE;
39985 + mem->page_count = count;
39986 + mem->align2n = align2n;
39987 + mem->flags = memflags;
39990 + mgt->alloced_for_sc_cnt > 0 && /*have used for scatter.*/
40006 + mem->flags,
40014 + atomic_set(&mem->use_cnt, 1);
40015 + mem->owner[0] = owner;
40016 + spin_lock_init(&mem->lock);
40017 + spin_lock_irqsave(&mgt->lock, flags);
40018 + mem->mem_id = mgt->global_memid++;
40019 + list_add_tail(&mem->list, &mgt->mem_list);
40020 + switch (mem->from_flags) {
40022 + mgt->alloced_sys_size += mem->buffer_size;
40025 + mgt->alloced_cma_size += mem->buffer_size;
40028 + mgt->tvp_pool.alloced_size += mem->buffer_size;
40031 + mgt->alloced_res_size += mem->buffer_size;
40034 + mgt->cma_res_pool.alloced_size += mem->buffer_size;
40037 + pr_err("error alloc flags %d\n", mem->from_flags);
40039 + if (!(mem->flags & CODEC_MM_FLAGS_FOR_LOCAL_MGR)) {
40040 + mgt->total_alloced_size += mem->buffer_size;
40041 + if (mgt->total_alloced_size > mgt->max_used_mem_size)
40042 + mgt->max_used_mem_size = mgt->total_alloced_size;
40044 + if ((mem->flags & CODEC_MM_FLAGS_FOR_SCATTER)) {
40045 + mgt->alloced_for_sc_size += mem->buffer_size;
40046 + mgt->alloced_for_sc_cnt++;
40049 + if (mem->flags & CODEC_MM_FLAGS_FOR_PHYS_VMAPED)
40050 + mgt->phys_vmaped_page_cnt += mem->page_count;
40052 + spin_unlock_irqrestore(&mgt->lock, flags);
40053 + mem->alloced_jiffies = get_jiffies_64();
40056 + owner, size, mem->phy_addr,
40057 + mem->from_flags,
40076 + spin_lock_irqsave(&mgt->lock, flags);
40079 + spin_unlock_irqrestore(&mgt->lock, flags);
40082 + index = atomic_dec_return(&mem->use_cnt);
40083 + max_owner = mem->owner[index];
40085 + if (mem->owner[i] && strcmp(owner, mem->owner[i]) == 0)
40086 + mem->owner[i] = max_owner;
40090 + owner, mem->buffer_size, mem->phy_addr,
40091 + mem->from_flags, index);
40092 + mem->owner[index] = NULL;
40094 + list_del(&mem->list);
40095 + spin_unlock_irqrestore(&mgt->lock, flags);
40100 + spin_unlock_irqrestore(&mgt->lock, flags);
40110 + addr = dma_alloc_coherent(mgt->dev, size, dma_handle, flag);
40120 + dma_free_coherent(mgt->dev, size, cpu_addr, dma_handle);
40129 + spin_lock_irqsave(&mgt->lock, flags);
40131 + spin_unlock_irqrestore(&mgt->lock, flags);
40153 + dma_sync_single_for_device(mgt->dev,
40159 + dma_addr = dma_map_single(mgt->dev, vaddr, size, dir);
40160 + if (dma_mapping_error(mgt->dev, dma_addr)) {
40165 + dma_sync_single_for_device(mgt->dev, dma_addr, size, dir);
40166 + dma_unmap_single(mgt->dev, dma_addr, size, dir);
40180 + spin_lock_irqsave(&mgt->lock, flags);
40182 + spin_unlock_irqrestore(&mgt->lock, flags);
40187 + index = atomic_read(&mem->use_cnt);
40190 + if (mem->owner[i] &&
40191 + strcmp(owner, mem->owner[i]) == 0) {
40196 + spin_unlock_irqrestore(&mgt->lock, flags);
40206 + int ret = -1;
40208 + spin_lock_irqsave(&mgt->lock, flags);
40210 + ret = -2;
40213 + if (atomic_read(&mem->use_cnt) > 7) {
40214 + ret = -3;
40218 + mem->owner[atomic_inc_return(&mem->use_cnt) - 1] = owner;
40221 + spin_unlock_irqrestore(&mgt->lock, flags);
40234 + spin_lock_irqsave(&mgt->lock, flags);
40235 + if (!list_empty(&mgt->mem_list)) {
40236 + list_for_each_entry(mem, &mgt->mem_list, list) {
40241 + spin_unlock_irqrestore(&mgt->lock, flags);
40253 + return mem->phy_addr;
40270 + mem->ins_id = ins_id;
40271 + mem->ins_buffer_id = buffer_id;
40274 + mem->owner[0] ? mem->owner[0] : "no",
40275 + mem->ins_id,
40278 + return mem->phy_addr;
40291 + return -1;
40303 + pool = gen_pool_create(RESERVE_MM_ALIGNED_2N, -1);
40305 + return -ENOMEM;
40306 + ret = gen_pool_add(pool, mm->phy_addr, mm->buffer_size, -1);
40309 + return -1;
40311 + tvp_pool->gen_pool[tvp_pool->slot_num] = pool;
40312 + mm->tvp_handle = -1;
40313 + tvp_pool->mm[tvp_pool->slot_num] = mm;
40322 + for (i = 0; i < tvp_pool->slot_num; i++) {
40323 + if (tvp_pool->mm[i]->tvp_handle == -1) {
40325 + (uint32_t)tvp_pool->mm[i]->phy_addr,
40326 + (uint32_t)tvp_pool->mm[i]->buffer_size,
40327 + &tvp_pool->mm[i]->tvp_handle);
40329 + i, tvp_pool->mm[i]->tvp_handle, ret);
40332 + i, tvp_pool->mm[i]->tvp_handle, ret);
40344 + int alloced_size = tvp_pool->total_size;
40349 + mutex_lock(&tvp_pool->pool_lock);
40350 + try_alloced_size = mgt->total_reserved_size - mgt->alloced_res_size;
40354 + size - alloced_size, try_alloced_size);
40372 + tvp_pool->slot_num++;
40376 + try_alloced_size = try_alloced_size - 4 * SZ_1M;
40388 + try_alloced_size = mgt->total_cma_size - mgt->alloced_cma_size;
40393 + size - alloced_size, try_alloced_size);
40406 + struct page *mm = mem->mem_handle;
40408 + if (mem->from_flags ==
40414 + mem->page_count,
40423 + mem->page_count,
40429 + tvp_pool->slot_num++;
40433 + try_alloced_size = try_alloced_size - 4 * SZ_1M;
40442 + tvp_pool->total_size = alloced_size;
40445 + mutex_unlock(&tvp_pool->pool_lock);
40461 + mutex_lock(&tvp_pool->pool_lock);
40462 + for (i = 0; i < tvp_pool->slot_num; i++) {
40463 + struct gen_pool *gpool = tvp_pool->gen_pool[i];
40473 + gen_pool_destroy(tvp_pool->gen_pool[i]);
40474 + if (tvp_pool->mm[i]) {
40475 + struct page *mm = tvp_pool->mm[i]->mem_handle;
40477 + if (tvp_pool->mm[i]->from_flags ==
40482 + tvp_pool->mm[i]->page_count,
40484 + codec_mm_release(tvp_pool->mm[i],
40488 + mgt->tvp_pool.total_size -= slot_mem_size;
40489 + tvp_pool->gen_pool[i] = NULL;
40490 + tvp_pool->mm[i] = NULL;
40493 + int before_free_slot = tvp_pool->slot_num + 1;
40495 + for (i = 0; i < tvp_pool->slot_num; i++) {
40496 + if (tvp_pool->gen_pool[i] && before_free_slot < i) {
40497 + tvp_pool->gen_pool[before_free_slot] =
40498 + tvp_pool->gen_pool[i];
40499 + tvp_pool->mm[before_free_slot] =
40500 + tvp_pool->mm[i];
40501 + tvp_pool->gen_pool[i] = NULL;
40502 + tvp_pool->mm[i] = NULL;
40505 + if (!tvp_pool->gen_pool[i] && before_free_slot > i) {
40512 + tvp_pool->slot_num = ignored;
40513 + mutex_unlock(&tvp_pool->pool_lock);
40533 + struct extpool_mgt_s *tvp_pool = &mgt->tvp_pool;
40535 + mutex_lock(&tvp_pool->pool_lock);
40536 + for (i = 0; i < tvp_pool->slot_num && i < victor_size / 2; i++) {
40537 + if (tvp_pool->mm[i]) {
40538 + res[2 * i] = tvp_pool->mm[i]->phy_addr;
40539 + res[2 * i + 1] = tvp_pool->mm[i]->phy_addr +
40540 + tvp_pool->mm[i]->buffer_size - 1;
40543 + mutex_unlock(&tvp_pool->pool_lock);
40550 + struct extpool_mgt_s *tvp_pool = &mgt->tvp_pool;
40553 + mutex_lock(&tvp_pool->pool_lock);
40554 + for (i = 0; i < tvp_pool->slot_num; i++) {
40555 + if (tvp_pool->mm[i]) {
40556 + in = tvp_pool->mm[i]->phy_addr <= phy_addr;
40557 + in2 = (tvp_pool->mm[i]->phy_addr +
40558 + tvp_pool->mm[i]->buffer_size - 1) >= phy_addr;
40565 + mutex_unlock(&tvp_pool->pool_lock);
40576 + if (phy_addr >= mgt->rmem.base &&
40577 + phy_addr < mgt->rmem.base + mgt->rmem.size) {
40578 + if (mgt->res_mem_flags & RES_MEM_FLAGS_HAVE_MAPED)
40616 + static int static_size = -1;
40654 + s = snprintf(pbuf, size - tsize,
40656 + mgt->total_codec_mem_size / SZ_1M);
40660 + s = snprintf(pbuf, size - tsize,
40662 + mgt->total_alloced_size / SZ_1M,
40663 + mgt->max_used_mem_size / SZ_1M);
40667 + s = snprintf(pbuf, size - tsize,
40669 + mgt->alloced_cma_size / SZ_1M,
40670 + mgt->alloced_res_size / SZ_1M,
40671 + mgt->tvp_pool.alloced_size / SZ_1M,
40672 + mgt->alloced_sys_size / SZ_1M,
40673 + (mgt->phys_vmaped_page_cnt << PAGE_SHIFT) / SZ_1M);
40677 + if (mgt->res_pool) {
40678 + s = snprintf(pbuf, size - tsize,
40681 + (int)(gen_pool_size(mgt->res_pool) / SZ_1M),
40682 + (int)(mgt->alloced_res_size / SZ_1M),
40683 + (int)(gen_pool_avail(mgt->res_pool) / SZ_1M));
40688 + s = snprintf(pbuf, size - tsize,
40691 + (int)(mgt->total_cma_size / SZ_1M),
40692 + (int)(mgt->alloced_cma_size / SZ_1M),
40693 + (int)((mgt->total_cma_size -
40694 + mgt->alloced_cma_size) / SZ_1M));
40698 + if (mgt->tvp_pool.slot_num > 0) {
40699 + s = snprintf(pbuf, size - tsize,
40702 + (int)(mgt->tvp_pool.total_size / SZ_1M),
40703 + (int)(mgt->tvp_pool.alloced_size / SZ_1M),
40704 + (int)((mgt->tvp_pool.total_size -
40705 + mgt->tvp_pool.alloced_size) / SZ_1M));
40709 + if (mgt->cma_res_pool.slot_num > 0) {
40710 + s = snprintf(pbuf, size - tsize,
40713 + (int)(mgt->cma_res_pool.total_size / SZ_1M),
40714 + (int)(mgt->cma_res_pool.alloced_size / SZ_1M),
40715 + (int)((mgt->cma_res_pool.total_size -
40716 + mgt->cma_res_pool.alloced_size) / SZ_1M));
40727 + spin_lock_irqsave(&mgt->lock, flags);
40728 + if (list_empty(&mgt->mem_list)) {
40729 + spin_unlock_irqrestore(&mgt->lock, flags);
40732 + list_for_each_entry(mem, &mgt->mem_list, list) {
40733 + s = snprintf(pbuf, size - tsize,
40735 + mem->mem_id,
40736 + mem->ins_id,
40737 + mem->owner[0] ? mem->owner[0] : "no",
40738 + mem->ins_buffer_id,
40739 + (void *)mem->phy_addr,
40740 + mem->buffer_size,
40741 + mem->from_flags,
40742 + atomic_read(&mem->use_cnt)
40744 + s += snprintf(pbuf + s, size - tsize,
40746 + mem->flags, jiffies_to_msecs(get_jiffies_64() -
40747 + mem->alloced_jiffies));
40752 + if (tsize > size - 256) {
40753 + s += snprintf(pbuf + s, size - tsize,
40763 + spin_unlock_irqrestore(&mgt->lock, flags);
40789 + spin_lock_irqsave(&mgt->lock, flags);
40790 + list_for_each_entry(mem, &mgt->mem_list, list) {
40791 + usedb[i].phy_addr = mem->phy_addr;
40792 + usedb[i].buffer_size = mem->buffer_size;
40793 + usedb[i].align2n = mem->align2n;
40799 + cma_base_phy = cma_get_base(dev_get_cma_area(mgt->dev));
40800 + cma_end_phy = cma_base_phy + dma_get_cma_size_int_byte(mgt->dev);
40801 + spin_unlock_irqrestore(&mgt->lock, flags);
40802 + pr_info("free cma idea[%x-%x] from codec_mm items %d\n", cma_base_phy,
40813 + freeb[j].buffer_size = minphy - freeb[j].phy_addr;
40831 + mutex_lock(&mgt->tvp_protect_lock);
40834 + mutex_unlock(&mgt->tvp_protect_lock);
40835 + return -1;
40837 + ret = atomic_add_return(1, &mgt->tvp_user_count);
40840 + &mgt->tvp_pool,
40842 + mgt->tvp_enable = 2;
40844 + pr_info("tvp_user_count is %d\n", atomic_read(&mgt->tvp_user_count));
40845 + mutex_unlock(&mgt->tvp_protect_lock);
40852 + int ret = -1;
40855 + mutex_lock(&mgt->tvp_protect_lock);
40858 + mutex_unlock(&mgt->tvp_protect_lock);
40861 + if (atomic_dec_and_test(&mgt->tvp_user_count)) {
40862 + if (codec_mm_tvp_pool_unprotect(&mgt->tvp_pool) == 0) {
40863 + ret = codec_mm_extpool_pool_release(&mgt->tvp_pool);
40864 + mgt->tvp_enable = 0;
40866 + mutex_unlock(&mgt->tvp_protect_lock);
40871 + if (atomic_read(&mgt->tvp_user_count) < 0)
40872 + atomic_set(&mgt->tvp_user_count, 0);
40874 + atomic_read(&mgt->tvp_user_count));
40875 + mutex_unlock(&mgt->tvp_protect_lock);
40884 + return mgt->tvp_enable;
40891 + int total_size = mgt->total_codec_mem_size;
40903 + total_size -= mgt->total_codec_mem_size / 2;
40905 + total_size -= mgt->total_reserved_size;
40906 + total_size -= mgt->cma_res_pool.total_size;
40909 + total_size -= mgt->total_cma_size;
40919 + return codec_mm_get_total_size() -
40920 + mgt->total_alloced_size;
40928 + return mgt->total_reserved_size;
40936 + return mgt->dev;
40952 + mem->owner[0] = owner;
40953 + mem->mem_handle = NULL;
40954 + mem->buffer_size = buf_size;
40955 + mem->page_count = buf_size / PAGE_SIZE;
40956 + mem->phy_addr = addr;
40957 + mem->ins_buffer_id = index;
40958 + mem->alloced_jiffies = get_jiffies_64();
40959 + mem->from_flags
40962 + spin_lock_irqsave(&mgt->lock, flags);
40964 + mem->mem_id = mgt->global_memid++;
40965 + mgt->alloced_from_coherent += buf_size;
40966 + mgt->total_alloced_size += buf_size;
40967 + mgt->alloced_cma_size += buf_size;
40968 + list_add_tail(&mem->list, &mgt->mem_list);
40970 + spin_unlock_irqrestore(&mgt->lock, flags);
40974 + owner, buf_size, mem->phy_addr, mem->from_flags);
40988 + if (!mem->owner[0] || strcmp(owner, mem->owner[0]) ||
40989 + !mem->buffer_size)
40992 + spin_lock_irqsave(&mgt->lock, flags);
40994 + mgt->alloced_from_coherent -= mem->buffer_size;
40995 + mgt->total_alloced_size -= mem->buffer_size;
40996 + mgt->alloced_cma_size -= mem->buffer_size;
40997 + list_del(&mem->list);
40999 + spin_unlock_irqrestore(&mgt->lock, flags);
41002 + pr_info("%s free mem size %d at %lx from %d\n", mem->owner[0],
41003 + mem->buffer_size, mem->phy_addr, mem->from_flags);
41019 + if (!have_mem && with_wait && mgt->alloced_for_sc_cnt > 0) {
41039 + INIT_LIST_HEAD(&mgt->mem_list);
41040 + mgt->dev = dev;
41041 + mgt->alloc_from_sys_pages_max = 4;
41042 + if (mgt->rmem.size > 0) {
41046 + mgt->res_pool = gen_pool_create(RESERVE_MM_ALIGNED_2N, -1);
41047 + if (!mgt->res_pool)
41048 + return -ENOMEM;
41049 + aligned_addr = ((unsigned long)mgt->rmem.base +
41050 + ((1 << RESERVE_MM_ALIGNED_2N) - 1)) &
41051 + (~((1 << RESERVE_MM_ALIGNED_2N) - 1));
41052 + aligned_size = mgt->rmem.size -
41053 + (int)(aligned_addr - (unsigned long)mgt->rmem.base);
41054 + gen_pool_add(mgt->res_pool,
41055 + aligned_addr, aligned_size, -1);
41057 + (void *)mgt->rmem.base, (void *)aligned_addr,
41058 + (int)mgt->rmem.size, (int)aligned_size);
41059 + mgt->total_reserved_size = aligned_size;
41060 + mgt->total_codec_mem_size = aligned_size;
41062 + mgt->res_mem_flags |= RES_MEM_FLAGS_HAVE_MAPED;
41065 + mgt->total_cma_size = codec_mm_get_cma_size_int_byte(mgt->dev);
41066 + mgt->total_codec_mem_size += mgt->total_cma_size;
41068 + default_tvp_4k_size = mgt->total_codec_mem_size - SZ_1M * 2;
41071 + /*97MB -> 160MB, may not enough for h265*/
41072 + default_tvp_size = (mgt->total_codec_mem_size - (SZ_1M * 2)) >
41077 + default_cma_res_size = mgt->total_cma_size;
41078 + mgt->global_memid = 0;
41079 + mutex_init(&mgt->tvp_pool.pool_lock);
41080 + mutex_init(&mgt->cma_res_pool.pool_lock);
41081 + spin_lock_init(&mgt->lock);
41176 + mutex_lock(&mgt->tvp_protect_lock);
41178 + (tvp_mode << 4) + mgt->tvp_enable);
41180 + atomic_read(&mgt->tvp_user_count));
41188 + mutex_unlock(&mgt->tvp_protect_lock);
41200 + val = -1;
41204 + return -EINVAL;
41211 + mutex_lock(&mgt->tvp_protect_lock);
41216 + ret = codec_mm_extpool_pool_release(&mgt->tvp_pool);
41217 + mgt->tvp_enable = 0;
41222 + &mgt->tvp_pool,
41224 + mgt->tvp_enable = 1;
41229 + &mgt->tvp_pool,
41231 + mgt->tvp_enable = 2;
41237 + mutex_unlock(&mgt->tvp_protect_lock);
41282 + val = -1;
41286 + return -EINVAL;
41289 + ret = codec_mm_extpool_pool_release(&mgt->cma_res_pool);
41290 + mgt->fastplay_enable = 0;
41295 + &mgt->cma_res_pool,
41297 + mgt->fastplay_enable = 1;
41339 + "segment%d:0x%p - 0x%p (size:0x%x)\n",
41343 + (int)(res_victor[2 * i + 1] - res_victor[2 * i] + 1));
41409 + for (i = 0; i <= len - 32; i += sizeof(int) * 8) {
41431 + val = -1;
41435 + return -EINVAL;
41510 + val = -1;
41513 + return -EINVAL;
41537 + val = -1;
41540 + return -EINVAL;
41602 + ret = -1;
41608 + int ret = -1;
41615 + return -ENOMEM;
41632 + ret = -1;
41656 + pdev->dev.platform_data = get_mem_mgt();
41657 + r = of_reserved_mem_device_init(&pdev->dev);
41661 + codec_mm_mgt_init(&pdev->dev);
41667 + r = of_reserved_mem_device_init(&pdev->dev);
41708 + return -ENODEV;
41726 + align = (phys_addr_t) PAGE_SIZE << max(MAX_ORDER - 1, pageblock_order);
41727 + base = ALIGN(rmem->base, align);
41728 + size = round_down(rmem->size - (base - rmem->base), align);
41729 + ret = cma_init_reserved_mem(base, size, 0, &mgt->cma);
41732 + mgt->cma = NULL;
41742 +RESERVEDMEM_OF_DECLARE(codec_mm_cma, "amlogic, codec-mm-cma",
41750 + mgt->rmem = *rmem;
41751 + pr_debug("codec_mm_reserved_init %p->%p\n",
41752 + (void *)mgt->rmem.base,
41753 + (void *)mgt->rmem.base + mgt->rmem.size);
41763 + rmem->ops = &codec_mm_rmem_vdec_ops;
41769 +RESERVEDMEM_OF_DECLARE(codec_mm_reserved, "amlogic, codec-mm-reserved",
41780 diff -Naur a/vendor/amlogic/media/common/codec_mm/codec_mm_keeper.c b/vendor/amlogic/media/common/c…
41781 --- a/vendor/amlogic/media/common/codec_mm/codec_mm_keeper.c 1970-01-01 08:00:00.000000000 +0800
41782 +++ b/vendor/amlogic/media/common/codec_mm/codec_mm_keeper.c 2022-06-24 14:37:50.130813817 +0800
41783 @@ -0,0 +1,290 @@
41817 +#define MAX_KEEP_ID (INT_MAX - 1)
41853 + int keep_id = -1;
41857 + int slot_i = -1;
41864 + return -2;
41869 + return -3;
41878 + return -4;
41885 + return -4;
41888 + spin_lock_irqsave(&mgr->lock, flags);
41889 + keep_id = mgr->next_id++;
41890 + if (mgr->next_id >= MAX_KEEP_ID)
41891 + mgr->next_id = START_KEEP_ID;
41893 + if (!mgr->keep_list[i].handle && slot_i < 0)
41895 + else if (mgr->keep_list[i].handle == mem_handle) {
41897 + keep_id = mgr->keep_list[i].keep_id;
41902 + mgr->keep_list[slot_i].handle = mem_handle;
41903 + mgr->keep_list[slot_i].keep_id = keep_id;
41904 + mgr->keep_list[slot_i].type = type;
41905 + mgr->keep_list[slot_i].user = 1;
41906 + mgr->num++;
41909 + keep_id = -1;
41924 + spin_unlock_irqrestore(&mgr->lock, flags);
41943 + return -1;
41945 + spin_lock_irqsave(&mgr->lock, flags);
41947 + if (keep_id == mgr->keep_list[i].keep_id) {
41948 + mgr->keep_list[i].user--; /*mask can free. */
41949 + mgr->keep_list[i].delay_on_jiffies64 =
41954 + spin_unlock_irqrestore(&mgr->lock, flags);
41955 + schedule_delayed_work(&mgr->dealy_work, delayms);/*do free later, */
41967 + spin_lock_irqsave(&mgr->lock, flags);
41968 + mem_handle = mgr->keep_list[index].handle;
41969 + type = mgr->keep_list[index].type;
41970 + mgr->keep_list[index].handle = NULL;
41971 + mgr->keep_list[index].delay_on_jiffies64 = 0;
41972 + mgr->num--;
41973 + spin_unlock_irqrestore(&mgr->lock, flags);
41975 + return -1;
41997 + struct keep_mem_info *info = &mgr->keep_list[i];
41998 + if (!info->handle || info->keep_id < 0)
42002 + info->delay_on_jiffies64);
42005 + else if (force == 2 && info->user <= 0)
42007 + else if (info->user <= 0 && time_after)
42036 + mgr->next_id,
42037 + mgr->work_runs,
42038 + mgr->num);
42042 + mgr->keep_list[i].keep_id,
42043 + mgr->keep_list[i].handle,
42044 + mgr->keep_list[i].type,
42045 + mgr->keep_list[i].user);
42058 + mgr->work_runs++;
42060 + if (mgr->num > 0) /*have some not free, run later.*/
42061 + schedule_delayed_work(&mgr->dealy_work, 10);
42069 + mgr->next_id = START_KEEP_ID;
42070 + spin_lock_init(&mgr->lock);
42071 + INIT_DELAYED_WORK(&mgr->dealy_work, codec_mm_keeper_monitor);
42074 diff -Naur a/vendor/amlogic/media/common/codec_mm/codec_mm_keeper_priv.h b/vendor/amlogic/media/com…
42075 --- a/vendor/amlogic/media/common/codec_mm/codec_mm_keeper_priv.h 1970-01-01 08:00:00.000000000 +08…
42076 +++ b/vendor/amlogic/media/common/codec_mm/codec_mm_keeper_priv.h 2022-06-24 14:37:50.153606920 +08…
42077 @@ -0,0 +1,24 @@
42102 diff -Naur a/vendor/amlogic/media/common/codec_mm/codec_mm_priv.h b/vendor/amlogic/media/common/cod…
42103 --- a/vendor/amlogic/media/common/codec_mm/codec_mm_priv.h 1970-01-01 08:00:00.000000000 +0800
42104 +++ b/vendor/amlogic/media/common/codec_mm/codec_mm_priv.h 2022-06-24 14:37:50.174206631 +0800
42105 @@ -0,0 +1,59 @@
42165 diff -Naur a/vendor/amlogic/media/common/codec_mm/codec_mm_scatter.c b/vendor/amlogic/media/common/…
42166 --- a/vendor/amlogic/media/common/codec_mm/codec_mm_scatter.c 1970-01-01 08:00:00.000000000 +0800
42167 +++ b/vendor/amlogic/media/common/codec_mm/codec_mm_scatter.c 2022-06-24 14:37:50.212708286 +0800
42168 @@ -0,0 +1,3038 @@
42201 +#include <linux/dma-mapping.h>
42202 +#include <linux/dma-map-ops.h>
42230 +#define MAX_SID (SID_MASK - 1)
42231 +#define MAX_HASH_SID (MAX_SID - 1)
42238 +*hash ID: 0-MAX_HASH_SID
42242 +#define SLOT_TO_SID(slot) HASH_PAGE_ADDR(((slot->phy_addr)>>PAGE_SHIFT))
42251 +#define PAGE_SID_OF_MMS(mms, id) PAGE_SID((mms)->pages_list[id])
42252 +#define PAGE_ADDR_OF_MMS(mms, id) PAGE_ADDR((mms)->pages_list[id])
42255 + !(mms)->pages_list ||\
42256 + (mms)->page_cnt <= (id) ||\
42260 +#define ADDR2BIT(base, addr) (((addr) - (base)) >> PAGE_SHIFT)
42263 +#define VALID_BIT(slot, bit) (bit >= 0 && ((slot->pagemap_size << 3) > bit))
42264 +#define CODEC_MM_S_ERR(x) ((-1000) - (x))
42372 +#define is_cache_sc(smgt, mms) ((smgt->cache_scs[0] == mms) ||\
42373 + (smgt->cache_scs[1] == mms))
42445 + TRY_MLOCK_INFO(&mms->mutex, line, 10 * HZ, "mms");
42451 + TRY_SLOCK_INFO(&smgt->list_lock, line, 10 * HZ, "list");
42457 + mutex_lock(&mms->mutex);
42462 + return mutex_trylock(&mms->mutex);
42468 + spin_lock(&smgt->list_lock);
42474 + mutex_unlock(&mms->mutex);
42480 + spin_unlock(&smgt->list_lock);
42504 + if (!for_update && delayed_work_pending(&smgt->dealy_work))
42506 + if (delayed_work_pending(&smgt->dealy_work))
42507 + cancel_delayed_work(&smgt->dealy_work);
42510 + &smgt->dealy_work, delay_ms * HZ / 1000);
42512 + ret = schedule_delayed_work(&smgt->dealy_work,
42527 + spend_time_us = (int)(codec_mm_get_current_us() - startus);
42531 + smgt->alloc_cnt++;
42533 + smgt->alloc_10us_less_cnt++;
42535 + smgt->alloc_10_50us_cnt++;
42537 + smgt->alloc_50_100us_cnt++;
42539 + smgt->alloc_100_1000us_cnt++;
42541 + smgt->alloc_1_10ms_cnt++;
42543 + smgt->alloc_10_100ms_cnt++;
42545 + smgt->alloc_100ms_up_cnt++;
42547 + smgt->alloc_total_us += spend_time_us;
42548 + if (spend_time_us > smgt->alloc_max_us) {
42550 + smgt->alloc_max_us = spend_time_us;
42560 + spend_time_us = (int)(codec_mm_get_current_us() - startus);
42564 + smgt->free_cnt++;
42566 + smgt->free_10us_less_cnt++;
42568 + smgt->free_10_50us_cnt++;
42570 + smgt->free_50_100us_cnt++;
42572 + smgt->free_100_1000us_cnt++;
42574 + smgt->free_1_10ms_cnt++;
42576 + smgt->free_10_100ms_cnt++;
42578 + smgt->free_100ms_up_cnt++;
42580 + smgt->free_total_us += spend_time_us;
42581 + if (spend_time_us > smgt->free_max_us) {
42583 + smgt->free_max_us = spend_time_us;
42591 + smgt->alloc_cnt = 0;
42592 + smgt->alloc_10us_less_cnt = 0;
42593 + smgt->alloc_10_50us_cnt = 0;
42594 + smgt->alloc_50_100us_cnt = 0;
42595 + smgt->alloc_100_1000us_cnt = 0;
42596 + smgt->alloc_1_10ms_cnt = 0;
42597 + smgt->alloc_10_100ms_cnt = 0;
42598 + smgt->alloc_100ms_up_cnt = 0;
42599 + smgt->alloc_total_us = 0;
42600 + smgt->alloc_max_us = 0;
42602 + smgt->free_cnt = 0;
42603 + smgt->free_10us_less_cnt = 0;
42604 + smgt->free_10_50us_cnt = 0;
42605 + smgt->free_50_100us_cnt = 0;
42606 + smgt->free_100_1000us_cnt = 0;
42607 + smgt->free_1_10ms_cnt = 0;
42608 + smgt->free_10_100ms_cnt = 0;
42609 + smgt->free_100ms_up_cnt = 0;
42610 + smgt->free_total_us = 0;
42611 + smgt->free_max_us = 0;
42630 + if (!list_empty(&smgt->free_list)) {
42633 + header = &smgt->free_list;
42634 + list = header->prev;
42638 + total_pages += slot->page_num;
42639 + alloced_pages += slot->alloced_page_num;
42641 + if (slot->page_num - slot->alloced_page_num >
42643 + max_free_pages_sg = slot->page_num -
42644 + slot->alloced_page_num;
42645 + list = list->prev;
42651 + *free_pages = total_pages - alloced_pages;
42667 + return -1;
42669 + slot->sid = sid;
42670 + INIT_LIST_HEAD(&slot->sid_list);
42671 + INIT_LIST_HEAD(&slot->free_list);
42673 + if (!smgt->slot_list_map[sid]) {
42674 + smgt->slot_list_map[sid] = slot;
42675 + slot->isroot = 1;
42677 + struct codec_mm_slot *f_slot = smgt->slot_list_map[sid];
42679 + list_add_tail(&slot->sid_list, &f_slot->sid_list);
42680 + slot->isroot = 0;
42682 + smgt->total_page_num += slot->page_num;
42683 + smgt->slot_cnt++;
42684 + if (slot->from_type == SLOT_FROM_GET_FREE_PAGES) {
42685 + smgt->alloc_from_sys_sc_cnt++;
42686 + smgt->alloc_from_sys_page_cnt += slot->page_num;
42687 + if (smgt->alloc_from_sys_page_cnt >
42688 + smgt->alloc_from_sys_max_page_cnt)
42689 + smgt->alloc_from_sys_max_page_cnt =
42690 + smgt->alloc_from_sys_page_cnt;
42692 + list_add_tail(&slot->free_list, &smgt->free_list);
42706 + fslot = smgt->slot_list_map[sid];
42713 + while (!(addr >= slot->phy_addr && /*optimization with hash? */
42715 + (slot->phy_addr +
42716 + (slot->page_num << PAGE_SHIFT)))) {
42719 + slot = list_entry(slot->sid_list.prev,
42722 + *pr_err("Slot range from =%p->%p\n",
42723 + *(void *)slot->phy_addr,
42724 + *(void *)slot->phy_addr +
42725 + *(slot->page_num << PAGE_SHIFT));
42747 + if (slot->alloced_page_num > 0 || slot->on_alloc_free) {
42749 + return -1;
42751 + if (!list_empty(&slot->free_list))
42752 + list_del(&slot->free_list);
42753 + if (!list_empty(&slot->sid_list)) {
42754 + if (slot->isroot) {
42757 + next_slot = list_entry(slot->sid_list.next,
42759 + next_slot->isroot = 1;
42760 + smgt->slot_list_map[slot->sid] = next_slot;
42762 + list_del(&slot->sid_list);
42764 + smgt->slot_list_map[slot->sid] = NULL;
42766 + smgt->slot_cnt--;
42767 + smgt->total_page_num -= slot->page_num;
42768 + if (slot->from_type == SLOT_FROM_GET_FREE_PAGES) {
42769 + smgt->alloc_from_sys_sc_cnt--;
42770 + smgt->alloc_from_sys_page_cnt -= slot->page_num;
42773 + switch (slot->from_type) {
42775 + if (slot->mm)
42776 + codec_mm_release(slot->mm, SCATTER_MEM);
42778 + ERR_LOG("ERR:slot->mm is ERROR:%p\n", slot->mm);
42781 + if (slot->page_header != 0)
42782 + free_pages(slot->page_header,
42783 + get_order(PAGE_SIZE * slot->page_num));
42785 + ERR_LOG("ERR:slot->page_header is ERROR:%p\n",
42786 + (void *)slot->page_header);
42790 + ERR_LOG("unknown from type:%d\n", slot->from_type);
42791 + ret = -1;
42794 + kfree(slot->pagemap);
42802 + if (smgt->keep_size_PAGE > 0) {
42804 + int free_pages = smgt->total_page_num - smgt->alloced_page_num;
42806 + if (free_pages < smgt->keep_size_PAGE)
42807 + return -1;
42814 + slot->alloced_page_num = 0;
42819 + slot->pagemap_size = (slot->page_num >> 3) + 2;
42820 + slot->pagemap = kmalloc(slot->pagemap_size, GFP_KERNEL);
42821 + if (!slot->pagemap) {
42823 + return -1;
42825 + memset(slot->pagemap, 0, slot->pagemap_size);
42826 + slot->next_bit = 0;
42853 + (smgt->tvp_mode ||
42855 + smgt->reserved_block_mm_M * SZ_1M))) {
42859 + smgt->try_alloc_in_cma_page_cnt *
42867 + (smgt->tvp_mode ?
42871 + slot->from_type = SLOT_FROM_CODEC_MM;
42872 + slot->mm = mm;
42873 + slot->page_num = mm->page_count;
42874 + slot->phy_addr = mm->phy_addr;
42876 + if (slot->pagemap == NULL) {
42882 + slot->page_num);
42886 + if (!have_alloced && !smgt->support_from_slot_sys) {
42893 + smgt->try_alloc_in_sys_page_cnt << PAGE_SHIFT;
42904 + if (smgt->tvp_mode || smgt->no_alloc_from_sys)
42911 + slot->page_header = __get_free_pages(
42914 + if (!slot->page_header) {
42916 + smgt->try_alloc_in_sys_page_cnt_min) {
42918 + smgt->try_alloc_in_sys_page_cnt =
42925 + smgt->support_from_slot_sys = 0;
42933 + slot->from_type = SLOT_FROM_GET_FREE_PAGES;
42934 + slot->mm = NULL;
42935 + slot->page_num = 1 << page_order;
42936 + slot->phy_addr =
42937 + virt_to_phys((unsigned long *)slot->page_header);
42939 + if (slot->pagemap == NULL) {
42940 + free_pages(slot->page_header, page_order);
42960 + if (!slot || !slot->pagemap || slot->page_num <= 0)
42963 + bit = ADDR2BIT(slot->phy_addr, phy_addr);
42967 + slot->on_alloc_free++;
42968 + if (!test_and_clear_bit(bit, slot->pagemap)) {
42971 + slot->on_alloc_free--;
42975 + slot->alloced_page_num--;
42976 + slot->on_alloc_free--;
42993 + if (!slot || !slot->pagemap)
42994 + return -1;
42995 + if (slot->alloced_page_num >= slot->page_num)
42996 + return -2;
42997 + tryn = slot->page_num;
42998 + can_alloced = slot->page_num - slot->alloced_page_num;
43000 + i = slot->next_bit;
43002 + while (need > 0 && (slot->on_alloc_free == 1)) {
43006 + ERR_LOG("\ti=%d,slot->pagemap=%p\n",
43008 + slot->pagemap);
43012 + if (!test_and_set_bit(i, slot->pagemap)) {
43013 + page = ADDR2PAGE(BIT2ADDR(slot->phy_addr, i),
43014 + slot->sid);
43015 + slot->alloced_page_num++;
43018 + need--;
43022 + if (i >= slot->page_num)
43024 + if (--tryn <= 0)
43027 + slot->next_bit = i;
43028 + if (i >= slot->page_num)
43029 + slot->next_bit = 0;
43031 + slot, slot->page_num,
43032 + slot->alloced_page_num, alloced);
43044 + page = mms->pages_list[id];
43056 + page = mms->pages_list[id];
43070 + return -1;
43076 + if (slot->alloced_page_num == 0)
43081 + if (list_empty(&slot->free_list) &&
43082 + (slot->alloced_page_num < slot->page_num)) {
43084 + slot, slot->page_num,
43085 + slot->alloced_page_num, ret);
43086 + list_add_tail(&slot->free_list, &smgt->free_list);
43111 + neednum--;
43120 + smgt->total_page_num += alloced;
43121 + smgt->one_page_cnt += alloced;
43122 + smgt->alloced_page_num += alloced;
43137 + if (!smgt->tvp_mode &&
43138 + list_empty(&smgt->free_list) &&
43140 + smgt->reserved_block_mm_M * SZ_1M) &&
43141 + !smgt->support_from_slot_sys) {/*no sys*/
43149 + if (smgt->total_page_num <= 0 || /*no codec mm. */
43150 + smgt->alloced_page_num == smgt->total_page_num ||
43151 + list_empty(&smgt->free_list)) {
43156 + smgt->try_alloc_in_cma_page_cnt/4;
43177 + if (slot && slot->on_alloc_free != 0) {
43179 + slot->on_alloc_free);
43182 + if (!slot && !list_empty(&smgt->free_list)) {
43183 + slot = list_entry(smgt->free_list.next,
43187 + else if (slot->on_alloc_free != 0) {
43189 + slot->on_alloc_free);
43193 + if (slot && slot->on_alloc_free == 0) { /*del from free list. */
43194 + slot->on_alloc_free++;
43195 + list_del_init(&slot->free_list);
43205 + slot->on_alloc_free--; /*alloc use end */
43206 + if (slot->alloced_page_num < slot->page_num &&
43207 + list_empty(&slot->free_list)) {
43209 + slot, slot->page_num,
43210 + slot->alloced_page_num, alloced);
43211 + list_add_tail(&slot->free_list,
43212 + &smgt->free_list);
43219 + neednum -= n;
43223 + DBG_LOG("smgt->free_list.next:%p\n",
43224 + smgt->free_list.next);
43225 + DBG_LOG("smgt->free_list.prev:%p\n",
43226 + smgt->free_list.prev);
43227 + DBG_LOG("slot->free_list:%p\n",
43228 + &slot->free_list);
43229 + DBG_LOG("slot->free_list.next:%p\n",
43230 + slot->free_list.next);
43249 + smgt->alloced_page_num += alloced;
43250 + if (smgt->max_alloced < smgt->alloced_page_num)
43251 + smgt->max_alloced = smgt->alloced_page_num;
43266 + if (smgt->cache_scs[0] == cur_mms)
43267 + mms = smgt->cache_scs[1];
43269 + mms = smgt->cache_scs[0];
43270 + } else if (smgt->cache_scs[0] && smgt->cache_scs[1]) {
43272 + int id = -1;
43274 + if (smgt->cache_scs[0]->page_cnt >=
43275 + smgt->cache_scs[1]->page_cnt)
43279 + mms = smgt->cache_scs[id];
43281 + if (smgt->cache_scs[0])
43282 + mms = smgt->cache_scs[0];
43284 + mms = smgt->cache_scs[1];
43310 + alloced = min(mms->page_cnt, need);
43312 + mms->page_cnt -= alloced;
43313 + mms->page_tail -= alloced;
43315 + memcpy(pages, &mms->pages_list[mms->page_tail + 1],
43319 + memcpy(pages, &mms->pages_list[0],
43321 + memmove(&mms->pages_list[0],
43322 + &mms->pages_list[alloced],
43323 + mms->page_cnt * sizeof(phy_addr_type));
43325 + memset(&mms->pages_list[mms->page_tail + 1], 0,
43331 + smgt->cached_pages -= alloced;
43351 + src_mms, &pages[alloced], num - alloced, 1);
43374 + num - alloced);
43385 + num - alloced);
43390 + } else if (!smgt->no_alloc_from_sys && !smgt->tvp_mode) {
43394 + num - alloced);
43414 + if (src_mms->page_used >= src_mms->page_cnt)
43415 + return -1; /*no need free. */
43421 + return -2;/*mms is locked try another.*/
43425 + moved = min(src_mms->page_cnt - src_mms->page_used,
43426 + dst_mms->page_max_cnt - dst_mms->page_cnt);
43427 + left = src_mms->page_cnt - moved;
43429 + memcpy(&dst_mms->pages_list[dst_mms->page_tail + 1],
43430 + &src_mms->pages_list[left],
43432 + memset(&src_mms->pages_list[left], 0,
43435 + dst_mms->page_cnt += moved;
43436 + dst_mms->page_tail += moved;
43437 + src_mms->page_cnt -= moved;
43438 + src_mms->page_tail -= moved;
43442 + smgt->cached_pages += moved;
43460 + if (alloced == -2) {
43489 + smgt->one_page_cnt--;
43490 + smgt->total_page_num--;
43492 + if (id == mms->page_tail)
43493 + mms->page_tail--;
43494 + mms->page_cnt--;
43499 + mms->page_cnt--;
43500 + mms->page_tail--;
43513 + (struct codec_mm_scatter_mgt *)mms->manager;
43520 + for (i = mms->page_tail; i >= id; i--) {
43526 + (int)mms->pages_list[i]);
43534 + mms->pages_list[i] = (phy_addr_type) 0;
43537 + smgt->alloced_page_num -= freeNum;
43539 + smgt->cached_pages -= freeNum;
43566 + return -1;
43571 + start_free_id = mms->page_used;
43574 + if (id >= mms->page_cnt)
43577 + start_free_id = mms->page_cnt - id;
43579 + start_free_id = -1;
43582 + (start_free_id >= mms->page_cnt) ||
43583 + (mms->page_tail < 0)) {
43585 + start_free_id != mms->page_cnt) {
43591 + mms->page_cnt,
43597 + return -1;
43599 + smgt = (struct codec_mm_scatter_mgt *)mms->manager;
43601 + mms->page_used = start_free_id;
43615 + if (fast_mode == 2 || mms->page_used == mms->page_cnt) {
43646 + return -1;
43647 + if (start_free_id < mms->page_cnt)
43652 + (struct codec_mm_scatter_mgt *)mms->manager,
43697 + if (smgt->scmap[i] == NULL) {
43698 + smgt->scmap[i] = mms;
43702 + return -1;
43712 + if (smgt->scmap[i] == mms) {
43713 + smgt->scmap[i] = NULL;
43728 + if (smgt->scmap[i] == mms) {
43748 + ret = atomic_read(&mms->user_cnt);
43757 + free = mms->page_cnt;
43758 + if (!list_empty(&mms->list))
43759 + list_del(&mms->list);
43761 + smgt->scatters_cnt--;
43767 + if (mms->page_cnt > 0)
43770 + (smgt->try_alloc_in_sys_page_cnt <
43771 + smgt->try_alloc_in_sys_page_cnt_max) &&
43772 + (smgt->total_page_num < (1024 * 1024 * 32 >> PAGE_SHIFT))) {
43773 + smgt->try_alloc_in_sys_page_cnt *= 2;
43774 + if (!smgt->support_from_slot_sys) {
43775 + smgt->support_from_slot_sys =
43776 + smgt->enable_slot_from_sys;
43800 + int ret = -1;
43806 + return -1;
43808 + old_user = atomic_read(&mms->user_cnt);
43810 + ret = atomic_add_return(cnt, &mms->user_cnt);
43812 + mms->tofree_jiffies = jiffies;
43825 + return -1;
43850 + return -1;
43852 + if (atomic_read(&mms->user_cnt) >= 1) {
43853 + after_users = atomic_sub_return(cnt, &mms->user_cnt);
43856 + mms->tofree_jiffies = jiffies +
43874 + return -1;
43948 + mms->pages_list = (phy_addr_type *) (mms + 1);
43949 + mms->page_max_cnt = max_page;
43950 + INIT_LIST_HEAD(&mms->list);
43951 + memset(mms->pages_list, 0, sizeof(phy_addr_type) * max_page);
43952 + mms->page_cnt = 0;
43953 + mms->page_tail = -1;
43954 + mms->manager = (void *)smgt;
43955 + atomic_set(&mms->user_cnt, 0);
43956 + mutex_init(&mms->mutex);
43959 + mms->pages_list, page_num,
43963 + mms->page_cnt = ret;
43964 + mms->page_tail = mms->page_cnt - 1;
43966 + atomic_set(&mms->user_cnt, 1000);
43968 + mms->page_used = mms->page_cnt;
43969 + list_add_tail(&mms->list, &smgt->scatter_list);
43970 + smgt->scatters_cnt++;
44003 + if (!list_empty(&smgt->scatter_list)) { /*try find a free scatter. */
44004 + pos = smgt->scatter_list.prev; /*free on prev. */
44005 + while (pos != &smgt->scatter_list) {
44006 + next = pos->prev;
44008 + if (mms->page_max_cnt >= max_page &&
44009 + atomic_read(&mms->user_cnt) == 0) {
44011 + &mms->user_cnt) == 1000) {
44012 + mms->page_used = mms->page_cnt;
44016 + atomic_sub(1000, &mms->user_cnt);
44042 + atomic_sub(1000, &alloced_mms->user_cnt);
44060 + if (want_pages > mms->page_max_cnt)
44065 + mms->page_used = want_pages;
44068 + if (want_pages > mms->page_cnt) {
44071 + &mms->pages_list[mms->page_tail + 1],
44072 + want_pages - mms->page_cnt,
44079 + mms->page_cnt += ret;
44080 + mms->page_tail += ret;
44086 + smgt->cached_pages += ret;
44091 + if (smgt->cached_pages < smgt->keep_size_PAGE / 2) {
44106 + return -1;
44107 + smgt = (struct codec_mm_scatter_mgt *)mms->manager;
44126 + header = &smgt->free_list;
44127 + list = header->prev;
44131 + if (slot->alloced_page_num == 0) {
44132 + list_del_init(&slot->free_list);
44136 + list = list->prev;
44176 + smgt->tvp_mode ? "TVP " : "");
44178 + (smgt->total_page_num << PAGE_SHIFT) / SZ_1M,
44179 + smgt->total_page_num << PAGE_SHIFT,
44180 + smgt->total_page_num);
44181 + n = smgt->alloced_page_num;
44187 + (smgt->max_alloced << PAGE_SHIFT) / SZ_1M,
44188 + smgt->max_alloced);
44190 + (smgt->cached_pages << PAGE_SHIFT) / SZ_1M,
44191 + smgt->cached_pages);
44194 + (smgt->alloc_from_sys_sc_cnt +
44195 + smgt->one_page_cnt) << PAGE_SHIFT);
44198 + smgt->alloc_from_sys_sc_cnt);
44200 + smgt->alloc_from_sys_page_cnt);
44202 + smgt->alloc_from_sys_max_page_cnt);
44204 + smgt->scatter_task_run_num);
44206 + smgt->one_page_cnt);
44207 + BUFPRINT("\tcatters cnt:%d\n", smgt->scatters_cnt);
44208 + BUFPRINT("\tslot cnt:%d\n", smgt->slot_cnt);
44210 + smgt->try_alloc_in_cma_page_cnt);
44212 + smgt->try_alloc_in_sys_page_cnt);
44214 + smgt->delay_free_on);
44216 + smgt->delay_free_timeout_jiffies64);
44220 + smgt->alloc_max_us);
44222 + smgt->alloc_cnt,
44223 + smgt->alloc_10us_less_cnt,
44224 + smgt->alloc_10_50us_cnt,
44225 + smgt->alloc_50_100us_cnt,
44226 + smgt->alloc_100_1000us_cnt,
44227 + smgt->alloc_1_10ms_cnt,
44228 + smgt->alloc_10_100ms_cnt,
44229 + smgt->alloc_100ms_up_cnt
44232 + smgt->free_max_us);
44234 + smgt->free_cnt,
44235 + smgt->free_10us_less_cnt,
44236 + smgt->free_10_50us_cnt,
44237 + smgt->free_50_100us_cnt,
44238 + smgt->free_100_1000us_cnt,
44239 + smgt->free_1_10ms_cnt,
44240 + smgt->free_10_100ms_cnt,
44241 + smgt->free_100ms_up_cnt
44245 + u64 divider = smgt->alloc_total_us;
44247 + do_div(divider, smgt->alloc_cnt);
44248 + average_timeus = (smgt->alloc_cnt == 0 ?
44252 + divider = smgt->free_total_us;
44254 + do_div(divider, smgt->free_cnt);
44255 + average_timeus = (smgt->free_cnt == 0 ?
44281 + esize -= ret;
44313 + (slot->from_type == SLOT_FROM_CODEC_MM ? "codec_mm" :
44315 + BUFPRINT("\tbase addr range:%p<-->%p\n",
44316 + (void *)slot->phy_addr,
44317 + (void *)(slot->phy_addr +
44318 + (slot->page_num << PAGE_SHIFT)
44319 + - 1));
44320 + BUFPRINT("\tpage_num:%d\n", slot->page_num);
44321 + BUFPRINT("\talloced:%d,free:%d\n", slot->alloced_page_num,
44322 + slot->page_num - slot->alloced_page_num);
44323 + BUFPRINT("\tnext bit:%d\n", slot->next_bit);
44324 + BUFPRINT("\tsid:%x\n", slot->sid);
44325 + BUFPRINT("\troot:%d\n", slot->isroot);
44327 + for (i = 0; i < slot->pagemap_size; i++) {
44328 + int c = ((unsigned char *)slot->pagemap)[i];
44335 + while (i < slot->pagemap_size && i < 16)
44336 + BUFPRINT(":%02x", ((char *)slot->pagemap)[i++]);
44357 + fslot = smgt->slot_list_map[i];
44361 + total_pages += fslot->page_num;
44362 + alloced_pages += fslot->alloced_page_num;
44363 + if (!list_empty(&fslot->sid_list)) {
44364 + slot = list_entry(fslot->sid_list.next,
44369 + total_pages += slot->page_num;
44370 + alloced_pages += slot->alloced_page_num;
44371 + slot = list_entry(slot->sid_list.next,
44382 + total_pages - alloced_pages);
44410 + fslot = smgt->slot_list_map[i];
44413 + pages += fslot->page_num;
44414 + alloced += fslot->alloced_page_num;
44415 + if (!list_empty(&fslot->sid_list)) {
44416 + slot = list_entry(fslot->sid_list.next,
44420 + pages += slot->page_num;
44421 + alloced += slot->alloced_page_num;
44422 + slot = list_entry(slot->sid_list.next,
44432 + i, cnt, pages, pages - alloced);
44437 + total_pages, total_pages - alloced_pages);
44458 + if (!list_empty(&smgt->free_list)) {
44461 + header = &smgt->free_list;
44462 + list = header->prev;
44467 + total_pages += slot->page_num;
44468 + alloced_pages += slot->alloced_page_num;
44469 + list = list->prev;
44475 + total_pages - alloced_pages);
44508 + BUFPRINT("\tsize:%d\n", (int)(mms->page_cnt * PAGE_SIZE));
44509 + BUFPRINT("\tmax:%d\n", mms->page_max_cnt);
44510 + BUFPRINT("\tpage_cnt:%d\n", mms->page_cnt);
44511 + BUFPRINT("\tpage_used:%d\n", mms->page_used);
44512 + BUFPRINT("\tpage_tail:%d\n", mms->page_tail);
44513 + BUFPRINT("\tuser_cnt:%d\n", atomic_read(&mms->user_cnt));
44514 + BUFPRINT("\ttofree_jiffies:%ld\n", mms->tofree_jiffies);
44517 + while (i < mms->page_cnt && i < 16)
44518 + BUFPRINT(":%x", (u32) mms->pages_list[i++]);
44537 + if (list_empty(&smgt->scatter_list))
44539 + list_for_each_safe(pos, tmp, &smgt->scatter_list) {
44545 + if (smgt->cache_scs[0])
44546 + codec_mm_dump_scatter(smgt->cache_scs[0], 0, 0);
44547 + if (smgt->cache_scs[1])
44548 + codec_mm_dump_scatter(smgt->cache_scs[1], 0, 0);
44566 + smgt->keep_size_PAGE = g_scatter.keep_size_PAGE;
44567 + smgt->reserved_block_mm_M = g_scatter.reserved_block_mm_M;
44568 + smgt->try_alloc_in_cma_page_cnt = g_scatter.try_alloc_in_cma_page_cnt;
44569 + smgt->try_alloc_in_sys_page_cnt_max
44571 + smgt->try_alloc_in_sys_page_cnt_min
44573 + smgt->enable_slot_from_sys = g_scatter.enable_slot_from_sys;
44574 + smgt->support_from_slot_sys = g_scatter.support_from_slot_sys;
44575 + smgt->no_cache_size_M = g_scatter.no_cache_size_M;
44576 + smgt->no_alloc_from_sys = g_scatter.no_alloc_from_sys;
44584 + return smgt->total_page_num;
44599 + smgt->delay_free_on++;
44600 + smgt->delay_free_timeout_jiffies64 =
44603 + smgt->delay_free_on--;
44604 + if (smgt->delay_free_on <= 0) {
44605 + smgt->delay_free_on = 0;
44606 + smgt->delay_free_timeout_jiffies64 =
44612 + smgt->force_cache_on = 1;
44613 + smgt->force_cache_page_cnt = wait_size_M >> PAGE_SHIFT;
44614 + smgt->delay_free_timeout_jiffies64 =
44618 + while (smgt->total_page_num < smgt->force_cache_page_cnt) {
44619 + if (smgt->cache_scs[0] &&
44620 + (smgt->cached_pages >= 65000)) {
44624 + if (try_max-- <= 0 || time_after64(get_jiffies_64(),
44629 + &smgt->complete,
44636 + smgt->cached_pages,
44637 + (int)(get_jiffies_64() - start_time) * 1000/HZ);
44638 + smgt->force_cache_on = 0;
44639 + smgt->delay_free_timeout_jiffies64 =
44656 + int total_free_page = smgt->total_page_num -
44657 + smgt->alloced_page_num + smgt->cached_pages;
44659 + if (smgt->delay_free_on > 0 && smgt->keep_size_PAGE > 0) {
44661 + if (smgt->no_cache_size_M > 0 &&
44662 + (smgt->cached_pages <= smgt->keep_size_PAGE) &&
44663 + (smgt->total_page_num >=
44664 + (smgt->no_cache_size_M * (SZ_1M >> PAGE_SHIFT)))) {
44667 + if (smgt->force_cache_on) {
44668 + smgt->force_cache_on = 0;
44669 + smgt->delay_free_timeout_jiffies64 =
44672 + } else if ((smgt->cached_pages < smgt->keep_size_PAGE) ||
44673 + (smgt->force_cache_on &&/*on star cache*/
44674 + (smgt->total_page_num < smgt->force_cache_page_cnt))
44681 + if (smgt->force_cache_on) {
44683 + if ((smgt->total_page_num -
44684 + smgt->alloced_page_num) >
44687 + smgt->total_page_num -
44688 + smgt->alloced_page_num;
44691 + need = mms->page_cnt + once_alloc;
44692 + if ((need - mms->page_cnt) > once_alloc)
44693 + need = mms->page_cnt + once_alloc;
44694 + if (need > smgt->force_cache_page_cnt)
44695 + need = smgt->force_cache_page_cnt;
44696 + if (need > mms->page_max_cnt)
44697 + need = mms->page_max_cnt - 4;
44698 + if (need > mms->page_cnt) {
44716 + smgt->force_cache_on &&
44717 + (smgt->cached_pages >=
44718 + smgt->force_cache_page_cnt)) {
44719 + smgt->force_cache_on = 0;
44720 + smgt->delay_free_timeout_jiffies64 =
44723 + } else if ((smgt->cached_pages >
44724 + (smgt->keep_size_PAGE + 1000)) &&
44726 + smgt->delay_free_timeout_jiffies64)) {
44736 + } else if (smgt->delay_free_on <= 0 &&
44738 + smgt->delay_free_timeout_jiffies64)) {
44742 + if (smgt->keep_size_PAGE > 0 && smgt->delay_free_on) {
44743 + if (((smgt->force_cache_on ||
44744 + (total_free_page < smgt->keep_size_PAGE)) /*&&*/
44745 + /*!smgt->tvp_mode*/) &&
44748 + if (smgt->force_cache_on && !smgt->tvp_mode)
44754 + } else if (!smgt->delay_free_on && smgt->total_page_num > 0) {
44768 + if (smgt->delay_free_on > 0 && !smgt->cache_scs[0]) {
44773 + list_del_init(&mms->list);
44774 + smgt->cache_scs[0] = mms;
44781 + list_del_init(&mms->list);
44782 + smgt->cache_scs[1] = mms;
44786 + if (smgt->delay_free_on <= 0 && smgt->cache_scs[0] &&
44788 + smgt->delay_free_timeout_jiffies64)) {
44791 + mms0 = smgt->cache_scs[0];
44792 + mms1 = smgt->cache_scs[1];
44793 + smgt->cache_scs[0] = NULL;
44794 + smgt->cache_scs[1] = NULL;
44795 + smgt->cached_pages = 0;
44808 + if (list_empty(&smgt->scatter_list)) {
44812 + list_for_each_safe(pos, tmp, &smgt->scatter_list) {
44814 + if (atomic_read(&mms->user_cnt) == 0 &&
44815 + time_after(jiffies, mms->tofree_jiffies)) {
44817 + mms->tofree_jiffies <
44818 + first_free_mms->tofree_jiffies)
44824 + list_move_tail(&mms->list, &smgt->scatter_list);
44841 + list_for_each_safe(pos, tmp, &smgt->scatter_list) {
44843 + if (atomic_read(&mms->user_cnt) == 0) {
44845 + (mms->tofree_jiffies <
44846 + to_free_mms->tofree_jiffies))
44850 + if (!less_page_mms && mms->page_used < mms->page_cnt) {
44857 + (((to_free_mms_cnt > 1 || !smgt->delay_free_on) &&
44858 + time_after(jiffies, to_free_mms->tofree_jiffies)) ||
44861 + int cnt = atomic_sub_return(100000, &to_free_mms->user_cnt);
44863 + if (cnt != -100000) {
44864 + atomic_add(100000, &to_free_mms->user_cnt);
44867 + list_del_init(&to_free_mms->list);
44896 + mutex_lock(&smgt->monitor_lock);
44903 + smgt->delay_free_on = 0;
44905 + mms = smgt->cache_scs[0];
44906 + smgt->cache_scs[0] = smgt->cache_scs[1];
44907 + smgt->cache_scs[1] = NULL;
44908 + smgt->cached_pages = 0;
44912 + mms->page_max_cnt, mms->page_used);
44918 + } while (smgt->cache_scs[0] != NULL);
44926 + } while ((smgt->scatters_cnt > 0) && (retry_num++ < 1000));
44929 + if (need_retry || smgt->scatters_cnt > 0) {
44934 + if (smgt->total_page_num > 0) {
44939 + mutex_unlock(&smgt->monitor_lock);
44940 + return smgt->total_page_num;
44963 + mutex_lock(&smgt->monitor_lock);
44964 + smgt->scatter_task_run_num++;
44971 + else if (smgt->scatters_cnt > 0)
44974 + mutex_unlock(&smgt->monitor_lock);
44984 + return -1;
44987 + spin_lock_init(&smgt->list_lock);
44988 + smgt->tag = SMGT_IDENTIFY_TAG;
44989 + smgt->alloced_page_num = 0;
44990 + smgt->try_alloc_in_cma_page_cnt = (16 * 1024 * 1024) / PAGE_SIZE;
44991 + smgt->try_alloc_in_sys_page_cnt_max = MAX_SYS_BLOCK_PAGE;
44992 + smgt->try_alloc_in_sys_page_cnt = MAX_SYS_BLOCK_PAGE;
44993 + smgt->try_alloc_in_sys_page_cnt_min = MIN_SYS_BLOCK_PAGE;
44994 + smgt->reserved_block_mm_M = 300;
44995 + smgt->keep_size_PAGE = 20 * SZ_1M >> PAGE_SHIFT;
44996 + smgt->alloc_from_cma_first = 1;
44997 + smgt->enable_slot_from_sys = 0;
44998 + smgt->support_from_slot_sys =
44999 + smgt->enable_slot_from_sys;
45000 + smgt->mem_flags = CODEC_MM_FLAGS_CMA_FIRST |
45006 + smgt->no_cache_size_M = 100;
45008 + smgt->no_cache_size_M = 0;
45009 + init_completion(&smgt->complete);
45010 + INIT_LIST_HEAD(&smgt->free_list);
45011 + INIT_LIST_HEAD(&smgt->scatter_list);
45012 + mutex_init(&smgt->monitor_lock);
45014 + INIT_DELAYED_WORK(&smgt->dealy_work,
45043 + scatter_tvp_mgt->tvp_mode = 1;
45044 + scatter_tvp_mgt->mem_flags |= CODEC_MM_FLAGS_TVP;
45046 + g_scatter.keep_size_PAGE = smgt->keep_size_PAGE;
45047 + g_scatter.reserved_block_mm_M = smgt->reserved_block_mm_M;
45048 + g_scatter.try_alloc_in_cma_page_cnt = smgt->try_alloc_in_cma_page_cnt;
45050 + = smgt->try_alloc_in_sys_page_cnt_max;
45052 + = smgt->try_alloc_in_sys_page_cnt_min;
45053 + g_scatter.enable_slot_from_sys = smgt->enable_slot_from_sys;
45054 + g_scatter.support_from_slot_sys = smgt->support_from_slot_sys;
45055 + g_scatter.no_cache_size_M = smgt->no_cache_size_M;
45111 + codec_mm_scatter_alloc_want_pages(sc[2], 44); /* 44-->//48 */
45160 + (struct codec_mm_scatter_mgt *)sc[p1]->manager,
45179 + (struct codec_mm_scatter_mgt *)sc[p1]->manager,
45207 diff -Naur a/vendor/amlogic/media/common/codec_mm/codec_mm_scatter_priv.h b/vendor/amlogic/media/co…
45208 --- a/vendor/amlogic/media/common/codec_mm/codec_mm_scatter_priv.h 1970-01-01 08:00:00.000000000 +0…
45209 +++ b/vendor/amlogic/media/common/codec_mm/codec_mm_scatter_priv.h 2022-06-24 14:37:50.231810166 +0…
45210 @@ -0,0 +1,72 @@
45283 diff -Naur a/vendor/amlogic/media/common/codec_mm/configs/configs.c b/vendor/amlogic/media/common/c…
45284 --- a/vendor/amlogic/media/common/codec_mm/configs/configs.c 1970-01-01 08:00:00.000000000 +0800
45285 +++ b/vendor/amlogic/media/common/codec_mm/configs/configs.c 2022-06-24 14:37:50.263538733 +0800
45286 @@ -0,0 +1,1099 @@
45320 + return atomic_inc_return(&node->ref_cnt);
45326 + return atomic_dec_return(&node->ref_cnt);
45337 + pnode = node->parent_node;
45342 + pnode = pnode->parent_node;
45362 + node_size = str - root_str;
45367 + node_size = str - root_str;
45372 + if (node_size >= MAX_ITEM_NAME - 1)
45373 + node_size = MAX_ITEM_NAME - 1;
45414 + if (pstr[0] == '-') {
45415 + ret = sscanf(pstr, "-%d", val);
45416 + *val = -((int)*val);
45439 + if (pstr[0] == '-') {
45440 + ret = sscanf(pstr, "-%lld", val);
45441 + *val = -((int)*val);
45492 + mutex_lock(&rootnode->lock);
45493 + if (list_empty(&rootnode->son_node_list)) {
45494 + mutex_unlock(&rootnode->lock);
45497 + list_for_each_safe(node_list, next, &rootnode->son_node_list) {
45499 + if (!strcmp(snode->name, node_name)) {
45501 + if (snode->active <= 0 ||
45507 + mutex_unlock(&rootnode->lock);
45514 + node->configs = NULL;
45515 + node->configs_num = 0;
45516 + node->son_node_num = 0;
45517 + node->name = name;
45518 + node->rw_flags = rw_flags;
45519 + node->depth = 0;
45520 + node->active = 1;
45521 + node->prefix[0] = '\0';
45522 + atomic_set(&node->ref_cnt, 0);
45523 + mutex_init(&node->lock);
45524 + INIT_LIST_HEAD(&node->list);
45525 + INIT_LIST_HEAD(&node->son_node_list);
45537 + if (parent->depth >= MAX_DEPTH)
45538 + return -1; /*too deep path */
45539 + if (strlen(parent->prefix) + strlen(parent->name) >=
45540 + MAX_PREFIX_NAME - 2) {
45542 + parent->prefix, parent->name,
45543 + (int)(strlen(parent->prefix) + strlen(parent->name) + 1),
45544 + MAX_PREFIX_NAME - 1);
45545 + return -2; /*unsuport deep path */
45547 + if (configs_get_node_with_name(parent, new_node->name) != NULL) {
45549 + new_node->name, parent->name);
45550 + return -3;
45558 + new_node->depth = parent->depth + 1;
45559 + if (new_node->depth >= 2) {
45560 + if (parent->prefix[0]) {
45561 + strcpy(new_node->prefix, parent->prefix);
45562 + strcat(new_node->prefix, ".");
45564 + strcat(new_node->prefix, parent->name);
45566 + mutex_lock(&parent->lock);
45567 + new_node->parent_node = parent;
45568 + list_add_tail(&new_node->list, &parent->son_node_list);
45574 + new_node->rw_flags = parent->rw_flags & new_node->rw_flags;
45575 + parent->son_node_num++;
45576 + new_node->active = 1;
45577 + mutex_unlock(&parent->lock);
45607 + if (!strcmp(node->name, sub_node_name)) {
45618 + sub_node_name, parent_node->name, path);
45621 + next_path = next_path + i + 1; /*media.vdec --> vdec */
45623 + node->name, parent_node->name, end);
45638 + return -1;
45650 + return -1;
45651 + if (node->configs != NULL || node->configs_num > 0) {
45652 + pr_err("node[%s] register config before!.\n", node->name);
45653 + return -2;
45659 + pr_info("init node:%s, config[i].data %lx-%lx\n",
45660 + node->name,
45665 + mutex_lock(&node->lock);
45666 + node->configs = configs;
45667 + node->configs_num = num;
45668 + mutex_unlock(&node->lock);
45682 + return -1;
45687 + return -1;
45696 + parent_node = node->parent_node;
45697 + node->active = 0;
45699 + if (atomic_read(&node->ref_cnt) != 0)
45700 + return -1;
45702 + node->configs = NULL;
45703 + node->configs_num = 0;
45705 + if (node->son_node_num > 0)
45706 + return -2;
45708 + mutex_lock(&parent->lock);
45709 + list_del(&node->list);
45710 + parent->son_node_num--;
45711 + mutex_unlock(&parent->lock);
45722 + mutex_lock(&node->lock);
45723 + for (i = 0; i < node->configs_num; i++) {
45724 + struct mconfig *val = &node->configs[i];
45726 + if (val && !strcmp(val->item_name, name)) {
45732 + mutex_unlock(&node->lock);
45733 + config_debug("get config[%s] from %s-end-%p\n",
45734 + name, node->name, (void *)config);
45745 + switch (config->type) {
45748 + config->pboolval[0] ? "true" : "false");
45751 + ret = snprintf(buf, size, "%u", config->pival[0]);
45754 + ret = snprintf(buf, size, "%d", config->pu32val[0]);
45757 + ret = snprintf(buf, size, "%llx", config->pu64val[0]);
45761 + ret = snprintf(buf, size, "%s", config->str);
45765 + config->pboolval ? "true" : "false");
45768 + ret = snprintf(buf, size, "%d", config->ival);
45771 + ret = snprintf(buf, size, "%u", config->u32val);
45774 + ret = snprintf(buf, size, "0x%llx", config->u64val);
45777 + if (!config->f_get)
45780 + ret = config->f_get(config->item_name,
45781 + config->id, buf, size);
45784 + ret = -4;
45787 + pr_err("config2str error %s-type:%d,%lx-%lx,ret=%d\n",
45788 + config->item_name, config->type,
45789 + config->ldata[0], config->ldata[1], ret);
45791 + buf[size - 1] = '\0';
45792 + ret = size - 1;
45807 + switch (config->type) {
45813 + if (config->type == CONFIG_TYPE_PBOOL)
45814 + config->pboolval[0] = bval;
45816 + config->boolval = bval;
45822 + config->pu32val[0] = val;
45827 + config->pu64val[0] = val64;
45830 + strncpy(config->str, str, config->size);
45831 + ret = strlen(config->str);
45837 + config->u32val = val;
45842 + config->u64val = val64;
45845 + if (!config->f_set)
45846 + ret = -1;
45848 + ret = config->f_set(config->item_name,
45849 + config->id,
45854 + ret = -4;
45870 + if (node->prefix[0]) {
45872 + node->prefix);
45880 + if (buf[0] && buf[strlen(buf) - 1] != '.')
45896 + if (!buf || size < 8 || !node->configs)
45900 + for (i = 0; i < node->configs_num && (size - pn_size) > 8; i++) {
45901 + config = &node->configs[i];
45903 + size - pn_size,
45906 + node->name,
45907 + config->item_name,
45908 + (node->rw_flags & CONFIG_FOR_R) ? "=" : "");
45913 + !(CONFIG_FOR_T & node->rw_flags)) &&
45914 + (node->rw_flags & CONFIG_FOR_R)) {
45916 + buf + pn_size, size - pn_size);
45932 + ret = snprintf(buf + pn_size, size - pn_size, "\n");
45946 + mutex_lock(&node->lock);
45949 + mutex_unlock(&node->lock);
45965 + if (!(node->rw_flags & mode))
45967 + config_debug("start dump node %s...\n", node->name);
45973 + mutex_lock(&node->lock);
45975 + ret = snprintf(buf + pn_size, size - pn_size,
45978 + node->name,
45979 + rw[(node->rw_flags & 3)],
45980 + atomic_read(&node->ref_cnt),
45981 + node->configs_num,
45982 + node->depth);
45988 + size - pn_size, c_prefix, mode);
45992 + if ((mode & LIST_MODE_SUB_NODES) && node->son_node_num > 0) {
45997 + if (node->depth > 0) {/*not root.*/
45998 + strncat(cprefix, node->name,
45999 + MAX_PREFIX_NAME + MAX_ITEM_NAME - 1);
46002 + list_for_each_safe(node_list, next, &node->son_node_list) {
46007 + buf + pn_size, size - pn_size,
46014 + mutex_unlock(&node->lock);
46056 + return -EIO;
46067 + return -1;
46077 + err = -EPERM;
46082 + sub_node_name, parent_node->name, path);
46083 + err = -ENOENT;
46086 + next_path = next_path + i + 1; /*media.vdec --> vdec */
46088 + node->name, parent_node->name, end);
46091 + if (set && !(node->rw_flags & CONFIG_FOR_W)) {
46092 + err = -ENOENT;
46095 + if (!set && !(node->rw_flags & CONFIG_FOR_R)) {
46096 + err = -EPERM;
46102 + err = -EPERM;
46110 + node->name, sub_node_name);
46113 + sub_node_name, root_node->name);
46130 + dst = config->buf_ptr;
46134 + src = config->buf_ptr;
46137 + return -1;
46138 + switch (config->type) {
46142 + return -2;
46148 + return -2;
46154 + ret = -3;
46159 + s = min_t(int, size - 1, config->size - 1);
46163 + ret = -3;
46171 + return -2;
46173 + config->u32val = ((const u32 *)src)[0];
46175 + ((u32 *) dst)[0] = config->u32val;
46180 + return -2;
46182 + config->u64val = ((const u64 *)src)[0];
46184 + ((u64 *) dst)[0] = config->u64val;
46188 + ret = -4;
46208 + config->item_name, *(int *)val_set);
46212 + config->item_name, ret);
46223 + int ret = -1;
46226 + return -1;
46231 + config->item_name, val);
46232 + mutex_lock(&node->lock);
46234 + mutex_unlock(&node->lock);
46240 + ret = -1;/*val not changed.*/
46250 + if (strncmp(topnode->name, path, strlen(topnode->name))) {
46252 + path, topnode->name);
46253 + return -1;
46256 + path + strlen(topnode->name) + 1, val);
46269 + return -1;
46295 + return -1;
46309 + int ret = -1;
46312 + return -1;
46318 + config->item_name);
46329 + if (strncmp(topnode->name, path, strlen(topnode->name))) {
46331 + path, topnode->name);
46332 + return -1;
46335 + path + strlen(topnode->name) + 1,
46386 diff -Naur a/vendor/amlogic/media/common/codec_mm/configs/configs_module.c b/vendor/amlogic/media/c…
46387 --- a/vendor/amlogic/media/common/codec_mm/configs/configs_module.c 1970-01-01 08:00:00.000000000 +…
46388 +++ b/vendor/amlogic/media/common/codec_mm/configs/configs_module.c 2022-06-24 14:37:50.290802131 +…
46389 @@ -0,0 +1,493 @@
46425 +#define MODULE_NAME "media-configs-dev"
46449 + return -EPERM;
46461 + return -EPERM;
46473 + return -EPERM;
46484 + return -EPERM;
46495 + return -EPERM;
46506 + return -EPERM;
46519 + return -EPERM;
46530 + return -EPERM;
46542 + return -EPERM;
46580 + return -EPERM;
46591 + return -EPERM;
46626 + .name = "media-configs",
46663 + if (atomic_read(&node->opened_cnt) > MAX_OPENED_CNT) {
46665 + return -EMFILE;
46669 + return -ENOMEM;
46670 + file->private_data = priv;
46671 + priv->pid = current->pid;
46672 + priv->tgid = current->tgid;
46673 + priv->opened_jiffies = jiffies;
46674 + priv->node = node;
46675 + atomic_inc(&node->opened_cnt);
46676 + configs_inc_node_ref(&node->node);
46682 + struct config_file_private *priv = file->private_data;
46683 + struct mediaconfig_node *node = priv->node;
46689 + return -EIO;
46690 + ret = configs_list_nodes(&node->node, buf, count,
46699 + struct config_file_private *priv = file->private_data;
46700 + struct mediaconfig_node *node = priv->node;
46702 + configs_dec_node_ref(&node->node);
46703 + atomic_dec(&node->opened_cnt);
46711 + struct config_file_private *priv = file->private_data;
46712 + struct mediaconfig_node *node = priv->node;
46715 + int r = -1;
46717 + priv->last_access_jiffies = jiffies;
46720 + priv->access_set_cnt++;
46722 + user_io->cmd_path, sizeof(io.cmd_path));
46723 + r |= copy_from_user(io.val, user_io->val, sizeof(io.val));
46725 + /*io.val, node->dev_name);*/
46727 + r = -EIO;
46730 + if (!strncmp(io.cmd_path, node->dev_name,
46731 + strlen(node->dev_name)))
46737 + io.cmd_path, io.val, node->dev_name);
46740 + r = -1;
46741 + priv->access_get_cnt++;
46743 + user_io->cmd_path, sizeof(io.cmd_path));
46744 + io.cmd_path[sizeof(io.cmd_path) - 1] = '\0';
46746 + r = -EIO;
46750 + if (!strncmp(io.cmd_path, node->dev_name,
46751 + strlen(node->dev_name))) {
46759 + if (r > 0 && r <= sizeof(io.val) - 1) {
46761 + if (copy_to_user(user_io->val, io.val, r + 1) != 0) {
46762 + r = -EIO;
46765 + put_user(r, &user_io->ret);
46768 + put_user(-1, &user_io->ret);
46772 + io.cmd_path, io.val, node->dev_name);
46775 + r = -EINVAL;
46779 + priv->error_cnt++;
46829 + mnode->class_dev = device_create(config_dev_class, NULL,
46831 + mnode->dev_name);
46832 + if (mnode->class_dev == NULL) {
46833 + pr_err("device_create %s failed\n", mnode->dev_name);
46834 + r = -1;
46864 + configs_init_new_node(&mnode->node, mnode->name,
46865 + mnode->rw_flags);
46866 + r = configs_register_path_node(mnode->parent,
46867 + &mnode->node);
46870 + mnode->name, mnode->parent);
46883 diff -Naur a/vendor/amlogic/media/common/codec_mm/configs/configs_priv.h b/vendor/amlogic/media/com…
46884 --- a/vendor/amlogic/media/common/codec_mm/configs/configs_priv.h 1970-01-01 08:00:00.000000000 +08…
46885 +++ b/vendor/amlogic/media/common/codec_mm/configs/configs_priv.h 2022-06-24 14:37:50.333210579 +08…
46886 @@ -0,0 +1,34 @@
46921 diff -Naur a/vendor/amlogic/media/common/codec_mm/configs/configs_test.c b/vendor/amlogic/media/com…
46922 --- a/vendor/amlogic/media/common/codec_mm/configs/configs_test.c 1970-01-01 08:00:00.000000000 +08…
46923 +++ b/vendor/amlogic/media/common/codec_mm/configs/configs_test.c 2022-06-24 14:37:50.357835024 +08…
46924 @@ -0,0 +1,145 @@
46998 + pr_err("trigger-->[%s]\n", buf);
47064 + pr_info("-----------start configs_config_setstr\n\n");
47066 + pr_info("-----------end configs_config_setstr\n\n");
47070 diff -Naur a/vendor/amlogic/media/common/codec_mm/Kconfig b/vendor/amlogic/media/common/codec_mm/Kc…
47071 --- a/vendor/amlogic/media/common/codec_mm/Kconfig 1970-01-01 08:00:00.000000000 +0800
47072 +++ b/vendor/amlogic/media/common/codec_mm/Kconfig 2022-05-31 11:56:47.717259467 +0800
47073 @@ -0,0 +1,9 @@
47083 diff -Naur a/vendor/amlogic/media/common/codec_mm/Makefile b/vendor/amlogic/media/common/codec_mm/M…
47084 --- a/vendor/amlogic/media/common/codec_mm/Makefile 1970-01-01 08:00:00.000000000 +0800
47085 +++ b/vendor/amlogic/media/common/codec_mm/Makefile 2022-05-31 11:56:47.717259467 +0800
47086 @@ -0,0 +1,16 @@
47096 +obj-y = codec_mm.o \
47103 diff -Naur a/vendor/amlogic/media/common/codec_mm/secmem.c b/vendor/amlogic/media/common/codec_mm/s…
47104 --- a/vendor/amlogic/media/common/codec_mm/secmem.c 1970-01-01 08:00:00.000000000 +0800
47105 +++ b/vendor/amlogic/media/common/codec_mm/secmem.c 2022-06-24 14:37:50.412958613 +0800
47106 @@ -0,0 +1,472 @@
47131 +#include <linux/dma-buf.h>
47168 + struct secmem_block *info = dbuf->priv;
47171 + phys_addr_t phys = info->paddr;
47178 + return -ENOMEM;
47181 + sgt = &attach->sgt;
47185 + return -ENOMEM;
47189 + sg_set_page(sgt->sgl, page, PAGE_ALIGN(info->size), 0);
47191 + attach->dma_dir = DMA_NONE;
47192 + attachment->priv = attach;
47200 + struct ksecmem_attachment *attach = attachment->priv;
47207 + sgt = &attach->sgt;
47209 +// if (attach->dma_dir != DMA_NONE)
47210 +// dma_unmap_sg(attachment->dev, sgt->sgl, sgt->orig_nents,
47211 +// attach->dma_dir);
47214 + attachment->priv = NULL;
47221 + struct ksecmem_attachment *attach = attachment->priv;
47222 + struct secmem_block *info = attachment->dmabuf->priv;
47223 + struct mutex *lock = &attachment->dmabuf->lock;
47228 + sgt = &attach->sgt;
47229 + if (attach->dma_dir == dma_dir) {
47234 + sgt->sgl->dma_address = info->paddr;
47236 + sgt->sgl->dma_length = PAGE_ALIGN(info->size);
47238 + sgt->sgl->length = PAGE_ALIGN(info->size);
47240 + pr_dbg("nents %d, %x, %d, %d\n", sgt->nents, info->paddr,
47241 + sg_dma_len(sgt->sgl), info->size);
47242 + attach->dma_dir = dma_dir;
47261 + info = (struct secmem_block *)dbuf->priv;
47262 + pr_dbg("handle:%x\n", info->handle);
47281 + return -EINVAL;
47302 + info->handle, info->paddr, info->size);
47304 + exp_info.size = info->size;
47352 + return -EFAULT;
47358 + long res = -EFAULT;
47374 + info = dbuf->priv;
47375 + res = (long) (info->handle & (0xffffffff));
47385 + long res = -EFAULT;
47401 + info = dbuf->priv;
47402 + res = (long) (info->paddr & (0xffffffff));
47412 + long res = -EFAULT;
47442 + paddr = sg_dma_address(sgt->sgl);
47483 + long ret = -EINVAL;
47579 diff -Naur a/vendor/amlogic/media/common/codec_mm/secmem.h b/vendor/amlogic/media/common/codec_mm/s…
47580 --- a/vendor/amlogic/media/common/codec_mm/secmem.h 1970-01-01 08:00:00.000000000 +0800
47581 +++ b/vendor/amlogic/media/common/codec_mm/secmem.h 2022-06-24 14:37:50.430184564 +0800
47582 @@ -0,0 +1,37 @@
47620 diff -Naur a/vendor/amlogic/media/common/Makefile b/vendor/amlogic/media/common/Makefile
47621 --- a/vendor/amlogic/media/common/Makefile 1970-01-01 08:00:00.000000000 +0800
47622 +++ b/vendor/amlogic/media/common/Makefile 2022-05-31 11:56:47.717259467 +0800
47623 @@ -0,0 +1,6 @@
47629 +obj-$(CONFIG_AMLOGIC_MEDIA_CODEC_MM) += codec_mm/
47630 diff -Naur a/vendor/amlogic/media/Kconfig b/vendor/amlogic/media/Kconfig
47631 --- a/vendor/amlogic/media/Kconfig 1970-01-01 08:00:00.000000000 +0800
47632 +++ b/vendor/amlogic/media/Kconfig 2022-06-06 09:14:48.455282131 +0800
47633 @@ -0,0 +1,10 @@
47644 diff -Naur a/vendor/amlogic/media/Makefile b/vendor/amlogic/media/Makefile
47645 --- a/vendor/amlogic/media/Makefile 1970-01-01 08:00:00.000000000 +0800
47646 +++ b/vendor/amlogic/media/Makefile 2022-05-31 11:56:47.717259467 +0800
47647 @@ -0,0 +1,6 @@
47653 +obj-y += common/
47654 diff -Naur a/vendor/amlogic/mmc/emmc_key.c b/vendor/amlogic/mmc/emmc_key.c
47655 --- a/vendor/amlogic/mmc/emmc_key.c 1970-01-01 08:00:00.000000000 +0800
47656 +++ b/vendor/amlogic/mmc/emmc_key.c 2022-06-24 14:47:38.325086185 +0800
47657 @@ -0,0 +1,522 @@
47658 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
47678 +#define stamp_after(a, b) ((int)(b) - (int)(a) < 0)
47699 + int bit = card->csd.read_blkbits;
47703 + + (valid_flag - 1) * EMMC_KEYAREA_SIZE;
47708 + mmc_claim_host(card->host);
47717 + cnt -= EMMC_BLOCK_SIZE;
47721 + mmc_release_host(card->host);
47747 + int bit = card->csd.read_blkbits;
47752 + return -1;
47759 + memcpy(checksum_info, &key_infos[valid_flag - 1], sizeof(struct aml_key_info));
47760 + mmc_claim_host(card->host);
47769 + cnt -= EMMC_BLOCK_SIZE;
47780 + mmc_release_host(card->host);
47806 + mmc->key_stamp = key_infos[0].stamp;
47816 + int bit = mmc->csd.read_blkbits;
47823 + return -1;
47825 + mmc_claim_host(mmc->host);
47827 + mmc_release_host(mmc->host);
47847 + return -1;
47869 + mmc_claim_host(mmc->host);
47874 + ret = -EFAULT;
47878 + cnt -= MAX_TRANS_BLK;
47881 + mmc_release_host(mmc->host);
47889 + int bit = mmc->csd.read_blkbits;
47909 + cpy--;
47913 + mmc->key_stamp = key_infos[0].stamp;
47915 + mmc->key_stamp = key_infos[1].stamp;
47929 + return -ENOMEM;
47964 + index = cpy - 1;
47965 + key_infos[index].stamp = card->key_stamp + 1;
47993 + int bit = card->csd.read_blkbits;
48000 + mmc_claim_host(card->host);
48009 + cnt -= EMMC_BLOCK_SIZE;
48013 + mmc_release_host(card->host);
48025 + emmckey_info->key_part_count =
48026 + emmckey_info->keyarea_phy_size / EMMC_KEYAREA_SIZE;
48028 + if (emmckey_info->key_part_count
48030 + emmckey_info->key_part_count = EMMC_KEYAREA_COUNT;
48041 + return -ENOMEM;
48043 + emmckey_valid_node->phy_addr = emmckey_info->keyarea_phy_addr
48045 + emmckey_valid_node->phy_size = EMMC_KEYAREA_SIZE;
48046 + emmckey_valid_node->next = NULL;
48047 + emmckey_info->key_valid = 0;
48048 + if (!emmckey_info->key_valid_node) {
48049 + emmckey_info->key_valid_node = emmckey_valid_node;
48052 + temp_valid_node = emmckey_info->key_valid_node;
48054 + while (temp_valid_node->next)
48055 + temp_valid_node = temp_valid_node->next;
48057 + temp_valid_node->next = emmckey_valid_node;
48059 + } while (++keypart_cnt < emmckey_info->key_part_count);
48061 + emmckey_info->key_valid = 1;
48074 + int bit = card->csd.read_blkbits;
48082 + mmc_claim_host(card->host);
48092 + cnt -= EMMC_BLOCK_SIZE;
48098 + mmc_release_host(card->host);
48109 + int bit = card->csd.read_blkbits;
48117 + return -ENOMEM;
48121 + err = -ENOMEM;
48125 + emmckey_info->key_init = 0;
48132 + err = -EINVAL;
48138 + emmckey_info->key_init = 1;
48143 + if (!emmckey_info->key_init) {
48144 + err = -EINVAL;
48149 + emmckey_info->keyarea_phy_addr = addr;
48150 + emmckey_info->keyarea_phy_size = size;
48151 + emmckey_info->lba_start = lba_start;
48152 + emmckey_info->lba_end = lba_end;
48163 + uk_type->storage_type = UNIFYKEY_STORAGE_TYPE_EMMC;
48164 + uk_type->ops = &ops;
48165 + uk_type->ops->read = emmc_key_read;
48166 + uk_type->ops->write = emmc_key_write;
48169 + err = -EINVAL;
48180 diff -Naur a/vendor/amlogic/mmc/emmc_key.h b/vendor/amlogic/mmc/emmc_key.h
48181 --- a/vendor/amlogic/mmc/emmc_key.h 1970-01-01 08:00:00.000000000 +0800
48182 +++ b/vendor/amlogic/mmc/emmc_key.h 2022-05-31 11:56:47.717259467 +0800
48183 @@ -0,0 +1,68 @@
48184 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
48234 + (EMMC_KEYAREA_SIZE - EMMC_KEY_AREA_SIGNAL_LEN - 4 - 4 - 4)
48252 diff -Naur a/vendor/amlogic/mmc/emmc_partitions.c b/vendor/amlogic/mmc/emmc_partitions.c
48253 --- a/vendor/amlogic/mmc/emmc_partitions.c 1970-01-01 08:00:00.000000000 +0800
48254 +++ b/vendor/amlogic/mmc/emmc_partitions.c 2022-06-24 14:48:21.048601295 +0800
48255 @@ -0,0 +1,1230 @@
48256 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
48296 +#define stamp_after(a, b) ((int)(b) - (int)(a) < 0)
48301 + u8 data[DTB_BLK_SIZE * DTB_BLK_CNT - 4 * sizeof(unsigned int)];
48347 + int size = sizeof(struct aml_dtb_rsv) - sizeof(unsigned int);
48364 + pr_info("calc %x, store %x\n", checksum, dtb->checksum);
48366 + return !(checksum == dtb->checksum);
48373 + int bit = mmc->csd.read_blkbits;
48378 + mmc_claim_host(mmc->host);
48383 + ret = -EFAULT;
48387 + cnt -= MAX_TRANS_BLK;
48390 + mmc_release_host(mmc->host);
48399 + int bit = mmc->csd.read_blkbits;
48403 + mmc_claim_host(mmc->host);
48408 + ret = -EFAULT;
48412 + cnt -= MAX_TRANS_BLK;
48415 + mmc_release_host(mmc->host);
48425 + int bit = mmc->csd.read_blkbits;
48431 + return -ENOMEM;
48445 + info->stamp[cpy] = dtb->timestamp;
48446 + info->valid[cpy] = 1;
48451 + valid += info->valid[cpy];
48452 + cpy--;
48462 + int bit = mmc->csd.read_blkbits;
48469 + return -EFAULT;
48472 + valid = info->valid[0] + info->valid[1];
48474 + dtb->timestamp = 0;
48476 + dtb->timestamp = 1 + info->stamp[info->valid[0] ? 0 : 1];
48479 + if (info->stamp[0] != info->stamp[1]) {
48481 + info->stamp[0], info->stamp[1]);
48482 + dtb->timestamp = 1 +
48483 + (stamp_after(info->stamp[1], info->stamp[0]) ?
48484 + info->stamp[1] : info->stamp[0]);
48486 + dtb->timestamp = 1 + info->stamp[0];
48490 + dtb->version = 1; /* base version */
48491 + dtb->magic = 0x00447e41; /*A~D\0*/
48492 + dtb->checksum = _calc_dtb_checksum(dtb);
48494 + dtb->timestamp, dtb->checksum,
48495 + dtb->version, (char *)&dtb->magic);
48510 + int bit = card->csd.read_blkbits;
48516 + return -EFAULT;
48523 + return -ENOMEM;
48535 + ret = -EFAULT;
48540 + blk_cnt -= (DTB_CELL_SIZE >> bit);
48566 + return -EFAULT;
48571 + return -ENOMEM;
48573 + mmc_claim_host(card_dtb->host);
48578 + ret = -EFAULT;
48582 + read_size = CONFIG_DTB_SIZE - *ppos;
48589 + mmc_release_host(card_dtb->host);
48604 + return -EFAULT;
48609 + return -ENOMEM;
48611 + mmc_claim_host(card_dtb->host);
48614 + write_size = CONFIG_DTB_SIZE - *ppos;
48624 + ret = -EFAULT;
48630 + mmc_release_host(card_dtb->host);
48658 + ret = -1;
48667 + ret = -1;
48674 + ret = -1;
48681 + ret = -1;
48689 + ret = -1;
48715 + WARN_ON(!mrq || !mrq->cmd || !mrq->data);
48719 + if (!ret && mrq->cmd->error)
48720 + ret = mrq->cmd->error;
48721 + if (!ret && mrq->data->error)
48722 + ret = mrq->data->error;
48723 + if (!ret && mrq->stop && mrq->stop->error)
48724 + ret = mrq->stop->error;
48725 + if (!ret && mrq->data->bytes_xfered !=
48726 + mrq->data->blocks * mrq->data->blksz)
48729 + if (ret == -EINVAL)
48741 + WARN_ON(!mrq || !mrq->cmd || !mrq->data || !mrq->stop);
48744 + mrq->cmd->opcode = write ?
48747 + mrq->cmd->opcode = write ?
48751 + mrq->cmd->arg = dev_addr;
48753 + mrq->cmd->arg <<= 9;
48755 + mrq->cmd->flags = MMC_RSP_R1 | MMC_CMD_ADTC;
48758 + mrq->stop = NULL;
48760 + mrq->stop->opcode = MMC_STOP_TRANSMISSION;
48761 + mrq->stop->arg = 0;
48762 + mrq->stop->flags = MMC_RSP_R1B | MMC_CMD_AC;
48765 + mrq->data->blksz = blksz;
48766 + mrq->data->blocks = blocks;
48767 + mrq->data->flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
48768 + mrq->data->sg = sg;
48769 + mrq->data->sg_len = sg_len;
48771 + mmc_set_data_timeout(mrq->data, card);
48777 + return card->ext_csd.sectors;
48779 + return card->csd.capacity << (card->csd.read_blkbits - 9);
48797 + cur_part_number = card->ext_csd.part_config
48801 + original_part_config = card->ext_csd.part_config;
48806 + card->ext_csd.part_time);
48810 + card->ext_csd.part_config = cur_part_number;
48815 + ret = -1;
48819 + size = blocks << card->csd.read_blkbits;
48827 + blocks, 1 << card->csd.read_blkbits, write);
48829 + mmc_wait_for_req(card->host, &mrq);
48835 + card->ext_csd.part_time);
48838 + card->ext_csd.part_config = original_part_config;
48849 + struct mmc_host *mmc = card->host;
48851 + struct aml_tuning_para *parameter = &host->para;
48856 + if (host->save_para == 0)
48859 + if (parameter->update == 0)
48861 + parameter->update = 0;
48864 + blocks = (para_size - 1) / 512 + 1;
48865 + size = blocks << card->csd.read_blkbits;
48872 + mmc_claim_host(card->host);
48874 + mmc_release_host(card->host);
48902 + j > 0; j--) {
48913 + int off = -1;
48924 + for (i = 0; i < pt_fmt->part_num; i++) {
48925 + if (!strcmp(pt_fmt->partitions[i].name, MMC_RESERVED_NAME))
48926 + return pt_fmt->partitions[i].offset;
48928 + return -1;
48935 + int bit = card->csd.read_blkbits;
48942 + ret = -ENOMEM;
48949 + ret = -EINVAL;
48963 + size -= blk_cnt << bit;
48973 + /* pt_fmt->magic, pt_fmt->version, pt_fmt->checksum); */
48974 + /* show_mmc_patition(pt_fmt->partitions, pt_fmt->part_num); */
48976 + if ((strncmp(pt_fmt->magic, MMC_PARTITIONS_MAGIC,
48977 + sizeof(pt_fmt->magic)) == 0) && pt_fmt->part_num > 0 &&
48978 + pt_fmt->part_num <= MAX_MMC_PART_NUM &&
48979 + pt_fmt->checksum == mmc_partition_tbl_checksum_calc
48980 + (pt_fmt->partitions, pt_fmt->part_num)) {
48984 + if (strncmp(pt_fmt->magic, MMC_PARTITIONS_MAGIC,
48985 + sizeof(pt_fmt->magic)) != 0) {
48986 + pr_info("magic error: %s\n", pt_fmt->magic);
48987 + } else if ((pt_fmt->part_num < 0) ||
48988 + (pt_fmt->part_num > MAX_MMC_PART_NUM)) {
48990 + pt_fmt->part_num);
48992 + pr_info("checksum error: pt_fmt->checksum=%d,calc_result=%d\n",
48993 + pt_fmt->checksum,
48995 + (pt_fmt->partitions, pt_fmt->part_num));
48999 + ret = -1; /* the partition information is invalid */
49029 + switch (disk->queue->limits.zoned) {
49032 + disk->disk_name);
49033 + return ERR_PTR(-ENXIO);
49036 + disk->disk_name);
49037 + disk->queue->limits.zoned = BLK_ZONED_NONE;
49046 + ptbl = rcu_dereference_protected(disk->part_tbl, 1);
49048 + if (ptbl->part[partno])
49049 + return ERR_PTR(-EBUSY);
49053 + return ERR_PTR(-EBUSY);
49055 + p->dkstats = alloc_percpu(struct disk_stats);
49056 + if (!p->dkstats) {
49057 + err = -ENOMEM;
49063 + p->start_sect = start;
49064 + p->nr_sects = len;
49065 + p->partno = partno;
49066 + p->policy = get_disk_ro(disk);
49068 + pinfo = kzalloc_node(sizeof(*pinfo), GFP_KERNEL, disk->node_id);
49069 + p->info = pinfo;
49070 + sprintf(p->info->volname, "%s", pname);
49076 + pdev->class = &block_class;
49077 + pdev->type = &part_type;
49078 + pdev->parent = ddev;
49083 + pdev->devt = devt;
49091 + err = -ENOMEM;
49092 + p->holder_dir = kobject_create_and_add("holders", &pdev->kobj);
49093 + if (!p->holder_dir)
49099 + rcu_assign_pointer(ptbl->part[partno], p);
49103 + kobject_uevent(&pdev->kobj, KOBJ_ADD);
49109 + kfree(p->info);
49114 + kobject_put(p->holder_dir);
49124 + struct partitions *this = &(pt_fmt->partitions[i]);
49126 + if (i >= pt_fmt->part_num)
49130 + i + 1, (unsigned long long)this->size,
49131 + 512 * 1024, this->name);
49170 + for (i = 0; i < pt_fmt->part_num; i++) {
49171 + pp = &(pt_fmt->partitions[i]);
49172 + offset = pp->offset >> 9; /* unit:512 bytes */
49173 + size = pp->size >> 9; /* unit:512 bytes */
49176 + size, 0, pp->name);
49179 + disk->disk_name, 1 + i,
49180 + pp->name, offset << 9,
49184 + __func__, disk->disk_name);
49187 + pp->name, offset << 9, size << 9);
49207 + struct mmc_host *mmc = card->host;
49215 + /*return mmc->is_emmc_port;*/
49234 + if (par_table->size == -1)
49235 + pr_info("part: %d, name : %10s, size : %-4s mask_flag %d\n",
49236 + i, par_table->name, "end",
49237 + par_table->mask_flags);
49239 + pr_info("part: %d, name : %10s, size : %-4llx mask_flag %d\n",
49240 + i, par_table->name, par_table->size,
49241 + par_table->mask_flags);
49252 + tmp_table = pt_fmt->partitions;
49258 + return -ENOMEM;
49304 + part_table[part_num].size = -1;
49318 +static int store_device = -1;
49322 + if (store_device == -1) {
49360 + u64 boot_size = (u64)get_capacity(disk) - 1;
49389 + return -ENOMEM;
49391 + mmc_claim_host(card->host);
49403 + if (le64_to_cpu(gpt_h->signature) == GPT_HEADER_SIGNATURE) {
49405 + mmc_release_host(card->host);
49417 + mmc_release_host(card->host);
49418 + return -ENOMEM;
49424 + pr_info("Delete invalid mbr partition part %p, part->partno %d\n",
49425 + part, part->partno);
49434 + mmc_release_host(card->host);
49447 + ret = -1;
49486 diff -Naur a/vendor/amlogic/mmc/Makefile b/vendor/amlogic/mmc/Makefile
49487 --- a/vendor/amlogic/mmc/Makefile 1970-01-01 08:00:00.000000000 +0800
49488 +++ b/vendor/amlogic/mmc/Makefile 2022-05-31 11:56:47.717259467 +0800
49489 @@ -0,0 +1,5 @@
49490 +# SPDX-License-Identifier: GPL-2.0
49493 +obj-$(CONFIG_MMC_MESON_GX) += emmc_partitions.o \
49495 diff -Naur a/vendor/amlogic/pm/Kconfig b/vendor/amlogic/pm/Kconfig
49496 --- a/vendor/amlogic/pm/Kconfig 1970-01-01 08:00:00.000000000 +0800
49497 +++ b/vendor/amlogic/pm/Kconfig 2022-06-30 16:21:34.294964448 +0800
49498 @@ -0,0 +1,10 @@
49499 +# SPDX-License-Identifier: GPL-2.0-only
49509 diff -Naur a/vendor/amlogic/pm/Makefile b/vendor/amlogic/pm/Makefile
49510 --- a/vendor/amlogic/pm/Makefile 1970-01-01 08:00:00.000000000 +0800
49511 +++ b/vendor/amlogic/pm/Makefile 2022-06-30 16:21:12.984323728 +0800
49512 @@ -0,0 +1,2 @@
49513 +# SPDX-License-Identifier: GPL-2.0-only
49514 +obj-$(CONFIG_MESON_GX_PM) += meson_gx_pm.o
49515 diff -Naur a/vendor/amlogic/pm/meson_gx_pm.c b/vendor/amlogic/pm/meson_gx_pm.c
49516 --- a/vendor/amlogic/pm/meson_gx_pm.c 1970-01-01 08:00:00.000000000 +0800
49517 +++ b/vendor/amlogic/pm/meson_gx_pm.c 2022-05-31 11:56:47.725259396 +0800
49518 @@ -0,0 +1,86 @@
49539 +#include <linux/arm-smccc.h>
49571 + return -EINVAL;
49580 + { .compatible = "amlogic,meson-gx-pm", },
49595 + .name = "meson-gx-pm",
49605 diff -Naur a/vendor/amlogic/reboot/Kconfig b/vendor/amlogic/reboot/Kconfig
49606 --- a/vendor/amlogic/reboot/Kconfig 1970-01-01 08:00:00.000000000 +0800
49607 +++ b/vendor/amlogic/reboot/Kconfig 2022-07-04 10:14:26.238273685 +0800
49608 @@ -0,0 +1,16 @@
49625 diff -Naur a/vendor/amlogic/reboot/Makefile b/vendor/amlogic/reboot/Makefile
49626 --- a/vendor/amlogic/reboot/Makefile 1970-01-01 08:00:00.000000000 +0800
49627 +++ b/vendor/amlogic/reboot/Makefile 2022-07-04 10:14:40.820257260 +0800
49628 @@ -0,0 +1,4 @@
49632 +obj-$(CONFIG_AMLOGIC_GX_REBOOT) += reboot.o
49633 diff -Naur a/vendor/amlogic/reboot/reboot.c b/vendor/amlogic/reboot/reboot.c
49634 --- a/vendor/amlogic/reboot/reboot.c 1970-01-01 08:00:00.000000000 +0800
49635 +++ b/vendor/amlogic/reboot/reboot.c 2022-07-04 13:59:02.866804967 +0800
49636 @@ -0,0 +1,205 @@
49662 +#include <linux/arm-smccc.h>
49786 + if (!of_property_read_u32(pdev->dev.of_node, "sys_reset", &id)) {
49791 + if (!of_property_read_u32(pdev->dev.of_node, "sys_poweroff", &id)) {
49796 + ret = of_property_read_u32(pdev->dev.of_node,
49801 + device_create_file(&pdev->dev, &dev_attr_reboot_reason);
49832 + .name = "aml-restart",
49842 diff -Naur a/vendor/amlogic/secmon/Kconfig b/vendor/amlogic/secmon/Kconfig
49843 --- a/vendor/amlogic/secmon/Kconfig 1970-01-01 08:00:00.000000000 +0800
49844 +++ b/vendor/amlogic/secmon/Kconfig 2022-05-31 11:56:47.717259467 +0800
49845 @@ -0,0 +1,10 @@
49856 diff -Naur a/vendor/amlogic/secmon/Makefile b/vendor/amlogic/secmon/Makefile
49857 --- a/vendor/amlogic/secmon/Makefile 1970-01-01 08:00:00.000000000 +0800
49858 +++ b/vendor/amlogic/secmon/Makefile 2022-05-31 11:56:47.717259467 +0800
49859 @@ -0,0 +1 @@
49860 +obj-$(CONFIG_AMLOGIC_SEC) += secmon.o
49861 diff -Naur a/vendor/amlogic/secmon/secmon.c b/vendor/amlogic/secmon/secmon.c
49862 --- a/vendor/amlogic/secmon/secmon.c 1970-01-01 08:00:00.000000000 +0800
49863 +++ b/vendor/amlogic/secmon/secmon.c 2022-05-31 11:56:47.717259467 +0800
49864 @@ -0,0 +1,238 @@
49865 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
49879 +#include <linux/dma-map-ops.h>
49881 +#include <linux/arm-smccc.h>
49920 + if (res.a0 != -1)
49924 + if (res.a0 != -1)
49944 + struct device_node *np = pdev->dev.of_node;
49965 + ret = of_reserved_mem_device_init(&pdev->dev);
49971 + page = dma_alloc_from_contiguous(&pdev->dev, secmon_size >> PAGE_SHIFT, 0, 0);
49974 + return -ENOMEM;
49986 + return -ENOMEM;
49998 + return -ENOMEM;
50103 diff -Naur a/vendor/amlogic/unifykey/amlkey_if.h b/vendor/amlogic/unifykey/amlkey_if.h
50104 --- a/vendor/amlogic/unifykey/amlkey_if.h 1970-01-01 08:00:00.000000000 +0800
50105 +++ b/vendor/amlogic/unifykey/amlkey_if.h 2022-05-31 11:56:47.717259467 +0800
50106 @@ -0,0 +1,60 @@
50107 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
50129 + return amlkey_if->init(seed, len, encrypt_type);
50134 + return amlkey_if->exsit(name);
50139 + return amlkey_if->size(name);
50144 + return amlkey_if->get_attr(name);
50149 + return amlkey_if->read(name, buffer, len);
50155 + return amlkey_if->write(name, buffer, len, attr);
50160 + return amlkey_if->hash(name, hash);
50167 diff -Naur a/vendor/amlogic/unifykey/efuse_api.c b/vendor/amlogic/unifykey/efuse_api.c
50168 --- a/vendor/amlogic/unifykey/efuse_api.c 1970-01-01 08:00:00.000000000 +0800
50169 +++ b/vendor/amlogic/unifykey/efuse_api.c 2022-05-31 11:56:47.717259467 +0800
50170 @@ -0,0 +1,337 @@
50171 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
50180 +#include <linux/arm-smccc.h>
50203 + unsigned long *retcnt = (unsigned long *)(arg->retcnt);
50210 + if (arg->cmd == EFUSE_HAL_API_READ)
50212 + else if (arg->cmd == EFUSE_HAL_API_WRITE)
50215 + return -1;
50217 + offset = arg->offset;
50218 + size = arg->size;
50222 + if (arg->cmd == EFUSE_HAL_API_WRITE) {
50231 + (const void *)arg->buffer, size);
50240 + if (arg->cmd == EFUSE_HAL_API_WRITE) {
50243 + } else if ((arg->cmd == EFUSE_HAL_API_READ) && (ret != 0)) {
50251 + memcpy((void *)arg->buffer,
50261 + return -1;
50272 + return -1;
50274 + cpumask_copy(&task_cpumask, current->cpus_ptr);
50332 + return -EINVAL;
50348 + *retrun: 1: wrote, 0: not write, -1: fail or not support
50357 + return -EINVAL;
50377 + cpumask_copy(&task_cpumask, current->cpus_ptr);
50393 + if (arg->cmd != EFUSE_HAL_API_USER_MAX)
50394 + return -1;
50403 + return -1;
50416 + cpumask_copy(&task_cpumask, current->cpus_ptr);
50478 + return -ENOMEM;
50498 + return -ENOMEM;
50508 diff -Naur a/vendor/amlogic/unifykey/efuse_burn.c b/vendor/amlogic/unifykey/efuse_burn.c
50509 --- a/vendor/amlogic/unifykey/efuse_burn.c 1970-01-01 08:00:00.000000000 +0800
50510 +++ b/vendor/amlogic/unifykey/efuse_burn.c 2022-05-31 11:56:47.717259467 +0800
50511 @@ -0,0 +1,303 @@
50512 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
50541 + devp = container_of(inode->i_cdev, struct aml_efuse_burn_dev, cdev);
50542 + file->private_data = devp;
50552 + file->private_data = NULL;
50564 + long ret = -ENOTTY;
50573 + return -EFAULT;
50579 + return -EFAULT;
50583 + return -EFAULT;
50618 + devp = file->private_data;
50622 + if (count != devp->efuse_pattern_size) {
50623 + ret = -EINVAL;
50625 + devp->efuse_pattern_size);
50630 + ret = -ENOMEM;
50639 + ret = -EFAULT;
50649 + ret = -EINVAL;
50705 + struct device_node *np = pdev->dev.of_node;
50707 + efuse_burn_dev = devm_kzalloc(&pdev->dev, sizeof(*efuse_burn_dev),
50710 + ret = -ENOMEM;
50711 + dev_err(&pdev->dev, "failed to alloc enough mem for efuse_dev\n");
50715 + efuse_burn_dev->pdev = pdev;
50721 + &efuse_burn_dev->efuse_pattern_size);
50727 + ret = alloc_chrdev_region(&efuse_burn_dev->devno, 0, 1,
50730 + dev_err(&pdev->dev, "fail to allocate major number\n ");
50734 + efuse_burn_dev->cls.name = EFUSE_BURN_CLASS_NAME;
50735 + efuse_burn_dev->cls.owner = THIS_MODULE;
50736 + efuse_burn_dev->cls.class_groups = efuse_burn_class_groups;
50737 + ret = class_register(&efuse_burn_dev->cls);
50741 + cdev_init(&efuse_burn_dev->cdev, &efuse_burn_fops);
50742 + efuse_burn_dev->cdev.owner = THIS_MODULE;
50744 + ret = cdev_add(&efuse_burn_dev->cdev, efuse_burn_dev->devno, 1);
50746 + dev_err(&pdev->dev, "failed to add device\n");
50750 + devp = device_create(&efuse_burn_dev->cls, NULL,
50751 + efuse_burn_dev->devno, efuse_burn_dev, "efuse_burn");
50753 + dev_err(&pdev->dev, "failed to create device node\n");
50759 + dev_info(&pdev->dev, "device %s created OK\n", EFUSE_BURN_DEVICE_NAME);
50764 + cdev_del(&efuse_burn_dev->cdev);
50766 + class_unregister(&efuse_burn_dev->cls);
50768 + unregister_chrdev_region(efuse_burn_dev->devno, 1);
50770 + devm_kfree(&pdev->dev, efuse_burn_dev);
50780 + unregister_chrdev_region(efuse_burn_dev->devno, 1);
50781 + device_destroy(&efuse_burn_dev->cls, efuse_burn_dev->devno);
50782 + cdev_del(&efuse_burn_dev->cdev);
50783 + class_unregister(&efuse_burn_dev->cls);
50785 + devm_kfree(&pdev->dev, efuse_burn_dev);
50815 diff -Naur a/vendor/amlogic/unifykey/efuse_burn.h b/vendor/amlogic/unifykey/efuse_burn.h
50816 --- a/vendor/amlogic/unifykey/efuse_burn.h 1970-01-01 08:00:00.000000000 +0800
50817 +++ b/vendor/amlogic/unifykey/efuse_burn.h 2022-05-31 11:56:47.717259467 +0800
50818 @@ -0,0 +1,42 @@
50819 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
50836 + int status; //1:wrote, 0:not write, -1:fail.
50861 diff -Naur a/vendor/amlogic/unifykey/efuse.c b/vendor/amlogic/unifykey/efuse.c
50862 --- a/vendor/amlogic/unifykey/efuse.c 1970-01-01 08:00:00.000000000 +0800
50863 +++ b/vendor/amlogic/unifykey/efuse.c 2022-05-31 11:56:47.717259467 +0800
50864 @@ -0,0 +1,1182 @@
50865 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
50937 + int ret = -EINVAL;
50941 + strcpy(info->keyname, efuse_key.infos[i].keyname);
50942 + info->offset = efuse_key.infos[i].offset;
50943 + info->size = efuse_key.infos[i].size;
50953 +/*return: 0:is configurated, -1: don't cfg*/
50956 + int ret = -1;
50969 + * retrun: 1:burned(wrote), 0: not write, -1: fail
50974 + int ret = -1;
50991 + devp = container_of(inode->i_cdev, struct aml_efuse_dev, cdev);
50992 + file->private_data = devp;
51009 + return -EINVAL;
51017 + newpos = filp->f_pos + off;
51025 + return -EINVAL;
51029 + return -EINVAL;
51031 + filp->f_pos = newpos;
51045 + return -EFAULT;
51050 + return -EFAULT;
51055 + return -EFAULT;
51060 + return -ENOTTY;
51093 + if (pos >= max_size || count > max_size || count > max_size - pos) {
51094 + ret = -EINVAL;
51100 + ret = -ENOMEM;
51118 + ret = -EFAULT;
51145 + if (pos >= max_size || count > max_size || count > max_size - pos) {
51146 + ret = -EINVAL;
51153 + ret = -ENOMEM;
51162 + ret = -EFAULT;
51184 + return -EPERM;
51213 + ret = -EINVAL;
51220 + ret = -ENOMEM;
51233 + if (i != info.size - 1) {
51236 + ret = -EINVAL;
51254 + } else if ((op[count - 1] != 0x0A && count != info.size) ||
51255 + count - 1 > info.size || count < info.size) {
51257 + ret = -EINVAL;
51281 + return -EPERM;
51296 + ret = -EINVAL;
51303 + ret = -ENOMEM;
51343 + ret = -EINVAL;
51350 + ret = -ENOMEM;
51393 + ret = -ENOMEM;
51442 + ret = -EINVAL;
51449 + ret = -ENOMEM;
51484 + ret = -EINVAL;
51492 + ret = -ENOMEM;
51506 + ret = -EINVAL;
51527 + if (!efuse_dev->reg_base)
51528 + ret = -EINVAL;
51530 + ret = readl(efuse_dev->reg_base) & efuse_dev->secureboot_mask;
51548 + if (efuse_dev->name[0]) {
51549 + if (efuse_burn_lockable_is_cfg(efuse_dev->name) == 0) {
51550 + n = efuse_burn_check_burned(efuse_dev->name);
51578 + n--; //discard '\n'
51580 + n = EFUSE_CHECK_NAME_LEN - 1;
51582 + memset(efuse_dev->name, 0, sizeof(efuse_dev->name));
51583 + memcpy(efuse_dev->name, buf, n);
51615 + ret = -EINVAL;
51621 + ret = -EINVAL;
51632 + name_size = EFUSE_KEY_NAME_LEN - 1;
51671 + ret = -EINVAL;
51677 + ret = -EINVAL;
51689 + ret = -EINVAL;
51698 + ret = -ENOMEM;
51731 + ret = -EINVAL;
51737 + ret = -EINVAL;
51748 + name_size = EFUSE_CHECK_NAME_LEN - 1;
51779 + ret = -EINVAL;
51785 + ret = -EINVAL;
51810 + ret = -EINVAL;
51819 + ret = -ENOMEM;
51867 + struct device_node *np = pdev->dev.of_node;
51874 + efuse_dev = devm_kzalloc(&pdev->dev, sizeof(*efuse_dev), GFP_KERNEL);
51876 + ret = -ENOMEM;
51877 + dev_err(&pdev->dev, "failed to alloc enough mem for efuse_dev\n");
51881 + efuse_dev->pdev = pdev;
51884 + efuse_clk = devm_clk_get(&pdev->dev, "efuse_clk");
51886 + dev_err(&pdev->dev, "can't get efuse clk gate, use default clk\n");
51890 + dev_err(&pdev->dev, "failed to enable efuse clk gate\n");
51899 + dev_err(&pdev->dev, "please config read_cmd\n");
51905 + dev_err(&pdev->dev, "failed to write_cmd\n");
51911 + dev_err(&pdev->dev, "failed to get_max_cmd\n");
51918 + dev_err(&pdev->dev, "failed to mem_in_base_cmd\n");
51925 + dev_err(&pdev->dev, "failed to mem_out_base_cmd\n");
51942 + reg_base = devm_ioremap_resource(&pdev->dev, reg_mem);
51944 + dev_err(&pdev->dev, "reg0: cannot obtain I/O memory region.\n");
51951 + dev_err(&pdev->dev, "can't get reg secureboot_mask\n");
51956 + dev_err(&pdev->dev, "can't get reg resource\n");
51962 + ret = alloc_chrdev_region(&efuse_dev->devno, 0, 1, EFUSE_DEVICE_NAME);
51964 + dev_err(&pdev->dev, "fail to allocate major number\n ");
51968 + efuse_dev->reg_base = reg_base;
51969 + efuse_dev->secureboot_mask = secureboot_mask;
51970 + efuse_dev->cls.name = EFUSE_CLASS_NAME;
51971 + efuse_dev->cls.owner = THIS_MODULE;
51972 + efuse_dev->cls.class_groups = efuse_calss_groups;
51973 + ret = class_register(&efuse_dev->cls);
51977 + cdev_init(&efuse_dev->cdev, &efuse_fops);
51978 + efuse_dev->cdev.owner = THIS_MODULE;
51980 + ret = cdev_add(&efuse_dev->cdev, efuse_dev->devno, 1);
51982 + dev_err(&pdev->dev, "failed to add device\n");
51986 + devp = device_create(&efuse_dev->cls, NULL,
51987 + efuse_dev->devno, NULL, "efuse");
51989 + dev_err(&pdev->dev, "failed to create device node\n");
51994 + dev_info(&pdev->dev, "device %s created OK\n", EFUSE_DEVICE_NAME);
51998 + cdev_del(&efuse_dev->cdev);
52000 + class_unregister(&efuse_dev->cls);
52002 + unregister_chrdev_region(efuse_dev->devno, 1);
52004 + devm_kfree(&pdev->dev, efuse_dev);
52013 + unregister_chrdev_region(efuse_dev->devno, 1);
52014 + device_destroy(&efuse_dev->cls, efuse_dev->devno);
52015 + cdev_del(&efuse_dev->cdev);
52016 + class_unregister(&efuse_dev->cls);
52047 diff -Naur a/vendor/amlogic/unifykey/efuse.h b/vendor/amlogic/unifykey/efuse.h
52048 --- a/vendor/amlogic/unifykey/efuse.h 1970-01-01 08:00:00.000000000 +0800
52049 +++ b/vendor/amlogic/unifykey/efuse.h 2022-05-31 11:56:47.717259467 +0800
52050 @@ -0,0 +1,99 @@
52051 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
52129 +/*return: 0:is configurated, -1: don't cfg*/
52132 + * retrun: 1:burned(wrote), 0: not write, -1: fail
52150 diff -Naur a/vendor/amlogic/unifykey/efuse_unifykey.c b/vendor/amlogic/unifykey/efuse_unifykey.c
52151 --- a/vendor/amlogic/unifykey/efuse_unifykey.c 1970-01-01 08:00:00.000000000 +0800
52152 +++ b/vendor/amlogic/unifykey/efuse_unifykey.c 2022-05-31 11:56:47.717259467 +0800
52153 @@ -0,0 +1,57 @@
52154 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
52211 diff -Naur a/vendor/amlogic/unifykey/Kconfig b/vendor/amlogic/unifykey/Kconfig
52212 --- a/vendor/amlogic/unifykey/Kconfig 1970-01-01 08:00:00.000000000 +0800
52213 +++ b/vendor/amlogic/unifykey/Kconfig 2022-05-31 11:56:47.717259467 +0800
52214 @@ -0,0 +1,33 @@
52248 diff -Naur a/vendor/amlogic/unifykey/Makefile b/vendor/amlogic/unifykey/Makefile
52249 --- a/vendor/amlogic/unifykey/Makefile 1970-01-01 08:00:00.000000000 +0800
52250 +++ b/vendor/amlogic/unifykey/Makefile 2022-05-31 11:56:47.717259467 +0800
52251 @@ -0,0 +1,11 @@
52257 +obj-$(CONFIG_AMLOGIC_EFUSE_UNIFYKEY) = $(MODULE_NAME).o
52259 +$(MODULE_NAME)-y += efuse_unifykey.o
52260 +$(MODULE_NAME)-$(CONFIG_AMLOGIC_EFUSE) += efuse.o efuse_api.o
52261 +$(MODULE_NAME)-$(CONFIG_AMLOGIC_EFUSE_BURN) += efuse_burn.o
52262 +$(MODULE_NAME)-$(CONFIG_AMLOGIC_UNIFYKEY) += security_key.o unifykey.o unifykey_dts.o storage_key.…
52263 diff -Naur a/vendor/amlogic/unifykey/normal_key.c b/vendor/amlogic/unifykey/normal_key.c
52264 --- a/vendor/amlogic/unifykey/normal_key.c 1970-01-01 08:00:00.000000000 +0800
52265 +++ b/vendor/amlogic/unifykey/normal_key.c 2022-05-31 11:56:47.717259467 +0800
52266 @@ -0,0 +1,683 @@
52267 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
52276 +#include <linux/arm-smccc.h>
52356 + pr_info("mark: %s\n", prawhead->mark);
52357 + pr_info("keycnt: %u\n", prawhead->keycnt);
52358 + pr_info("initcnt: %u\n", prawhead->initcnt);
52359 + pr_info("wrtcnt: %u\n", prawhead->wrtcnt);
52360 + pr_info("errcnt: %u\n", prawhead->errcnt);
52361 + pr_info("flags: 0x%x\n", prawhead->flags);
52367 + pr_info("blocksize: %u\n", penchead->blocksize);
52368 + pr_info("flashsize: %u\n", penchead->flashsize);
52379 + tmp = min(((int)len - idx), 16);
52381 + total += snprintf(buf + total, 64 - total, "%02x ", p[idx + j]);
52391 + obj->namesize, obj->namesize, obj->name,
52392 + obj->type, obj->attribute, obj->datasize);
52393 + if (obj->dataptr) {
52395 + dump_mem(obj->dataptr, obj->datasize);
52468 + ret = Tlv_ReadTl(input + idx, len - idx,
52475 + pblockhead->blocksize = *((u32 *)(input + idx));
52478 + pblockhead->flashsize = *((u32 *)(input + idx));
52508 + ret = Tlv_ReadTl(input + idx, len - idx,
52515 + pcontent->namesize = *((u32 *)(input + idx));
52518 + memset(pcontent->name, 0, MAX_OBJ_NAME_LEN);
52519 + memcpy(pcontent->name, input + idx, pcontent->namesize);
52522 + pcontent->type = *((u32 *)(input + idx));
52525 + pcontent->attribute = *((u32 *)(input + idx));
52528 + pcontent->datasize = *((u32 *)(input + idx));
52533 + memcpy(pcontent->hashptr, input + idx, length);
52536 + pcontent->dataptr = kmalloc(pcontent->datasize,
52538 + if (!pcontent->dataptr)
52540 + memcpy(pcontent->dataptr,
52541 + input + idx, pcontent->datasize);
52551 + kfree(pcontent->dataptr);
52558 + __tmp = Tlv_WriteUint32(output + idx, len - idx, \
52568 + __tmp = Tlv_WriteBuf(output + idx, len - idx, \
52588 + if (!WRT_UINT32(EMTLVHEADSIZE, enchead->blocksize))
52590 + if (!WRT_UINT32(EMTLVHEADFLASHSIZE, enchead->flashsize))
52593 + *sum = idx - 8;
52610 + if (object->namesize != 0) {
52611 + if (!WRT_UINT32(EMTLVOBJNAMESIZE, object->namesize))
52613 + if (!WRT_BUF(EMTLVOBJNAME, object->namesize,
52614 + (u8 *)object->name))
52618 + if (object->dataptr && object->datasize != 0) {
52619 + if (!WRT_UINT32(EMTLVOBJDATASIZE, object->datasize))
52621 + if (!WRT_BUF(EMTLVOBJDATABUF, object->datasize,
52622 + object->dataptr))
52626 + if (!WRT_BUF(EMTLVOBJHASHBUF, 32, object->hashptr))
52628 + if (!WRT_UINT32(EMTLVOBJTYPE, object->type))
52630 + if (!WRT_UINT32(EMTLVOBJATTR, object->attribute))
52633 + *sum = idx - 8;
52641 + int ret = -1;
52647 + ret = -EINVAL;
52653 + ret = -ENOMEM;
52656 + desc->tfm = tfm;
52675 + return -1;
52691 + list_del(&pos->node);
52692 + kfree(pos->object.dataptr);
52708 + obj = &pos->object;
52709 + if (len == obj->namesize &&
52710 + !memcmp(name, obj->name, len))
52725 + return -1;
52728 + return -1;
52732 + return -1;
52736 + if (attr != obj->attribute)
52737 + return -1;
52738 + if (len > obj->datasize) {
52741 + return -1;
52742 + kfree(obj->dataptr);
52743 + obj->dataptr = data;
52748 + return -1;
52752 + return -1;
52754 + obj = &node->object;
52755 + memcpy(obj->name, name, namelen);
52756 + obj->namesize = namelen;
52757 + obj->attribute = attr;
52758 + obj->type = OBJ_TYPE_GENERIC;
52759 + obj->dataptr = data;
52760 + list_add(&node->node, &keys);
52762 + obj->datasize = len;
52763 + memcpy(obj->dataptr, buffer, len);
52764 + normalkey_hash(buffer, len, obj->hashptr);
52774 + return -1;
52778 + return -1;
52781 + list_del(&node->node);
52782 + kfree(obj->dataptr);
52798 + return -1;
52806 + return -1;
52815 + if (strcmp((const char *)prawhead->mark, blockmark) != 0) {
52820 + normalkey_hash((u8 *)prawhead, sizeof(*prawhead) - 64,
52822 + if (memcmp(rawhead.headhash, prawhead->headhash, 32)) {
52827 + rawhead.keycnt = prawhead->keycnt;
52828 + rawhead.initcnt = prawhead->initcnt;
52829 + rawhead.wrtcnt = prawhead->wrtcnt;
52830 + rawhead.errcnt = prawhead->errcnt;
52831 + rawhead.flags = prawhead->flags;
52840 + normalkey_hash(penchead, size - STORAGE_BLOCK_RAW_HEAD_SIZE,
52842 + if (memcmp(rawhead.hash, prawhead->hash, 32)) {
52877 + obj = &node->object;
52879 + enchead.blocksize - idx, obj);
52886 + normalkey_hash(obj->dataptr, obj->datasize, hash);
52887 + if (memcmp(hash, obj->hashptr, 32)) {
52888 + kfree(obj->dataptr);
52895 + list_add(&node->node, &keys);
52913 + return -1;
52921 + return -1;
52924 + size -= (STORAGE_BLOCK_ENC_HEAD_SIZE + STORAGE_BLOCK_RAW_HEAD_SIZE);
52928 + obj = &node->object;
52929 + ret = Tlv_WriteObject(obj, pdata + idx, size - idx);
52931 + return -1;
52939 + return -1;
52942 + normalkey_hash((u8 *)&rawhead, sizeof(rawhead) - 64,
52944 + normalkey_hash(penchead, enchead.flashsize - STORAGE_BLOCK_RAW_HEAD_SIZE,
52950 diff -Naur a/vendor/amlogic/unifykey/normal_key.h b/vendor/amlogic/unifykey/normal_key.h
52951 --- a/vendor/amlogic/unifykey/normal_key.h 1970-01-01 08:00:00.000000000 +0800
52952 +++ b/vendor/amlogic/unifykey/normal_key.h 2022-05-31 11:56:47.717259467 +0800
52953 @@ -0,0 +1,37 @@
52954 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
52991 diff -Naur a/vendor/amlogic/unifykey/security_key.c b/vendor/amlogic/unifykey/security_key.c
52992 --- a/vendor/amlogic/unifykey/security_key.c 1970-01-01 08:00:00.000000000 +0800
52993 +++ b/vendor/amlogic/unifykey/security_key.c 2022-05-31 11:56:47.717259467 +0800
52994 @@ -0,0 +1,286 @@
52995 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
53003 +#include <linux/arm-smccc.h>
53027 + *size = share_mem->size;
53028 + return (void *)(share_mem->block);
53049 + if (namelen + keylen + 12 > share_mem->size)
53053 + input = (u32 *)(share_mem->in);
53082 + if (namelen + 8 > share_mem->size)
53086 + input = (u32 *)(share_mem->in);
53087 + output = (u32 *)(share_mem->out);
53118 + if (namelen + 4 > share_mem->size)
53122 + input = (u32 *)(share_mem->in);
53123 + output = (u32 *)(share_mem->out);
53148 + if (namelen + 4 > share_mem->size)
53152 + input = (u32 *)(share_mem->in);
53153 + output = (u32 *)(share_mem->out);
53178 + if (namelen + 4 > share_mem->size)
53182 + input = (u32 *)(share_mem->in);
53183 + output = (u32 *)(share_mem->out);
53208 + if (namelen + 4 > share_mem->size)
53212 + input = (u32 *)(share_mem->in);
53213 + output = (u32 *)(share_mem->out);
53231 + storage_init_status = -1;
53233 + share_mem = devm_kzalloc(&pdev->dev, sizeof(*share_mem), GFP_KERNEL);
53236 + return -ENOMEM;
53242 + share_mem->size = storage_smc_ops(BL31_STORAGE_SIZE);
53247 + !(share_mem->size) || share_mem->size == SMC_UNK) {
53249 + return -EOPNOTSUPP;
53259 + share_mem->in = (void __iomem *)phys_to_virt(phy_in);
53260 + share_mem->out = (void __iomem *)phys_to_virt(phy_out);
53261 + share_mem->block = (void __iomem *)phys_to_virt(phy_block);
53263 + share_mem->in = ioremap_cache(phy_in, share_mem->size);
53264 + share_mem->out = ioremap_cache(phy_out, share_mem->size);
53265 + share_mem->block = ioremap_cache(phy_block, share_mem->size);
53269 + (long)(share_mem->in), (long)(share_mem->out),
53270 + (long)(share_mem->block));
53272 + if (!(share_mem->in) || !(share_mem->out) || !(share_mem->block)) {
53274 + return -EINVAL;
53281 diff -Naur a/vendor/amlogic/unifykey/security_key.h b/vendor/amlogic/unifykey/security_key.h
53282 --- a/vendor/amlogic/unifykey/security_key.h 1970-01-01 08:00:00.000000000 +0800
53283 +++ b/vendor/amlogic/unifykey/security_key.h 2022-05-31 11:56:47.717259467 +0800
53284 @@ -0,0 +1,50 @@
53285 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
53335 diff -Naur a/vendor/amlogic/unifykey/storage_key.c b/vendor/amlogic/unifykey/storage_key.c
53336 --- a/vendor/amlogic/unifykey/storage_key.c 1970-01-01 08:00:00.000000000 +0800
53337 +++ b/vendor/amlogic/unifykey/storage_key.c 2022-05-31 11:56:47.717259467 +0800
53338 @@ -0,0 +1,542 @@
53339 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
53397 + return -EINVAL;
53406 + return -EINVAL;
53408 + type = uk_type->storage_type;
53412 + return -EINVAL;
53417 + return -EBUSY;
53420 + unifykey_types.storage_type = uk_type->storage_type;
53421 + unifykey_types.ops->read = uk_type->ops->read;
53422 + unifykey_types.ops->write = uk_type->ops->write;
53447 + ret = -EINVAL;
53454 + ret = -EINVAL;
53459 + if (unlikely(!uk_type->ops->read)) {
53461 + ret = -EINVAL;
53465 + ret = uk_type->ops->read(storagekey_info.buffer,
53477 + ret = -EINVAL;
53493 + return -ENOMEM;
53622 + if (!uk_type->ops->write) {
53628 + if (uk_type->ops->write(buf, storagekey_info.size, &actual_length)) {
53655 + return -1;
53657 + if (!unifykey_types.ops->read) {
53659 + return -1;
53663 + return -1;
53666 + ret = unifykey_types.ops->read(normal_block,
53708 + attr = obj->attribute;
53722 + size = obj->datasize;
53735 + if (obj && len >= obj->datasize) {
53736 + size = obj->datasize;
53737 + memcpy(buffer, obj->dataptr, size);
53755 + if (!unifykey_types.ops->write) {
53775 + ret = unifykey_types.ops->write(normal_block,
53791 + int ret = -1;
53798 + memcpy(hash, obj->hashptr, 32);
53810 + ret = device_property_read_u32(&pdev->dev, "blocksize", &blksz);
53818 + return -1;
53862 + if (ret != -EOPNOTSUPP) {
53881 diff -Naur a/vendor/amlogic/unifykey/unifykey.c b/vendor/amlogic/unifykey/unifykey.c
53882 --- a/vendor/amlogic/unifykey/unifykey.c 1970-01-01 08:00:00.000000000 +0800
53883 +++ b/vendor/amlogic/unifykey/unifykey.c 2022-05-31 11:56:47.721259431 +0800
53884 @@ -0,0 +1,1368 @@
53885 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
53943 + if (!strncmp(item->name, name,
53944 + ((strlen(item->name) > strlen(name)) ?
53945 + strlen(item->name) : strlen(name))))
53956 + if (item->id == id)
53984 + return -EINVAL;
53993 + return -EINVAL;
54000 + return -EINVAL;
54012 + return -EINVAL;
54016 + return -1;
54023 + return -EINVAL;
54036 + return -EINVAL;
54040 + return -ENOMEM;
54053 + return -EINVAL;
54066 + return -EINVAL;
54070 + return -ENOMEM;
54086 + return -EINVAL;
54097 + return -EINVAL;
54099 + if (ukdev->init_flag == 1) {
54104 + enc_type = ukdev->uk_info.encrypt_type;
54111 + ukdev->init_flag = 1;
54123 + key = uk_find_item_by_name(&ukdev->uk_hdr, name);
54126 + return -EINVAL;
54129 + if ((key->perm & KEY_PERM_WRITE) != KEY_PERM_WRITE) {
54131 + return -EPERM;
54134 + switch (key->dev) {
54140 + attr = ((key->dev == KEY_SECURE) ? KEY_ATTR_SECURE : 0);
54141 + attr |= (key->attr & KEY_ATTR_ENCRYPT) ? KEY_ATTR_ENCRYPT : 0;
54145 + ret = -EINVAL;
54167 + return -EINVAL;
54170 + key = uk_find_item_by_name(&ukdev->uk_hdr, name);
54173 + return -EINVAL;
54176 + if ((key->perm & KEY_PERM_READ) != KEY_PERM_READ) {
54178 + return -EPERM;
54181 + switch (key->dev) {
54192 + ret = key_storage_read(name, data, len, real, key->attr);
54208 + key = uk_find_item_by_name(&ukdev->uk_hdr, name);
54211 + return -EINVAL;
54214 + if ((key->perm & KEY_PERM_READ) != KEY_PERM_READ) {
54216 + return -EPERM;
54219 + switch (key->dev) {
54253 + key = uk_find_item_by_name(&ukdev->uk_hdr, name);
54256 + return -EINVAL;
54259 + if ((key->perm & KEY_PERM_READ) != KEY_PERM_READ) {
54261 + return -EINVAL;
54264 + switch (key->dev) {
54267 + *perm = key->perm;
54275 + *perm = key->perm;
54293 + key = uk_find_item_by_name(&ukdev->uk_hdr, name);
54296 + return -EINVAL;
54300 + ret = key_unify_query(ukdev, key->name, &state, NULL);
54306 + *secure = amlkey_get_attr((u8 *)(key->name)) & KEY_ATTR_SECURE;
54308 + if (key->dev == KEY_SECURE)
54324 + key = uk_find_item_by_name(&ukdev->uk_hdr, name);
54327 + return -EINVAL;
54331 + ret = key_unify_query(ukdev, key->name, &state, NULL);
54338 + *enc = amlkey_get_attr((u8 *)(key->name)) & KEY_ATTR_ENCRYPT;
54340 + if (key->attr & KEY_ATTR_ENCRYPT)
54350 + return ukdev_global->init_flag;
54360 + ukdev = container_of(inode->i_cdev, struct aml_uk_dev, cdev);
54361 + file->private_data = ukdev;
54376 + ukdev = filp->private_data;
54384 + newpos = filp->f_pos + off;
54388 + newpos = (loff_t)uk_count_key(&ukdev->uk_hdr) - 1;
54389 + newpos = newpos - off;
54393 + return -EINVAL;
54397 + return -EINVAL;
54398 + if (newpos >= (loff_t)uk_count_key(&ukdev->uk_hdr))
54399 + return -EINVAL;
54400 + filp->f_pos = newpos;
54416 + ukdev = file->private_data;
54422 + return -ENOMEM;
54429 + ret = key_unify_init(ukdev, key->name, KEY_UNIFY_NAME_LEN);
54437 + return -ENOMEM;
54445 + item->name[KEY_UNIFY_NAME_LEN - 1] = '\0';
54446 + if (strlen(item->name))
54447 + key = uk_find_item_by_name(&ukdev->uk_hdr, item->name);
54449 + key = uk_find_item_by_id(&ukdev->uk_hdr, item->id);
54453 + return -EINVAL;
54455 + pr_err("%d, %s\n", key->id, key->name);
54457 + ret = key_unify_query(ukdev, key->name, &state, &perm);
54459 + pr_err("fail to query key: %s\n", key->name);
54463 + item->perm = perm;
54464 + item->flag = state;
54465 + item->id = key->id;
54466 + strncpy(item->name, key->name, (KEY_UNIFY_NAME_LEN - 1));
54467 + item->name[KEY_UNIFY_NAME_LEN - 1] = '\0';
54468 + ret = key_unify_size(ukdev, key->name, &item->size);
54470 + pr_err("fail to obtain key size of %s\n", key->name);
54472 + return -EFAULT;
54486 + return -EINVAL;
54513 + ukdev = file->private_data;
54516 + item = uk_find_item_by_id(&ukdev->uk_hdr, id);
54518 + ret = -EINVAL;
54522 + if (item->dev == KEY_SECURE)
54528 + return -ENOMEM;
54531 + ret = key_unify_read(ukdev, item->name, local_buf, count, &reallen);
54537 + ret = -EFAULT;
54556 + ukdev = file->private_data;
54560 + return -ENOMEM;
54563 + item = uk_find_item_by_id(&ukdev->uk_hdr, id);
54565 + ret = -EINVAL;
54569 + ret = -EFAULT;
54573 + ret = key_unify_write(ukdev, item->name, local_buf, count);
54608 + key_cnt = uk_count_key(&ukdev->uk_hdr);
54612 + unifykey = uk_find_item_by_id(&ukdev->uk_hdr, index);
54615 + index, unifykey->name,
54616 + keydev[unifykey->dev], unifykey->perm);
54636 + curkey = ukdev->curkey;
54641 + return -EINVAL;
54644 + ret = key_unify_query(ukdev, curkey->name, &keystate, &keypermit);
54672 + curkey = ukdev->curkey;
54676 + return -EINVAL;
54680 + ret = key_unify_secure(ukdev, curkey->name, &secure);
54709 + curkey = ukdev->curkey;
54713 + return -EINVAL;
54717 + ret = key_unify_encrypt(ukdev, curkey->name, &encrypt);
54745 + curkey = ukdev->curkey;
54749 + return -EINVAL;
54752 + ret = key_unify_size(ukdev, curkey->name, &reallen);
54774 + curkey = ukdev->curkey;
54780 + n = sprintf(buf, "%s\n", curkey->name);
54800 + curkey = ukdev->curkey;
54803 + count = KEY_UNIFY_NAME_LEN - 1;
54807 + return -EINVAL;
54810 + key_cnt = uk_count_key(&ukdev->uk_hdr);
54815 + return -EINVAL;
54818 + if (buf[count - 1] == '\n')
54819 + memcpy(name, buf, count - 1);
54829 + unifykey = uk_find_item_by_id(&ukdev->uk_hdr, index);
54831 + if (!strncmp(name, unifykey->name,
54832 + ((strlen(unifykey->name) > query_name_len)
54833 + ? strlen(unifykey->name) : query_name_len))
54845 + return -EINVAL;
54847 + ukdev->curkey = curkey;
54866 + curkey = ukdev->curkey;
54869 + ret = key_unify_size(ukdev, curkey->name, &keysize);
54877 + __func__, __LINE__, curkey->name);
54880 + if (curkey->dev == KEY_SECURE)
54882 + pr_err("name: %s, size %d\n", curkey->name, keysize);
54889 + ret = key_unify_read(ukdev, curkey->name,
54919 + curkey = ukdev->curkey;
54923 + return -EINVAL;
54937 + if (key_len == count && (buf[count - 1] == '\n')) {
54939 + memcpy(keydata, buf, count - 1);
54940 + key_len = count - 1;
54946 + ret = key_unify_write(ukdev, curkey->name, keydata, key_len);
54969 + n = sprintf(buf, "%s\n", (ukdev->init_flag == 0 ? "no" : "yes"));
54996 + n = sprintf(buf, "%d\n", ukdev->lock_flag);
54998 + pr_info("%s\n", (ukdev->lock_flag == 1 ? "locked" : "unlocked"));
55014 + return -EINVAL;
55018 + if (buf[count - 1] == '\n')
55019 + len = count - 1;
55029 + return -EINVAL;
55032 + ukdev->lock_flag = state;
55034 + (ukdev->lock_flag == 1 ? "locked" : "unlocked"));
55045 +"echo \"key name\" > name //set current key name->\"key name\"\n"
55047 +"echo \"key value\" > write //set current key value->\"key value\"\n"
55075 + if (pdev->dev.of_node) {
55079 + pdev->dev.of_node);
55081 + key_dev = (char *)match->data;
55138 + ret = -ENODEV;
55142 + ukdev = devm_kzalloc(&pdev->dev, sizeof(*ukdev), GFP_KERNEL);
55145 + ret = -ENOMEM;
55149 + ukdev->pdev = pdev;
55152 + INIT_LIST_HEAD(&ukdev->uk_hdr);
55160 + ret = alloc_chrdev_region(&ukdev->uk_devno, 0, 1,
55166 + pr_info("unifykey_devno: %x\n", ukdev->uk_devno);
55168 + ukdev->cls.name = UNIFYKEYS_CLASS_NAME;
55169 + ukdev->cls.owner = THIS_MODULE;
55170 + ukdev->cls.class_groups = unifykey_class_groups;
55171 + ret = class_register(&ukdev->cls);
55176 + cdev_init(&ukdev->cdev, &unifykey_fops);
55177 + ukdev->cdev.owner = THIS_MODULE;
55179 + ret = cdev_add(&ukdev->cdev, ukdev->uk_devno, 1);
55185 + devp = device_create(&ukdev->cls, NULL,
55186 + ukdev->uk_devno, NULL, UNIFYKEYS_DEVICE_NAME);
55193 + devp->platform_data = get_unifykeys_drv_data(pdev);
55199 + cdev_del(&ukdev->cdev);
55201 + class_unregister(&ukdev->cls);
55203 + unregister_chrdev_region(ukdev->uk_devno, 1);
55205 + devm_kfree(&pdev->dev, ukdev);
55215 + if (pdev->dev.of_node)
55218 + unregister_chrdev_region(ukdev->uk_devno, 1);
55219 + device_destroy(&ukdev->cls, ukdev->uk_devno);
55220 + cdev_del(&ukdev->cdev);
55221 + class_unregister(&ukdev->cls);
55253 diff -Naur a/vendor/amlogic/unifykey/unifykey_dts.c b/vendor/amlogic/unifykey/unifykey_dts.c
55254 --- a/vendor/amlogic/unifykey/unifykey_dts.c 1970-01-01 08:00:00.000000000 +0800
55255 +++ b/vendor/amlogic/unifykey/unifykey_dts.c 2022-05-31 11:56:47.721259431 +0800
55256 @@ -0,0 +1,136 @@
55257 +// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
55283 + return -ENOMEM;
55286 + ret = of_property_read_string(node, "key-name", &propname);
55288 + pr_err("%s:%d,get key-name fail\n", __func__, __LINE__);
55289 + ret = -EINVAL;
55295 + count = KEY_UNIFY_NAME_LEN - 1;
55296 + memcpy(tmp_item->name, propname, count);
55300 + ret = of_property_read_string(node, "key-device", &propname);
55302 + pr_err("%s:%d,get key-device fail\n", __func__, __LINE__);
55303 + ret = -EINVAL;
55308 + tmp_item->dev = KEY_EFUSE;
55310 + tmp_item->dev = KEY_NORMAL;
55312 + tmp_item->dev = KEY_SECURE;
55314 + tmp_item->dev = KEY_UNKNOWN_DEV;
55317 + tmp_item->perm = 0;
55318 + if (of_property_match_string(node, "key-permit", "read") >= 0)
55319 + tmp_item->perm |= KEY_PERM_READ;
55320 + if (of_property_match_string(node, "key-permit", "write") >= 0)
55321 + tmp_item->perm |= KEY_PERM_WRITE;
55322 + tmp_item->id = id;
55324 + tmp_item->attr = 0;
55325 + if (of_property_read_bool(node, "key-encrypt"))
55326 + tmp_item->attr = KEY_ATTR_ENCRYPT;
55328 + list_add(&tmp_item->node, &ukdev->uk_hdr);
55337 + int ret = -1;
55340 + struct device_node *np = pdev->dev.of_node;
55361 + ukdev->uk_info.encrypt_type = -1;
55362 + /* do not care whether unifykey-encrypt really exists*/
55363 + ret = of_property_read_u32(pdev->dev.of_node, "unifykey-encrypt",
55364 + &ukdev->uk_info.encrypt_type);
55366 + pr_info("no unifykey-encrypt property\n");
55368 + if (!(ukdev->uk_info.key_flag)) {
55370 + ukdev->uk_info.key_num = key_num;
55371 + ukdev->uk_info.key_flag = 1;
55383 + if (pdev->dev.of_node)
55384 + of_node_put(pdev->dev.of_node);
55386 + list_for_each_entry_safe(item, tmp, &ukdev->uk_hdr, node) {
55387 + list_del(&item->node);
55390 + ukdev->uk_info.key_flag = 0;
55393 diff -Naur a/vendor/amlogic/unifykey/unifykey.h b/vendor/amlogic/unifykey/unifykey.h
55394 --- a/vendor/amlogic/unifykey/unifykey.h 1970-01-01 08:00:00.000000000 +0800
55395 +++ b/vendor/amlogic/unifykey/unifykey.h 2022-05-31 11:56:47.721259431 +0800
55396 @@ -0,0 +1,87 @@
55397 +/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
55432 + unsigned int flag; /*bit 0: 1 exsit, 0-none;*/
55484 diff -Naur a/vendor/amlogic/wifi/dhd_static_buf.c b/vendor/amlogic/wifi/dhd_static_buf.c
55485 --- a/vendor/amlogic/wifi/dhd_static_buf.c 1970-01-01 08:00:00.000000000 +0800
55486 +++ b/vendor/amlogic/wifi/dhd_static_buf.c 2022-06-30 14:53:29.553189617 +0800
55487 @@ -0,0 +1,463 @@
55945 + return -ENOMEM;
55951 diff -Naur a/vendor/amlogic/wifi/dhd_static_buf.h b/vendor/amlogic/wifi/dhd_static_buf.h
55952 --- a/vendor/amlogic/wifi/dhd_static_buf.h 1970-01-01 08:00:00.000000000 +0800
55953 +++ b/vendor/amlogic/wifi/dhd_static_buf.h 2022-05-31 11:56:48.093256151 +0800
55954 @@ -0,0 +1,21 @@
55976 diff -Naur a/vendor/amlogic/wifi/Kconfig b/vendor/amlogic/wifi/Kconfig
55977 --- a/vendor/amlogic/wifi/Kconfig 1970-01-01 08:00:00.000000000 +0800
55978 +++ b/vendor/amlogic/wifi/Kconfig 2022-05-31 11:56:47.721259431 +0800
55979 @@ -0,0 +1,7 @@
55987 diff -Naur a/vendor/amlogic/wifi/Makefile b/vendor/amlogic/wifi/Makefile
55988 --- a/vendor/amlogic/wifi/Makefile 1970-01-01 08:00:00.000000000 +0800
55989 +++ b/vendor/amlogic/wifi/Makefile 2022-05-31 11:56:47.721259431 +0800
55990 @@ -0,0 +1 @@
55991 +obj-y += wifi_dt.o dhd_static_buf.o
55993 diff -Naur a/vendor/amlogic/wifi/wifi_dt.c b/vendor/amlogic/wifi/wifi_dt.c
55994 --- a/vendor/amlogic/wifi/wifi_dt.c 1970-01-01 08:00:00.000000000 +0800
55995 +++ b/vendor/amlogic/wifi/wifi_dt.c 2022-06-30 15:33:21.221209131 +0800
55996 @@ -0,0 +1,578 @@
56078 + .compatible = "amlogic, wifi-dev",
56088 + match = of_match_node(wifi_match, pdev->dev.of_node);
56091 + return (struct wifi_plat_info *)match->data;
56204 + struct cdev *cdevp = inode->i_cdev;
56205 + file->private_data = cdevp;
56238 + memcpy(dev_type, "sdio", (sizeof(dev_type) - 1));
56245 + return -ENOTTY;
56249 + return -EINVAL;
56274 + return -1;
56353 + struct wifi_plat_info *plat = (struct wifi_plat_info *)(pdev->dev.platform_data);
56357 + if (pdev->dev.of_node) {
56359 + plat->plat_info_valid = 0;
56360 + plat->dev = &pdev->dev;
56362 + ret = of_property_read_string(pdev->dev.of_node, "interrupt_pin", &value);
56364 + plat->interrupt_pin = 0;
56366 + desc = of_get_named_gpio_flags(pdev->dev.of_node, "interrupt_pin", 0, NULL);
56367 + plat->interrupt_desc = gpio_to_desc(desc);
56368 + plat->interrupt_pin = desc;
56370 + ret = of_property_read_string(pdev->dev.of_node, "irq_trigger_type", &value);
56373 + plat->irq_trigger_type = 0;
56374 + return -1;
56378 + plat->irq_trigger_type = GPIO_IRQ_HIGH;
56380 + plat->irq_trigger_type = GPIO_IRQ_LOW;
56382 + plat->irq_trigger_type = GPIO_IRQ_RISING;
56384 + plat->irq_trigger_type = GPIO_IRQ_FALLING;
56386 + WIFI_INFO("unknown irq trigger type-%s\n",
56388 + return -1;
56391 + WIFI_INFO("interrupt_pin=%d\n", plat->interrupt_pin);
56393 + plat->irq_num, plat->irq_trigger_type);
56396 + ret = of_property_read_string(pdev->dev.of_node, "power_on_pin", &value);
56399 + plat->power_on_pin = 0;
56400 + plat->power_on_pin_OD = 0;
56402 + desc = of_get_named_gpio_flags(pdev->dev.of_node, "power_on_pin", 0, NULL);
56403 + plat->power_desc = gpio_to_desc(desc);
56404 + plat->power_on_pin = desc;
56407 + ret = of_property_read_u32(pdev->dev.of_node, "power_on_pin_level", &plat->power_on_pin_level);
56409 + plat->power_on_pin_level = 0;
56411 + ret = of_property_read_u32(pdev->dev.of_node, "power_on_pin_OD", &plat->power_on_pin_OD);
56413 + plat->power_on_pin_OD = 0;
56415 + ret = of_property_read_string(pdev->dev.of_node, "power_on_pin2", &value);
56417 + plat->power_on_pin2 = 0;
56419 + desc = of_get_named_gpio_flags(pdev->dev.of_node, "power_on_pin2", 0, NULL);
56420 + plat->power_on_pin2 = desc;
56423 + if (of_get_property(pdev->dev.of_node, "dhd_static_buf", NULL)) {
56427 + plat->plat_info_valid = 1;
56434 + ret = -ENODEV;
56446 + wifi_power_cdev->owner = THIS_MODULE;
56457 + devp->platform_data = pdata;
56514 + return c - '0';
56516 + return (c - 'A') + 10;
56518 + return (c - 'a') + 10;
56533 + WIFI_INFO("uboot setup mac-addr: %x:%x:%x:%x:%x:%x\n",
56575 diff -Naur a/vendor/amlogic/wifi/wifi_dt.h b/vendor/amlogic/wifi/wifi_dt.h
56576 --- a/vendor/amlogic/wifi/wifi_dt.h 1970-01-01 08:00:00.000000000 +0800
56577 +++ b/vendor/amlogic/wifi/wifi_dt.h 2022-06-30 15:28:16.867026208 +0800
56578 @@ -0,0 +1,19 @@
56598 diff -Naur a/vendor/Kconfig b/vendor/Kconfig
56599 --- a/vendor/Kconfig 1970-01-01 08:00:00.000000000 +0800
56600 +++ b/vendor/Kconfig 2022-06-25 19:52:18.146274718 +0800
56601 @@ -0,0 +1,8 @@
56602 +# SPDX-License-Identifier: GPL-2.0
56610 diff -Naur a/vendor/Makefile b/vendor/Makefile
56611 --- a/vendor/Makefile 1970-01-01 08:00:00.000000000 +0800
56612 +++ b/vendor/Makefile 2022-06-25 19:55:57.496041292 +0800
56613 @@ -0,0 +1,11 @@
56614 +# SPDX-License-Identifier: GPL-2.0
56622 +obj-y += $(VENDOR_DRIVERS_PREFIX)/device/board/$(PRODUCT_COMPANY)/$(DEVICE_NAME)/kernel/drivers/
56624 +obj-$(CONFIG_ARCH_MESON) += amlogic/