1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
4 * Author: Liviu Dudau <Liviu.Dudau@arm.com>
5 *
6 * ARM Mali DP500/DP550/DP650 hardware manipulation routines. This is where
7 * the difference between various versions of the hardware is being dealt with
8 * in an attempt to provide to the rest of the driver code a unified view
9 */
10
11 #include <linux/clk.h>
12 #include <linux/delay.h>
13 #include <linux/types.h>
14 #include <linux/io.h>
15
16 #include <video/videomode.h>
17 #include <video/display_timing.h>
18
19 #include <drm/drm_fourcc.h>
20 #include <drm/drm_vblank.h>
21 #include <drm/drm_print.h>
22
23 #include "malidp_drv.h"
24 #include "malidp_hw.h"
25 #include "malidp_mw.h"
26
27 enum {
28 MW_NOT_ENABLED = 0, /* SE writeback not enabled */
29 MW_ONESHOT, /* SE in one-shot mode for writeback */
30 MW_START, /* SE started writeback */
31 MW_RESTART, /* SE will start another writeback after this one */
32 MW_STOP, /* SE needs to stop after this writeback */
33 };
34
35 static const struct malidp_format_id malidp500_de_formats[] = {
36 /* fourcc, layers supporting the format, internal id */
37 { DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2 | SE_MEMWRITE, 0 },
38 { DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2 | SE_MEMWRITE, 1 },
39 { DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 2 },
40 { DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 3 },
41 { DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2 | SE_MEMWRITE, 4 },
42 { DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2 | SE_MEMWRITE, 5 },
43 { DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 6 },
44 { DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 7 },
45 { DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 8 },
46 { DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 9 },
47 { DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 10 },
48 { DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 11 },
49 { DRM_FORMAT_UYVY, DE_VIDEO1, 12 },
50 { DRM_FORMAT_YUYV, DE_VIDEO1, 13 },
51 { DRM_FORMAT_NV12, DE_VIDEO1 | SE_MEMWRITE, 14 },
52 { DRM_FORMAT_YUV420, DE_VIDEO1, 15 },
53 { DRM_FORMAT_XYUV8888, DE_VIDEO1, 16 },
54 /* These are supported with AFBC only */
55 { DRM_FORMAT_YUV420_8BIT, DE_VIDEO1, 14 },
56 { DRM_FORMAT_VUY888, DE_VIDEO1, 16 },
57 { DRM_FORMAT_VUY101010, DE_VIDEO1, 17 },
58 { DRM_FORMAT_YUV420_10BIT, DE_VIDEO1, 18 }
59 };
60
61 #define MALIDP_ID(__group, __format) \
62 ((((__group) & 0x7) << 3) | ((__format) & 0x7))
63
64 #define AFBC_YUV_422_FORMAT_ID MALIDP_ID(5, 1)
65
66 #define MALIDP_COMMON_FORMATS \
67 /* fourcc, layers supporting the format, internal id */ \
68 { DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(0, 0) }, \
69 { DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(0, 1) }, \
70 { DRM_FORMAT_RGBA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(0, 2) }, \
71 { DRM_FORMAT_BGRA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(0, 3) }, \
72 { DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 0) }, \
73 { DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 1) }, \
74 { DRM_FORMAT_RGBA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 2) }, \
75 { DRM_FORMAT_BGRA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 3) }, \
76 { DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART | SE_MEMWRITE, MALIDP_ID(2, 0) }, \
77 { DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART | SE_MEMWRITE, MALIDP_ID(2, 1) }, \
78 { DRM_FORMAT_RGBX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART | SE_MEMWRITE, MALIDP_ID(2, 2) }, \
79 { DRM_FORMAT_BGRX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART | SE_MEMWRITE, MALIDP_ID(2, 3) }, \
80 { DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(3, 0) }, \
81 { DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(3, 1) }, \
82 { DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 0) }, \
83 { DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 1) }, \
84 { DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 2) }, \
85 { DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 3) }, \
86 /* This is only supported with linear modifier */ \
87 { DRM_FORMAT_XYUV8888, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 0) },\
88 /* This is only supported with AFBC modifier */ \
89 { DRM_FORMAT_VUY888, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 0) }, \
90 { DRM_FORMAT_YUYV, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 2) }, \
91 /* This is only supported with linear modifier */ \
92 { DRM_FORMAT_UYVY, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 3) }, \
93 { DRM_FORMAT_NV12, DE_VIDEO1 | DE_VIDEO2 | SE_MEMWRITE, MALIDP_ID(5, 6) }, \
94 /* This is only supported with AFBC modifier */ \
95 { DRM_FORMAT_YUV420_8BIT, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 6) }, \
96 { DRM_FORMAT_YUV420, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 7) }, \
97 /* This is only supported with linear modifier */ \
98 { DRM_FORMAT_XVYU2101010, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(6, 0)}, \
99 /* This is only supported with AFBC modifier */ \
100 { DRM_FORMAT_VUY101010, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(6, 0)}, \
101 { DRM_FORMAT_X0L2, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(6, 6)}, \
102 /* This is only supported with AFBC modifier */ \
103 { DRM_FORMAT_YUV420_10BIT, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(6, 7)}, \
104 { DRM_FORMAT_P010, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(6, 7)}
105
106 static const struct malidp_format_id malidp550_de_formats[] = {
107 MALIDP_COMMON_FORMATS,
108 };
109
110 static const struct malidp_format_id malidp650_de_formats[] = {
111 MALIDP_COMMON_FORMATS,
112 { DRM_FORMAT_X0L0, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 4)},
113 };
114
115 static const struct malidp_layer malidp500_layers[] = {
116 /* id, base address, fb pointer address base, stride offset,
117 * yuv2rgb matrix offset, mmu control register offset, rotation_features
118 */
119 { DE_VIDEO1, MALIDP500_DE_LV_BASE, MALIDP500_DE_LV_PTR_BASE,
120 MALIDP_DE_LV_STRIDE0, MALIDP500_LV_YUV2RGB, 0, ROTATE_ANY,
121 MALIDP500_DE_LV_AD_CTRL },
122 { DE_GRAPHICS1, MALIDP500_DE_LG1_BASE, MALIDP500_DE_LG1_PTR_BASE,
123 MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY,
124 MALIDP500_DE_LG1_AD_CTRL },
125 { DE_GRAPHICS2, MALIDP500_DE_LG2_BASE, MALIDP500_DE_LG2_PTR_BASE,
126 MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY,
127 MALIDP500_DE_LG2_AD_CTRL },
128 };
129
130 static const struct malidp_layer malidp550_layers[] = {
131 /* id, base address, fb pointer address base, stride offset,
132 * yuv2rgb matrix offset, mmu control register offset, rotation_features
133 */
134 { DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE,
135 MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, 0, ROTATE_ANY,
136 MALIDP550_DE_LV1_AD_CTRL },
137 { DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE,
138 MALIDP_DE_LG_STRIDE, 0, 0, ROTATE_ANY,
139 MALIDP550_DE_LG_AD_CTRL },
140 { DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE,
141 MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB, 0, ROTATE_ANY,
142 MALIDP550_DE_LV2_AD_CTRL },
143 { DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE,
144 MALIDP550_DE_LS_R1_STRIDE, 0, 0, ROTATE_NONE, 0 },
145 };
146
147 static const struct malidp_layer malidp650_layers[] = {
148 /* id, base address, fb pointer address base, stride offset,
149 * yuv2rgb matrix offset, mmu control register offset,
150 * rotation_features
151 */
152 { DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE,
153 MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB,
154 MALIDP650_DE_LV_MMU_CTRL, ROTATE_ANY,
155 MALIDP550_DE_LV1_AD_CTRL },
156 { DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE,
157 MALIDP_DE_LG_STRIDE, 0, MALIDP650_DE_LG_MMU_CTRL,
158 ROTATE_COMPRESSED, MALIDP550_DE_LG_AD_CTRL },
159 { DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE,
160 MALIDP_DE_LV_STRIDE0, MALIDP550_LV_YUV2RGB,
161 MALIDP650_DE_LV_MMU_CTRL, ROTATE_ANY,
162 MALIDP550_DE_LV2_AD_CTRL },
163 { DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE,
164 MALIDP550_DE_LS_R1_STRIDE, 0, MALIDP650_DE_LS_MMU_CTRL,
165 ROTATE_NONE, 0 },
166 };
167
168 const u64 malidp_format_modifiers[] = {
169 /* All RGB formats (except XRGB, RGBX, XBGR, BGRX) */
170 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_YTR | AFBC_SPARSE),
171 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_YTR),
172
173 /* All RGB formats > 16bpp (except XRGB, RGBX, XBGR, BGRX) */
174 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_YTR | AFBC_SPARSE | AFBC_SPLIT),
175
176 /* All 8 or 10 bit YUV 444 formats. */
177 /* In DP550, 10 bit YUV 420 format also supported */
178 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_SPARSE | AFBC_SPLIT),
179
180 /* YUV 420, 422 P1 8 bit and YUV 444 8 bit/10 bit formats */
181 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_SPARSE),
182 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16),
183
184 /* YUV 420, 422 P1 8, 10 bit formats */
185 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_CBR | AFBC_SPARSE),
186 DRM_FORMAT_MOD_ARM_AFBC(AFBC_SIZE_16X16 | AFBC_CBR),
187
188 /* All formats */
189 DRM_FORMAT_MOD_LINEAR,
190
191 DRM_FORMAT_MOD_INVALID
192 };
193
194 #define SE_N_SCALING_COEFFS 96
195 static const u16 dp500_se_scaling_coeffs[][SE_N_SCALING_COEFFS] = {
196 [MALIDP_UPSCALING_COEFFS - 1] = {
197 0x0000, 0x0001, 0x0007, 0x0011, 0x001e, 0x002e, 0x003f, 0x0052,
198 0x0064, 0x0073, 0x007d, 0x0080, 0x007a, 0x006c, 0x0053, 0x002f,
199 0x0000, 0x3fc6, 0x3f83, 0x3f39, 0x3eea, 0x3e9b, 0x3e4f, 0x3e0a,
200 0x3dd4, 0x3db0, 0x3da2, 0x3db1, 0x3dde, 0x3e2f, 0x3ea5, 0x3f40,
201 0x0000, 0x00e5, 0x01ee, 0x0315, 0x0456, 0x05aa, 0x0709, 0x086c,
202 0x09c9, 0x0b15, 0x0c4a, 0x0d5d, 0x0e4a, 0x0f06, 0x0f91, 0x0fe5,
203 0x1000, 0x0fe5, 0x0f91, 0x0f06, 0x0e4a, 0x0d5d, 0x0c4a, 0x0b15,
204 0x09c9, 0x086c, 0x0709, 0x05aa, 0x0456, 0x0315, 0x01ee, 0x00e5,
205 0x0000, 0x3f40, 0x3ea5, 0x3e2f, 0x3dde, 0x3db1, 0x3da2, 0x3db0,
206 0x3dd4, 0x3e0a, 0x3e4f, 0x3e9b, 0x3eea, 0x3f39, 0x3f83, 0x3fc6,
207 0x0000, 0x002f, 0x0053, 0x006c, 0x007a, 0x0080, 0x007d, 0x0073,
208 0x0064, 0x0052, 0x003f, 0x002e, 0x001e, 0x0011, 0x0007, 0x0001
209 },
210 [MALIDP_DOWNSCALING_1_5_COEFFS - 1] = {
211 0x0059, 0x004f, 0x0041, 0x002e, 0x0016, 0x3ffb, 0x3fd9, 0x3fb4,
212 0x3f8c, 0x3f62, 0x3f36, 0x3f09, 0x3edd, 0x3eb3, 0x3e8d, 0x3e6c,
213 0x3e52, 0x3e3f, 0x3e35, 0x3e37, 0x3e46, 0x3e61, 0x3e8c, 0x3ec5,
214 0x3f0f, 0x3f68, 0x3fd1, 0x004a, 0x00d3, 0x0169, 0x020b, 0x02b8,
215 0x036e, 0x042d, 0x04f2, 0x05b9, 0x0681, 0x0745, 0x0803, 0x08ba,
216 0x0965, 0x0a03, 0x0a91, 0x0b0d, 0x0b75, 0x0bc6, 0x0c00, 0x0c20,
217 0x0c28, 0x0c20, 0x0c00, 0x0bc6, 0x0b75, 0x0b0d, 0x0a91, 0x0a03,
218 0x0965, 0x08ba, 0x0803, 0x0745, 0x0681, 0x05b9, 0x04f2, 0x042d,
219 0x036e, 0x02b8, 0x020b, 0x0169, 0x00d3, 0x004a, 0x3fd1, 0x3f68,
220 0x3f0f, 0x3ec5, 0x3e8c, 0x3e61, 0x3e46, 0x3e37, 0x3e35, 0x3e3f,
221 0x3e52, 0x3e6c, 0x3e8d, 0x3eb3, 0x3edd, 0x3f09, 0x3f36, 0x3f62,
222 0x3f8c, 0x3fb4, 0x3fd9, 0x3ffb, 0x0016, 0x002e, 0x0041, 0x004f
223 },
224 [MALIDP_DOWNSCALING_2_COEFFS - 1] = {
225 0x3f19, 0x3f03, 0x3ef0, 0x3edf, 0x3ed0, 0x3ec5, 0x3ebd, 0x3eb9,
226 0x3eb9, 0x3ebf, 0x3eca, 0x3ed9, 0x3eef, 0x3f0a, 0x3f2c, 0x3f52,
227 0x3f7f, 0x3fb0, 0x3fe8, 0x0026, 0x006a, 0x00b4, 0x0103, 0x0158,
228 0x01b1, 0x020d, 0x026c, 0x02cd, 0x032f, 0x0392, 0x03f4, 0x0455,
229 0x04b4, 0x051e, 0x0585, 0x05eb, 0x064c, 0x06a8, 0x06fe, 0x074e,
230 0x0796, 0x07d5, 0x080c, 0x0839, 0x085c, 0x0875, 0x0882, 0x0887,
231 0x0881, 0x0887, 0x0882, 0x0875, 0x085c, 0x0839, 0x080c, 0x07d5,
232 0x0796, 0x074e, 0x06fe, 0x06a8, 0x064c, 0x05eb, 0x0585, 0x051e,
233 0x04b4, 0x0455, 0x03f4, 0x0392, 0x032f, 0x02cd, 0x026c, 0x020d,
234 0x01b1, 0x0158, 0x0103, 0x00b4, 0x006a, 0x0026, 0x3fe8, 0x3fb0,
235 0x3f7f, 0x3f52, 0x3f2c, 0x3f0a, 0x3eef, 0x3ed9, 0x3eca, 0x3ebf,
236 0x3eb9, 0x3eb9, 0x3ebd, 0x3ec5, 0x3ed0, 0x3edf, 0x3ef0, 0x3f03
237 },
238 [MALIDP_DOWNSCALING_2_75_COEFFS - 1] = {
239 0x3f51, 0x3f60, 0x3f71, 0x3f84, 0x3f98, 0x3faf, 0x3fc8, 0x3fe3,
240 0x0000, 0x001f, 0x0040, 0x0064, 0x008a, 0x00b1, 0x00da, 0x0106,
241 0x0133, 0x0160, 0x018e, 0x01bd, 0x01ec, 0x021d, 0x024e, 0x0280,
242 0x02b2, 0x02e4, 0x0317, 0x0349, 0x037c, 0x03ad, 0x03df, 0x0410,
243 0x0440, 0x0468, 0x048f, 0x04b3, 0x04d6, 0x04f8, 0x0516, 0x0533,
244 0x054e, 0x0566, 0x057c, 0x0590, 0x05a0, 0x05ae, 0x05ba, 0x05c3,
245 0x05c9, 0x05c3, 0x05ba, 0x05ae, 0x05a0, 0x0590, 0x057c, 0x0566,
246 0x054e, 0x0533, 0x0516, 0x04f8, 0x04d6, 0x04b3, 0x048f, 0x0468,
247 0x0440, 0x0410, 0x03df, 0x03ad, 0x037c, 0x0349, 0x0317, 0x02e4,
248 0x02b2, 0x0280, 0x024e, 0x021d, 0x01ec, 0x01bd, 0x018e, 0x0160,
249 0x0133, 0x0106, 0x00da, 0x00b1, 0x008a, 0x0064, 0x0040, 0x001f,
250 0x0000, 0x3fe3, 0x3fc8, 0x3faf, 0x3f98, 0x3f84, 0x3f71, 0x3f60
251 },
252 [MALIDP_DOWNSCALING_4_COEFFS - 1] = {
253 0x0094, 0x00a9, 0x00be, 0x00d4, 0x00ea, 0x0101, 0x0118, 0x012f,
254 0x0148, 0x0160, 0x017a, 0x0193, 0x01ae, 0x01c8, 0x01e4, 0x01ff,
255 0x021c, 0x0233, 0x024a, 0x0261, 0x0278, 0x028f, 0x02a6, 0x02bd,
256 0x02d4, 0x02eb, 0x0302, 0x0319, 0x032f, 0x0346, 0x035d, 0x0374,
257 0x038a, 0x0397, 0x03a3, 0x03af, 0x03bb, 0x03c6, 0x03d1, 0x03db,
258 0x03e4, 0x03ed, 0x03f6, 0x03fe, 0x0406, 0x040d, 0x0414, 0x041a,
259 0x0420, 0x041a, 0x0414, 0x040d, 0x0406, 0x03fe, 0x03f6, 0x03ed,
260 0x03e4, 0x03db, 0x03d1, 0x03c6, 0x03bb, 0x03af, 0x03a3, 0x0397,
261 0x038a, 0x0374, 0x035d, 0x0346, 0x032f, 0x0319, 0x0302, 0x02eb,
262 0x02d4, 0x02bd, 0x02a6, 0x028f, 0x0278, 0x0261, 0x024a, 0x0233,
263 0x021c, 0x01ff, 0x01e4, 0x01c8, 0x01ae, 0x0193, 0x017a, 0x0160,
264 0x0148, 0x012f, 0x0118, 0x0101, 0x00ea, 0x00d4, 0x00be, 0x00a9
265 },
266 };
267
268 #define MALIDP_DE_DEFAULT_PREFETCH_START 5
269
malidp500_query_hw(struct malidp_hw_device * hwdev)270 static int malidp500_query_hw(struct malidp_hw_device *hwdev)
271 {
272 u32 conf = malidp_hw_read(hwdev, MALIDP500_CONFIG_ID);
273 /* bit 4 of the CONFIG_ID register holds the line size multiplier */
274 u8 ln_size_mult = conf & 0x10 ? 2 : 1;
275
276 hwdev->min_line_size = 2;
277 hwdev->max_line_size = SZ_2K * ln_size_mult;
278 hwdev->rotation_memory[0] = SZ_1K * 64 * ln_size_mult;
279 hwdev->rotation_memory[1] = 0; /* no second rotation memory bank */
280
281 return 0;
282 }
283
malidp500_enter_config_mode(struct malidp_hw_device * hwdev)284 static void malidp500_enter_config_mode(struct malidp_hw_device *hwdev)
285 {
286 u32 status, count = 100;
287
288 malidp_hw_setbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
289 while (count) {
290 status = malidp_hw_read(hwdev, hwdev->hw->map.dc_base + MALIDP_REG_STATUS);
291 if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
292 break;
293 /*
294 * entering config mode can take as long as the rendering
295 * of a full frame, hence the long sleep here
296 */
297 usleep_range(1000, 10000);
298 count--;
299 }
300 WARN(count == 0, "timeout while entering config mode");
301 }
302
malidp500_leave_config_mode(struct malidp_hw_device * hwdev)303 static void malidp500_leave_config_mode(struct malidp_hw_device *hwdev)
304 {
305 u32 status, count = 100;
306
307 malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
308 malidp_hw_clearbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
309 while (count) {
310 status = malidp_hw_read(hwdev, hwdev->hw->map.dc_base + MALIDP_REG_STATUS);
311 if ((status & MALIDP500_DC_CONFIG_REQ) == 0)
312 break;
313 usleep_range(100, 1000);
314 count--;
315 }
316 WARN(count == 0, "timeout while leaving config mode");
317 }
318
malidp500_in_config_mode(struct malidp_hw_device * hwdev)319 static bool malidp500_in_config_mode(struct malidp_hw_device *hwdev)
320 {
321 u32 status;
322
323 status = malidp_hw_read(hwdev, hwdev->hw->map.dc_base + MALIDP_REG_STATUS);
324 if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
325 return true;
326
327 return false;
328 }
329
malidp500_set_config_valid(struct malidp_hw_device * hwdev,u8 value)330 static void malidp500_set_config_valid(struct malidp_hw_device *hwdev, u8 value)
331 {
332 if (value)
333 malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
334 else
335 malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
336 }
337
malidp500_modeset(struct malidp_hw_device * hwdev,struct videomode * mode)338 static void malidp500_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
339 {
340 u32 val = 0;
341
342 malidp_hw_write(hwdev, hwdev->output_color_depth,
343 hwdev->hw->map.out_depth_base);
344 malidp_hw_clearbits(hwdev, MALIDP500_DC_CLEAR_MASK, MALIDP500_DC_CONTROL);
345 if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
346 val |= MALIDP500_HSYNCPOL;
347 if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
348 val |= MALIDP500_VSYNCPOL;
349 val |= MALIDP_DE_DEFAULT_PREFETCH_START;
350 malidp_hw_setbits(hwdev, val, MALIDP500_DC_CONTROL);
351
352 /*
353 * Mali-DP500 encodes the background color like this:
354 * - red @ MALIDP500_BGND_COLOR[12:0]
355 * - green @ MALIDP500_BGND_COLOR[27:16]
356 * - blue @ (MALIDP500_BGND_COLOR + 4)[12:0]
357 */
358 val = ((MALIDP_BGND_COLOR_G & 0xfff) << 16) |
359 (MALIDP_BGND_COLOR_R & 0xfff);
360 malidp_hw_write(hwdev, val, MALIDP500_BGND_COLOR);
361 malidp_hw_write(hwdev, MALIDP_BGND_COLOR_B, MALIDP500_BGND_COLOR + 4);
362
363 val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
364 MALIDP_DE_H_BACKPORCH(mode->hback_porch);
365 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
366
367 val = MALIDP500_DE_V_FRONTPORCH(mode->vfront_porch) |
368 MALIDP_DE_V_BACKPORCH(mode->vback_porch);
369 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
370
371 val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
372 MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
373 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
374
375 val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
376 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
377
378 if (mode->flags & DISPLAY_FLAGS_INTERLACED)
379 malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
380 else
381 malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
382
383 /*
384 * Program the RQoS register to avoid high resolutions flicker
385 * issue on the LS1028A.
386 */
387 if (hwdev->arqos_value) {
388 val = hwdev->arqos_value;
389 malidp_hw_setbits(hwdev, val, MALIDP500_RQOS_QUALITY);
390 }
391 }
392
malidp_format_get_bpp(u32 fmt)393 int malidp_format_get_bpp(u32 fmt)
394 {
395 const struct drm_format_info *info = drm_format_info(fmt);
396 int bpp = info->cpp[0] * 8;
397
398 if (bpp == 0) {
399 switch (fmt) {
400 case DRM_FORMAT_VUY101010:
401 bpp = 30;
402 break;
403 case DRM_FORMAT_YUV420_10BIT:
404 bpp = 15;
405 break;
406 case DRM_FORMAT_YUV420_8BIT:
407 bpp = 12;
408 break;
409 default:
410 bpp = 0;
411 }
412 }
413
414 return bpp;
415 }
416
malidp500_rotmem_required(struct malidp_hw_device * hwdev,u16 w,u16 h,u32 fmt,bool has_modifier)417 static int malidp500_rotmem_required(struct malidp_hw_device *hwdev, u16 w,
418 u16 h, u32 fmt, bool has_modifier)
419 {
420 /*
421 * Each layer needs enough rotation memory to fit 8 lines
422 * worth of pixel data. Required size is then:
423 * size = rotated_width * (bpp / 8) * 8;
424 */
425 int bpp = malidp_format_get_bpp(fmt);
426
427 return w * bpp;
428 }
429
malidp500_se_write_pp_coefftab(struct malidp_hw_device * hwdev,u32 direction,u16 addr,u8 coeffs_id)430 static void malidp500_se_write_pp_coefftab(struct malidp_hw_device *hwdev,
431 u32 direction,
432 u16 addr,
433 u8 coeffs_id)
434 {
435 int i;
436 u16 scaling_control = MALIDP500_SE_CONTROL + MALIDP_SE_SCALING_CONTROL;
437
438 malidp_hw_write(hwdev,
439 direction | (addr & MALIDP_SE_COEFFTAB_ADDR_MASK),
440 scaling_control + MALIDP_SE_COEFFTAB_ADDR);
441 for (i = 0; i < ARRAY_SIZE(dp500_se_scaling_coeffs); ++i)
442 malidp_hw_write(hwdev, MALIDP_SE_SET_COEFFTAB_DATA(
443 dp500_se_scaling_coeffs[coeffs_id][i]),
444 scaling_control + MALIDP_SE_COEFFTAB_DATA);
445 }
446
malidp500_se_set_scaling_coeffs(struct malidp_hw_device * hwdev,struct malidp_se_config * se_config,struct malidp_se_config * old_config)447 static int malidp500_se_set_scaling_coeffs(struct malidp_hw_device *hwdev,
448 struct malidp_se_config *se_config,
449 struct malidp_se_config *old_config)
450 {
451 /* Get array indices into dp500_se_scaling_coeffs. */
452 u8 h = (u8)se_config->hcoeff - 1;
453 u8 v = (u8)se_config->vcoeff - 1;
454
455 if (WARN_ON(h >= ARRAY_SIZE(dp500_se_scaling_coeffs) ||
456 v >= ARRAY_SIZE(dp500_se_scaling_coeffs)))
457 return -EINVAL;
458
459 if ((h == v) && (se_config->hcoeff != old_config->hcoeff ||
460 se_config->vcoeff != old_config->vcoeff)) {
461 malidp500_se_write_pp_coefftab(hwdev,
462 (MALIDP_SE_V_COEFFTAB |
463 MALIDP_SE_H_COEFFTAB),
464 0, v);
465 } else {
466 if (se_config->vcoeff != old_config->vcoeff)
467 malidp500_se_write_pp_coefftab(hwdev,
468 MALIDP_SE_V_COEFFTAB,
469 0, v);
470 if (se_config->hcoeff != old_config->hcoeff)
471 malidp500_se_write_pp_coefftab(hwdev,
472 MALIDP_SE_H_COEFFTAB,
473 0, h);
474 }
475
476 return 0;
477 }
478
malidp500_se_calc_mclk(struct malidp_hw_device * hwdev,struct malidp_se_config * se_config,struct videomode * vm)479 static long malidp500_se_calc_mclk(struct malidp_hw_device *hwdev,
480 struct malidp_se_config *se_config,
481 struct videomode *vm)
482 {
483 unsigned long mclk;
484 unsigned long pxlclk = vm->pixelclock; /* Hz */
485 unsigned long htotal = vm->hactive + vm->hfront_porch +
486 vm->hback_porch + vm->hsync_len;
487 unsigned long input_size = se_config->input_w * se_config->input_h;
488 unsigned long a = 10;
489 long ret;
490
491 /*
492 * mclk = max(a, 1.5) * pxlclk
493 *
494 * To avoid float calculaiton, using 15 instead of 1.5 and div by
495 * 10 to get mclk.
496 */
497 if (se_config->scale_enable) {
498 a = 15 * input_size / (htotal * se_config->output_h);
499 if (a < 15)
500 a = 15;
501 }
502 mclk = a * pxlclk / 10;
503 ret = clk_get_rate(hwdev->mclk);
504 if (ret < mclk) {
505 DRM_DEBUG_DRIVER("mclk requirement of %lu kHz can't be met.\n",
506 mclk / 1000);
507 return -EINVAL;
508 }
509 return ret;
510 }
511
malidp500_enable_memwrite(struct malidp_hw_device * hwdev,dma_addr_t * addrs,s32 * pitches,int num_planes,u16 w,u16 h,u32 fmt_id,const s16 * rgb2yuv_coeffs)512 static int malidp500_enable_memwrite(struct malidp_hw_device *hwdev,
513 dma_addr_t *addrs, s32 *pitches,
514 int num_planes, u16 w, u16 h, u32 fmt_id,
515 const s16 *rgb2yuv_coeffs)
516 {
517 u32 base = MALIDP500_SE_MEMWRITE_BASE;
518 u32 de_base = malidp_get_block_base(hwdev, MALIDP_DE_BLOCK);
519
520 /* enable the scaling engine block */
521 malidp_hw_setbits(hwdev, MALIDP_SCALE_ENGINE_EN, de_base + MALIDP_DE_DISPLAY_FUNC);
522
523 /* restart the writeback if already enabled */
524 if (hwdev->mw_state != MW_NOT_ENABLED)
525 hwdev->mw_state = MW_RESTART;
526 else
527 hwdev->mw_state = MW_START;
528
529 malidp_hw_write(hwdev, fmt_id, base + MALIDP_MW_FORMAT);
530 switch (num_planes) {
531 case 2:
532 malidp_hw_write(hwdev, lower_32_bits(addrs[1]), base + MALIDP_MW_P2_PTR_LOW);
533 malidp_hw_write(hwdev, upper_32_bits(addrs[1]), base + MALIDP_MW_P2_PTR_HIGH);
534 malidp_hw_write(hwdev, pitches[1], base + MALIDP_MW_P2_STRIDE);
535 fallthrough;
536 case 1:
537 malidp_hw_write(hwdev, lower_32_bits(addrs[0]), base + MALIDP_MW_P1_PTR_LOW);
538 malidp_hw_write(hwdev, upper_32_bits(addrs[0]), base + MALIDP_MW_P1_PTR_HIGH);
539 malidp_hw_write(hwdev, pitches[0], base + MALIDP_MW_P1_STRIDE);
540 break;
541 default:
542 WARN(1, "Invalid number of planes");
543 }
544
545 malidp_hw_write(hwdev, MALIDP_DE_H_ACTIVE(w) | MALIDP_DE_V_ACTIVE(h),
546 MALIDP500_SE_MEMWRITE_OUT_SIZE);
547
548 if (rgb2yuv_coeffs) {
549 int i;
550
551 for (i = 0; i < MALIDP_COLORADJ_NUM_COEFFS; i++) {
552 malidp_hw_write(hwdev, rgb2yuv_coeffs[i],
553 MALIDP500_SE_RGB_YUV_COEFFS + i * 4);
554 }
555 }
556
557 malidp_hw_setbits(hwdev, MALIDP_SE_MEMWRITE_EN, MALIDP500_SE_CONTROL);
558
559 return 0;
560 }
561
malidp500_disable_memwrite(struct malidp_hw_device * hwdev)562 static void malidp500_disable_memwrite(struct malidp_hw_device *hwdev)
563 {
564 u32 base = malidp_get_block_base(hwdev, MALIDP_DE_BLOCK);
565
566 if (hwdev->mw_state == MW_START || hwdev->mw_state == MW_RESTART)
567 hwdev->mw_state = MW_STOP;
568 malidp_hw_clearbits(hwdev, MALIDP_SE_MEMWRITE_EN, MALIDP500_SE_CONTROL);
569 malidp_hw_clearbits(hwdev, MALIDP_SCALE_ENGINE_EN, base + MALIDP_DE_DISPLAY_FUNC);
570 }
571
malidp550_query_hw(struct malidp_hw_device * hwdev)572 static int malidp550_query_hw(struct malidp_hw_device *hwdev)
573 {
574 u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
575 u8 ln_size = (conf >> 4) & 0x3, rsize;
576
577 hwdev->min_line_size = 2;
578
579 switch (ln_size) {
580 case 0:
581 hwdev->max_line_size = SZ_2K;
582 /* two banks of 64KB for rotation memory */
583 rsize = 64;
584 break;
585 case 1:
586 hwdev->max_line_size = SZ_4K;
587 /* two banks of 128KB for rotation memory */
588 rsize = 128;
589 break;
590 case 2:
591 hwdev->max_line_size = 1280;
592 /* two banks of 40KB for rotation memory */
593 rsize = 40;
594 break;
595 case 3:
596 /* reserved value */
597 hwdev->max_line_size = 0;
598 return -EINVAL;
599 }
600
601 hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
602 return 0;
603 }
604
malidp550_enter_config_mode(struct malidp_hw_device * hwdev)605 static void malidp550_enter_config_mode(struct malidp_hw_device *hwdev)
606 {
607 u32 status, count = 100;
608
609 malidp_hw_setbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
610 while (count) {
611 status = malidp_hw_read(hwdev, hwdev->hw->map.dc_base + MALIDP_REG_STATUS);
612 if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
613 break;
614 /*
615 * entering config mode can take as long as the rendering
616 * of a full frame, hence the long sleep here
617 */
618 usleep_range(1000, 10000);
619 count--;
620 }
621 WARN(count == 0, "timeout while entering config mode");
622 }
623
malidp550_leave_config_mode(struct malidp_hw_device * hwdev)624 static void malidp550_leave_config_mode(struct malidp_hw_device *hwdev)
625 {
626 u32 status, count = 100;
627
628 malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
629 malidp_hw_clearbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
630 while (count) {
631 status = malidp_hw_read(hwdev, hwdev->hw->map.dc_base + MALIDP_REG_STATUS);
632 if ((status & MALIDP550_DC_CONFIG_REQ) == 0)
633 break;
634 usleep_range(100, 1000);
635 count--;
636 }
637 WARN(count == 0, "timeout while leaving config mode");
638 }
639
malidp550_in_config_mode(struct malidp_hw_device * hwdev)640 static bool malidp550_in_config_mode(struct malidp_hw_device *hwdev)
641 {
642 u32 status;
643
644 status = malidp_hw_read(hwdev, hwdev->hw->map.dc_base + MALIDP_REG_STATUS);
645 if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
646 return true;
647
648 return false;
649 }
650
malidp550_set_config_valid(struct malidp_hw_device * hwdev,u8 value)651 static void malidp550_set_config_valid(struct malidp_hw_device *hwdev, u8 value)
652 {
653 if (value)
654 malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
655 else
656 malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
657 }
658
malidp550_modeset(struct malidp_hw_device * hwdev,struct videomode * mode)659 static void malidp550_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
660 {
661 u32 val = MALIDP_DE_DEFAULT_PREFETCH_START;
662
663 malidp_hw_write(hwdev, hwdev->output_color_depth,
664 hwdev->hw->map.out_depth_base);
665 malidp_hw_write(hwdev, val, MALIDP550_DE_CONTROL);
666 /*
667 * Mali-DP550 and Mali-DP650 encode the background color like this:
668 * - red @ MALIDP550_DE_BGND_COLOR[23:16]
669 * - green @ MALIDP550_DE_BGND_COLOR[15:8]
670 * - blue @ MALIDP550_DE_BGND_COLOR[7:0]
671 *
672 * We need to truncate the least significant 4 bits from the default
673 * MALIDP_BGND_COLOR_x values
674 */
675 val = (((MALIDP_BGND_COLOR_R >> 4) & 0xff) << 16) |
676 (((MALIDP_BGND_COLOR_G >> 4) & 0xff) << 8) |
677 ((MALIDP_BGND_COLOR_B >> 4) & 0xff);
678 malidp_hw_write(hwdev, val, MALIDP550_DE_BGND_COLOR);
679
680 val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
681 MALIDP_DE_H_BACKPORCH(mode->hback_porch);
682 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
683
684 val = MALIDP550_DE_V_FRONTPORCH(mode->vfront_porch) |
685 MALIDP_DE_V_BACKPORCH(mode->vback_porch);
686 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
687
688 val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
689 MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
690 if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
691 val |= MALIDP550_HSYNCPOL;
692 if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
693 val |= MALIDP550_VSYNCPOL;
694 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
695
696 val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
697 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
698
699 if (mode->flags & DISPLAY_FLAGS_INTERLACED)
700 malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
701 else
702 malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
703 }
704
malidpx50_get_bytes_per_column(u32 fmt)705 static int malidpx50_get_bytes_per_column(u32 fmt)
706 {
707 u32 bytes_per_column;
708
709 switch (fmt) {
710 /* 8 lines at 4 bytes per pixel */
711 case DRM_FORMAT_ARGB2101010:
712 case DRM_FORMAT_ABGR2101010:
713 case DRM_FORMAT_RGBA1010102:
714 case DRM_FORMAT_BGRA1010102:
715 case DRM_FORMAT_ARGB8888:
716 case DRM_FORMAT_ABGR8888:
717 case DRM_FORMAT_RGBA8888:
718 case DRM_FORMAT_BGRA8888:
719 case DRM_FORMAT_XRGB8888:
720 case DRM_FORMAT_XBGR8888:
721 case DRM_FORMAT_RGBX8888:
722 case DRM_FORMAT_BGRX8888:
723 case DRM_FORMAT_RGB888:
724 case DRM_FORMAT_BGR888:
725 /* 16 lines at 2 bytes per pixel */
726 case DRM_FORMAT_RGBA5551:
727 case DRM_FORMAT_ABGR1555:
728 case DRM_FORMAT_RGB565:
729 case DRM_FORMAT_BGR565:
730 case DRM_FORMAT_UYVY:
731 case DRM_FORMAT_YUYV:
732 case DRM_FORMAT_X0L0:
733 bytes_per_column = 32;
734 break;
735 /* 16 lines at 1.5 bytes per pixel */
736 case DRM_FORMAT_NV12:
737 case DRM_FORMAT_YUV420:
738 /* 8 lines at 3 bytes per pixel */
739 case DRM_FORMAT_VUY888:
740 /* 16 lines at 12 bits per pixel */
741 case DRM_FORMAT_YUV420_8BIT:
742 /* 8 lines at 3 bytes per pixel */
743 case DRM_FORMAT_P010:
744 bytes_per_column = 24;
745 break;
746 /* 8 lines at 30 bits per pixel */
747 case DRM_FORMAT_VUY101010:
748 /* 16 lines at 15 bits per pixel */
749 case DRM_FORMAT_YUV420_10BIT:
750 bytes_per_column = 30;
751 break;
752 default:
753 return -EINVAL;
754 }
755
756 return bytes_per_column;
757 }
758
malidp550_rotmem_required(struct malidp_hw_device * hwdev,u16 w,u16 h,u32 fmt,bool has_modifier)759 static int malidp550_rotmem_required(struct malidp_hw_device *hwdev, u16 w,
760 u16 h, u32 fmt, bool has_modifier)
761 {
762 int bytes_per_column = 0;
763
764 switch (fmt) {
765 /* 8 lines at 15 bits per pixel */
766 case DRM_FORMAT_YUV420_10BIT:
767 bytes_per_column = 15;
768 break;
769 /* Uncompressed YUV 420 10 bit single plane cannot be rotated */
770 case DRM_FORMAT_X0L2:
771 if (has_modifier)
772 bytes_per_column = 8;
773 else
774 return -EINVAL;
775 break;
776 default:
777 bytes_per_column = malidpx50_get_bytes_per_column(fmt);
778 }
779
780 if (bytes_per_column == -EINVAL)
781 return bytes_per_column;
782
783 return w * bytes_per_column;
784 }
785
malidp650_rotmem_required(struct malidp_hw_device * hwdev,u16 w,u16 h,u32 fmt,bool has_modifier)786 static int malidp650_rotmem_required(struct malidp_hw_device *hwdev, u16 w,
787 u16 h, u32 fmt, bool has_modifier)
788 {
789 int bytes_per_column = 0;
790
791 switch (fmt) {
792 /* 16 lines at 2 bytes per pixel */
793 case DRM_FORMAT_X0L2:
794 bytes_per_column = 32;
795 break;
796 default:
797 bytes_per_column = malidpx50_get_bytes_per_column(fmt);
798 }
799
800 if (bytes_per_column == -EINVAL)
801 return bytes_per_column;
802
803 return w * bytes_per_column;
804 }
805
malidp550_se_set_scaling_coeffs(struct malidp_hw_device * hwdev,struct malidp_se_config * se_config,struct malidp_se_config * old_config)806 static int malidp550_se_set_scaling_coeffs(struct malidp_hw_device *hwdev,
807 struct malidp_se_config *se_config,
808 struct malidp_se_config *old_config)
809 {
810 u32 mask = MALIDP550_SE_CTL_VCSEL(MALIDP550_SE_CTL_SEL_MASK) |
811 MALIDP550_SE_CTL_HCSEL(MALIDP550_SE_CTL_SEL_MASK);
812 u32 new_value = MALIDP550_SE_CTL_VCSEL(se_config->vcoeff) |
813 MALIDP550_SE_CTL_HCSEL(se_config->hcoeff);
814
815 malidp_hw_clearbits(hwdev, mask, MALIDP550_SE_CONTROL);
816 malidp_hw_setbits(hwdev, new_value, MALIDP550_SE_CONTROL);
817 return 0;
818 }
819
malidp550_se_calc_mclk(struct malidp_hw_device * hwdev,struct malidp_se_config * se_config,struct videomode * vm)820 static long malidp550_se_calc_mclk(struct malidp_hw_device *hwdev,
821 struct malidp_se_config *se_config,
822 struct videomode *vm)
823 {
824 unsigned long mclk;
825 unsigned long pxlclk = vm->pixelclock;
826 unsigned long htotal = vm->hactive + vm->hfront_porch +
827 vm->hback_porch + vm->hsync_len;
828 unsigned long numerator = 1, denominator = 1;
829 long ret;
830
831 if (se_config->scale_enable) {
832 numerator = max(se_config->input_w, se_config->output_w) *
833 se_config->input_h;
834 numerator += se_config->output_w *
835 (se_config->output_h -
836 min(se_config->input_h, se_config->output_h));
837 denominator = (htotal - 2) * se_config->output_h;
838 }
839
840 /* mclk can't be slower than pxlclk. */
841 if (numerator < denominator)
842 numerator = denominator = 1;
843 mclk = (pxlclk * numerator) / denominator;
844 ret = clk_get_rate(hwdev->mclk);
845 if (ret < mclk) {
846 DRM_DEBUG_DRIVER("mclk requirement of %lu kHz can't be met.\n",
847 mclk / 1000);
848 return -EINVAL;
849 }
850 return ret;
851 }
852
malidp550_enable_memwrite(struct malidp_hw_device * hwdev,dma_addr_t * addrs,s32 * pitches,int num_planes,u16 w,u16 h,u32 fmt_id,const s16 * rgb2yuv_coeffs)853 static int malidp550_enable_memwrite(struct malidp_hw_device *hwdev,
854 dma_addr_t *addrs, s32 *pitches,
855 int num_planes, u16 w, u16 h, u32 fmt_id,
856 const s16 *rgb2yuv_coeffs)
857 {
858 u32 base = MALIDP550_SE_MEMWRITE_BASE;
859 u32 de_base = malidp_get_block_base(hwdev, MALIDP_DE_BLOCK);
860
861 /* enable the scaling engine block */
862 malidp_hw_setbits(hwdev, MALIDP_SCALE_ENGINE_EN, de_base + MALIDP_DE_DISPLAY_FUNC);
863
864 hwdev->mw_state = MW_ONESHOT;
865
866 malidp_hw_write(hwdev, fmt_id, base + MALIDP_MW_FORMAT);
867 switch (num_planes) {
868 case 2:
869 malidp_hw_write(hwdev, lower_32_bits(addrs[1]), base + MALIDP_MW_P2_PTR_LOW);
870 malidp_hw_write(hwdev, upper_32_bits(addrs[1]), base + MALIDP_MW_P2_PTR_HIGH);
871 malidp_hw_write(hwdev, pitches[1], base + MALIDP_MW_P2_STRIDE);
872 fallthrough;
873 case 1:
874 malidp_hw_write(hwdev, lower_32_bits(addrs[0]), base + MALIDP_MW_P1_PTR_LOW);
875 malidp_hw_write(hwdev, upper_32_bits(addrs[0]), base + MALIDP_MW_P1_PTR_HIGH);
876 malidp_hw_write(hwdev, pitches[0], base + MALIDP_MW_P1_STRIDE);
877 break;
878 default:
879 WARN(1, "Invalid number of planes");
880 }
881
882 malidp_hw_write(hwdev, MALIDP_DE_H_ACTIVE(w) | MALIDP_DE_V_ACTIVE(h),
883 MALIDP550_SE_MEMWRITE_OUT_SIZE);
884 malidp_hw_setbits(hwdev, MALIDP550_SE_MEMWRITE_ONESHOT | MALIDP_SE_MEMWRITE_EN,
885 MALIDP550_SE_CONTROL);
886
887 if (rgb2yuv_coeffs) {
888 int i;
889
890 for (i = 0; i < MALIDP_COLORADJ_NUM_COEFFS; i++) {
891 malidp_hw_write(hwdev, rgb2yuv_coeffs[i],
892 MALIDP550_SE_RGB_YUV_COEFFS + i * 4);
893 }
894 }
895
896 return 0;
897 }
898
malidp550_disable_memwrite(struct malidp_hw_device * hwdev)899 static void malidp550_disable_memwrite(struct malidp_hw_device *hwdev)
900 {
901 u32 base = malidp_get_block_base(hwdev, MALIDP_DE_BLOCK);
902
903 malidp_hw_clearbits(hwdev, MALIDP550_SE_MEMWRITE_ONESHOT | MALIDP_SE_MEMWRITE_EN,
904 MALIDP550_SE_CONTROL);
905 malidp_hw_clearbits(hwdev, MALIDP_SCALE_ENGINE_EN, base + MALIDP_DE_DISPLAY_FUNC);
906 }
907
malidp650_query_hw(struct malidp_hw_device * hwdev)908 static int malidp650_query_hw(struct malidp_hw_device *hwdev)
909 {
910 u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
911 u8 ln_size = (conf >> 4) & 0x3, rsize;
912
913 hwdev->min_line_size = 4;
914
915 switch (ln_size) {
916 case 0:
917 case 2:
918 /* reserved values */
919 hwdev->max_line_size = 0;
920 return -EINVAL;
921 case 1:
922 hwdev->max_line_size = SZ_4K;
923 /* two banks of 128KB for rotation memory */
924 rsize = 128;
925 break;
926 case 3:
927 hwdev->max_line_size = 2560;
928 /* two banks of 80KB for rotation memory */
929 rsize = 80;
930 }
931
932 hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
933 return 0;
934 }
935
936 const struct malidp_hw malidp_device[MALIDP_MAX_DEVICES] = {
937 [MALIDP_500] = {
938 .map = {
939 .coeffs_base = MALIDP500_COEFFS_BASE,
940 .se_base = MALIDP500_SE_BASE,
941 .dc_base = MALIDP500_DC_BASE,
942 .out_depth_base = MALIDP500_OUTPUT_DEPTH,
943 .features = 0, /* no CLEARIRQ register */
944 .n_layers = ARRAY_SIZE(malidp500_layers),
945 .layers = malidp500_layers,
946 .de_irq_map = {
947 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
948 MALIDP500_DE_IRQ_AXI_ERR |
949 MALIDP500_DE_IRQ_VSYNC |
950 MALIDP500_DE_IRQ_GLOBAL,
951 .vsync_irq = MALIDP500_DE_IRQ_VSYNC,
952 .err_mask = MALIDP_DE_IRQ_UNDERRUN |
953 MALIDP500_DE_IRQ_AXI_ERR |
954 MALIDP500_DE_IRQ_SATURATION,
955 },
956 .se_irq_map = {
957 .irq_mask = MALIDP500_SE_IRQ_CONF_MODE |
958 MALIDP500_SE_IRQ_CONF_VALID |
959 MALIDP500_SE_IRQ_GLOBAL,
960 .vsync_irq = MALIDP500_SE_IRQ_CONF_VALID,
961 .err_mask = MALIDP500_SE_IRQ_INIT_BUSY |
962 MALIDP500_SE_IRQ_AXI_ERROR |
963 MALIDP500_SE_IRQ_OVERRUN,
964 },
965 .dc_irq_map = {
966 .irq_mask = MALIDP500_DE_IRQ_CONF_VALID,
967 .vsync_irq = MALIDP500_DE_IRQ_CONF_VALID,
968 },
969 .pixel_formats = malidp500_de_formats,
970 .n_pixel_formats = ARRAY_SIZE(malidp500_de_formats),
971 .bus_align_bytes = 8,
972 },
973 .query_hw = malidp500_query_hw,
974 .enter_config_mode = malidp500_enter_config_mode,
975 .leave_config_mode = malidp500_leave_config_mode,
976 .in_config_mode = malidp500_in_config_mode,
977 .set_config_valid = malidp500_set_config_valid,
978 .modeset = malidp500_modeset,
979 .rotmem_required = malidp500_rotmem_required,
980 .se_set_scaling_coeffs = malidp500_se_set_scaling_coeffs,
981 .se_calc_mclk = malidp500_se_calc_mclk,
982 .enable_memwrite = malidp500_enable_memwrite,
983 .disable_memwrite = malidp500_disable_memwrite,
984 .features = MALIDP_DEVICE_LV_HAS_3_STRIDES,
985 },
986 [MALIDP_550] = {
987 .map = {
988 .coeffs_base = MALIDP550_COEFFS_BASE,
989 .se_base = MALIDP550_SE_BASE,
990 .dc_base = MALIDP550_DC_BASE,
991 .out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
992 .features = MALIDP_REGMAP_HAS_CLEARIRQ |
993 MALIDP_DEVICE_AFBC_SUPPORT_SPLIT |
994 MALIDP_DEVICE_AFBC_YUV_420_10_SUPPORT_SPLIT |
995 MALIDP_DEVICE_AFBC_YUYV_USE_422_P2,
996 .n_layers = ARRAY_SIZE(malidp550_layers),
997 .layers = malidp550_layers,
998 .de_irq_map = {
999 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
1000 MALIDP550_DE_IRQ_VSYNC,
1001 .vsync_irq = MALIDP550_DE_IRQ_VSYNC,
1002 .err_mask = MALIDP_DE_IRQ_UNDERRUN |
1003 MALIDP550_DE_IRQ_SATURATION |
1004 MALIDP550_DE_IRQ_AXI_ERR,
1005 },
1006 .se_irq_map = {
1007 .irq_mask = MALIDP550_SE_IRQ_EOW,
1008 .vsync_irq = MALIDP550_SE_IRQ_EOW,
1009 .err_mask = MALIDP550_SE_IRQ_AXI_ERR |
1010 MALIDP550_SE_IRQ_OVR |
1011 MALIDP550_SE_IRQ_IBSY,
1012 },
1013 .dc_irq_map = {
1014 .irq_mask = MALIDP550_DC_IRQ_CONF_VALID |
1015 MALIDP550_DC_IRQ_SE,
1016 .vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
1017 },
1018 .pixel_formats = malidp550_de_formats,
1019 .n_pixel_formats = ARRAY_SIZE(malidp550_de_formats),
1020 .bus_align_bytes = 8,
1021 },
1022 .query_hw = malidp550_query_hw,
1023 .enter_config_mode = malidp550_enter_config_mode,
1024 .leave_config_mode = malidp550_leave_config_mode,
1025 .in_config_mode = malidp550_in_config_mode,
1026 .set_config_valid = malidp550_set_config_valid,
1027 .modeset = malidp550_modeset,
1028 .rotmem_required = malidp550_rotmem_required,
1029 .se_set_scaling_coeffs = malidp550_se_set_scaling_coeffs,
1030 .se_calc_mclk = malidp550_se_calc_mclk,
1031 .enable_memwrite = malidp550_enable_memwrite,
1032 .disable_memwrite = malidp550_disable_memwrite,
1033 .features = 0,
1034 },
1035 [MALIDP_650] = {
1036 .map = {
1037 .coeffs_base = MALIDP550_COEFFS_BASE,
1038 .se_base = MALIDP550_SE_BASE,
1039 .dc_base = MALIDP550_DC_BASE,
1040 .out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
1041 .features = MALIDP_REGMAP_HAS_CLEARIRQ |
1042 MALIDP_DEVICE_AFBC_SUPPORT_SPLIT |
1043 MALIDP_DEVICE_AFBC_YUYV_USE_422_P2,
1044 .n_layers = ARRAY_SIZE(malidp650_layers),
1045 .layers = malidp650_layers,
1046 .de_irq_map = {
1047 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
1048 MALIDP650_DE_IRQ_DRIFT |
1049 MALIDP550_DE_IRQ_VSYNC,
1050 .vsync_irq = MALIDP550_DE_IRQ_VSYNC,
1051 .err_mask = MALIDP_DE_IRQ_UNDERRUN |
1052 MALIDP650_DE_IRQ_DRIFT |
1053 MALIDP550_DE_IRQ_SATURATION |
1054 MALIDP550_DE_IRQ_AXI_ERR |
1055 MALIDP650_DE_IRQ_ACEV1 |
1056 MALIDP650_DE_IRQ_ACEV2 |
1057 MALIDP650_DE_IRQ_ACEG |
1058 MALIDP650_DE_IRQ_AXIEP,
1059 },
1060 .se_irq_map = {
1061 .irq_mask = MALIDP550_SE_IRQ_EOW,
1062 .vsync_irq = MALIDP550_SE_IRQ_EOW,
1063 .err_mask = MALIDP550_SE_IRQ_AXI_ERR |
1064 MALIDP550_SE_IRQ_OVR |
1065 MALIDP550_SE_IRQ_IBSY,
1066 },
1067 .dc_irq_map = {
1068 .irq_mask = MALIDP550_DC_IRQ_CONF_VALID |
1069 MALIDP550_DC_IRQ_SE,
1070 .vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
1071 },
1072 .pixel_formats = malidp650_de_formats,
1073 .n_pixel_formats = ARRAY_SIZE(malidp650_de_formats),
1074 .bus_align_bytes = 16,
1075 },
1076 .query_hw = malidp650_query_hw,
1077 .enter_config_mode = malidp550_enter_config_mode,
1078 .leave_config_mode = malidp550_leave_config_mode,
1079 .in_config_mode = malidp550_in_config_mode,
1080 .set_config_valid = malidp550_set_config_valid,
1081 .modeset = malidp550_modeset,
1082 .rotmem_required = malidp650_rotmem_required,
1083 .se_set_scaling_coeffs = malidp550_se_set_scaling_coeffs,
1084 .se_calc_mclk = malidp550_se_calc_mclk,
1085 .enable_memwrite = malidp550_enable_memwrite,
1086 .disable_memwrite = malidp550_disable_memwrite,
1087 .features = 0,
1088 },
1089 };
1090
malidp_hw_get_format_id(const struct malidp_hw_regmap * map,u8 layer_id,u32 format,bool has_modifier)1091 u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
1092 u8 layer_id, u32 format, bool has_modifier)
1093 {
1094 unsigned int i;
1095
1096 for (i = 0; i < map->n_pixel_formats; i++) {
1097 if (((map->pixel_formats[i].layer & layer_id) == layer_id) &&
1098 (map->pixel_formats[i].format == format)) {
1099 /*
1100 * In some DP550 and DP650, DRM_FORMAT_YUYV + AFBC modifier
1101 * is supported by a different h/w format id than
1102 * DRM_FORMAT_YUYV (only).
1103 */
1104 if (format == DRM_FORMAT_YUYV &&
1105 (has_modifier) &&
1106 (map->features & MALIDP_DEVICE_AFBC_YUYV_USE_422_P2))
1107 return AFBC_YUV_422_FORMAT_ID;
1108 else
1109 return map->pixel_formats[i].id;
1110 }
1111 }
1112
1113 return MALIDP_INVALID_FORMAT_ID;
1114 }
1115
malidp_hw_format_is_linear_only(u32 format)1116 bool malidp_hw_format_is_linear_only(u32 format)
1117 {
1118 switch (format) {
1119 case DRM_FORMAT_ARGB2101010:
1120 case DRM_FORMAT_RGBA1010102:
1121 case DRM_FORMAT_BGRA1010102:
1122 case DRM_FORMAT_ARGB8888:
1123 case DRM_FORMAT_RGBA8888:
1124 case DRM_FORMAT_BGRA8888:
1125 case DRM_FORMAT_XBGR8888:
1126 case DRM_FORMAT_XRGB8888:
1127 case DRM_FORMAT_RGBX8888:
1128 case DRM_FORMAT_BGRX8888:
1129 case DRM_FORMAT_RGB888:
1130 case DRM_FORMAT_RGB565:
1131 case DRM_FORMAT_ARGB1555:
1132 case DRM_FORMAT_RGBA5551:
1133 case DRM_FORMAT_BGRA5551:
1134 case DRM_FORMAT_UYVY:
1135 case DRM_FORMAT_XYUV8888:
1136 case DRM_FORMAT_XVYU2101010:
1137 case DRM_FORMAT_X0L2:
1138 case DRM_FORMAT_X0L0:
1139 return true;
1140 default:
1141 return false;
1142 }
1143 }
1144
malidp_hw_format_is_afbc_only(u32 format)1145 bool malidp_hw_format_is_afbc_only(u32 format)
1146 {
1147 switch (format) {
1148 case DRM_FORMAT_VUY888:
1149 case DRM_FORMAT_VUY101010:
1150 case DRM_FORMAT_YUV420_8BIT:
1151 case DRM_FORMAT_YUV420_10BIT:
1152 return true;
1153 default:
1154 return false;
1155 }
1156 }
1157
malidp_hw_clear_irq(struct malidp_hw_device * hwdev,u8 block,u32 irq)1158 static void malidp_hw_clear_irq(struct malidp_hw_device *hwdev, u8 block, u32 irq)
1159 {
1160 u32 base = malidp_get_block_base(hwdev, block);
1161
1162 if (hwdev->hw->map.features & MALIDP_REGMAP_HAS_CLEARIRQ)
1163 malidp_hw_write(hwdev, irq, base + MALIDP_REG_CLEARIRQ);
1164 else
1165 malidp_hw_write(hwdev, irq, base + MALIDP_REG_STATUS);
1166 }
1167
malidp_de_irq(int irq,void * arg)1168 static irqreturn_t malidp_de_irq(int irq, void *arg)
1169 {
1170 struct drm_device *drm = arg;
1171 struct malidp_drm *malidp = drm->dev_private;
1172 struct malidp_hw_device *hwdev;
1173 struct malidp_hw *hw;
1174 const struct malidp_irq_map *de;
1175 u32 status, mask, dc_status;
1176 irqreturn_t ret = IRQ_NONE;
1177
1178 hwdev = malidp->dev;
1179 hw = hwdev->hw;
1180 de = &hw->map.de_irq_map;
1181
1182 /*
1183 * if we are suspended it is likely that we were invoked because
1184 * we share an interrupt line with some other driver, don't try
1185 * to read the hardware registers
1186 */
1187 if (hwdev->pm_suspended)
1188 return IRQ_NONE;
1189
1190 /* first handle the config valid IRQ */
1191 dc_status = malidp_hw_read(hwdev, hw->map.dc_base + MALIDP_REG_STATUS);
1192 if (dc_status & hw->map.dc_irq_map.vsync_irq) {
1193 malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, dc_status);
1194 /* do we have a page flip event? */
1195 if (malidp->event != NULL) {
1196 spin_lock(&drm->event_lock);
1197 drm_crtc_send_vblank_event(&malidp->crtc, malidp->event);
1198 malidp->event = NULL;
1199 spin_unlock(&drm->event_lock);
1200 }
1201 atomic_set(&malidp->config_valid, MALIDP_CONFIG_VALID_DONE);
1202 ret = IRQ_WAKE_THREAD;
1203 }
1204
1205 status = malidp_hw_read(hwdev, MALIDP_REG_STATUS);
1206 if (!(status & de->irq_mask))
1207 return ret;
1208
1209 mask = malidp_hw_read(hwdev, MALIDP_REG_MASKIRQ);
1210 /* keep the status of the enabled interrupts, plus the error bits */
1211 status &= (mask | de->err_mask);
1212 if ((status & de->vsync_irq) && malidp->crtc.enabled)
1213 drm_crtc_handle_vblank(&malidp->crtc);
1214
1215 #ifdef CONFIG_DEBUG_FS
1216 if (status & de->err_mask) {
1217 malidp_error(malidp, &malidp->de_errors, status,
1218 drm_crtc_vblank_count(&malidp->crtc));
1219 }
1220 #endif
1221 malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, status);
1222
1223 return (ret == IRQ_NONE) ? IRQ_HANDLED : ret;
1224 }
1225
malidp_de_irq_thread_handler(int irq,void * arg)1226 static irqreturn_t malidp_de_irq_thread_handler(int irq, void *arg)
1227 {
1228 struct drm_device *drm = arg;
1229 struct malidp_drm *malidp = drm->dev_private;
1230
1231 wake_up(&malidp->wq);
1232
1233 return IRQ_HANDLED;
1234 }
1235
malidp_de_irq_hw_init(struct malidp_hw_device * hwdev)1236 void malidp_de_irq_hw_init(struct malidp_hw_device *hwdev)
1237 {
1238 /* ensure interrupts are disabled */
1239 malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
1240 malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
1241 malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
1242 malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
1243
1244 /* first enable the DC block IRQs */
1245 malidp_hw_enable_irq(hwdev, MALIDP_DC_BLOCK,
1246 hwdev->hw->map.dc_irq_map.irq_mask);
1247
1248 /* now enable the DE block IRQs */
1249 malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
1250 hwdev->hw->map.de_irq_map.irq_mask);
1251 }
1252
malidp_de_irq_init(struct drm_device * drm,int irq)1253 int malidp_de_irq_init(struct drm_device *drm, int irq)
1254 {
1255 struct malidp_drm *malidp = drm->dev_private;
1256 struct malidp_hw_device *hwdev = malidp->dev;
1257 int ret;
1258
1259 /* ensure interrupts are disabled */
1260 malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
1261 malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
1262 malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
1263 malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
1264
1265 ret = devm_request_threaded_irq(drm->dev, irq, malidp_de_irq,
1266 malidp_de_irq_thread_handler,
1267 IRQF_SHARED, "malidp-de", drm);
1268 if (ret < 0) {
1269 DRM_ERROR("failed to install DE IRQ handler\n");
1270 return ret;
1271 }
1272
1273 malidp_de_irq_hw_init(hwdev);
1274
1275 return 0;
1276 }
1277
malidp_de_irq_fini(struct malidp_hw_device * hwdev)1278 void malidp_de_irq_fini(struct malidp_hw_device *hwdev)
1279 {
1280 malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
1281 hwdev->hw->map.de_irq_map.irq_mask);
1282 malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK,
1283 hwdev->hw->map.dc_irq_map.irq_mask);
1284 }
1285
malidp_se_irq(int irq,void * arg)1286 static irqreturn_t malidp_se_irq(int irq, void *arg)
1287 {
1288 struct drm_device *drm = arg;
1289 struct malidp_drm *malidp = drm->dev_private;
1290 struct malidp_hw_device *hwdev = malidp->dev;
1291 struct malidp_hw *hw = hwdev->hw;
1292 const struct malidp_irq_map *se = &hw->map.se_irq_map;
1293 u32 status, mask;
1294
1295 /*
1296 * if we are suspended it is likely that we were invoked because
1297 * we share an interrupt line with some other driver, don't try
1298 * to read the hardware registers
1299 */
1300 if (hwdev->pm_suspended)
1301 return IRQ_NONE;
1302
1303 status = malidp_hw_read(hwdev, hw->map.se_base + MALIDP_REG_STATUS);
1304 if (!(status & (se->irq_mask | se->err_mask)))
1305 return IRQ_NONE;
1306
1307 #ifdef CONFIG_DEBUG_FS
1308 if (status & se->err_mask)
1309 malidp_error(malidp, &malidp->se_errors, status,
1310 drm_crtc_vblank_count(&malidp->crtc));
1311 #endif
1312 mask = malidp_hw_read(hwdev, hw->map.se_base + MALIDP_REG_MASKIRQ);
1313 status &= mask;
1314
1315 if (status & se->vsync_irq) {
1316 switch (hwdev->mw_state) {
1317 case MW_ONESHOT:
1318 drm_writeback_signal_completion(&malidp->mw_connector, 0);
1319 break;
1320 case MW_STOP:
1321 drm_writeback_signal_completion(&malidp->mw_connector, 0);
1322 /* disable writeback after stop */
1323 hwdev->mw_state = MW_NOT_ENABLED;
1324 break;
1325 case MW_RESTART:
1326 drm_writeback_signal_completion(&malidp->mw_connector, 0);
1327 fallthrough; /* to a new start */
1328 case MW_START:
1329 /* writeback started, need to emulate one-shot mode */
1330 hw->disable_memwrite(hwdev);
1331 /*
1332 * only set config_valid HW bit if there is no other update
1333 * in progress or if we raced ahead of the DE IRQ handler
1334 * and config_valid flag will not be update until later
1335 */
1336 status = malidp_hw_read(hwdev, hw->map.dc_base + MALIDP_REG_STATUS);
1337 if ((atomic_read(&malidp->config_valid) != MALIDP_CONFIG_START) ||
1338 (status & hw->map.dc_irq_map.vsync_irq))
1339 hw->set_config_valid(hwdev, 1);
1340 break;
1341 }
1342 }
1343
1344 malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, status);
1345
1346 return IRQ_HANDLED;
1347 }
1348
malidp_se_irq_hw_init(struct malidp_hw_device * hwdev)1349 void malidp_se_irq_hw_init(struct malidp_hw_device *hwdev)
1350 {
1351 /* ensure interrupts are disabled */
1352 malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
1353 malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
1354
1355 malidp_hw_enable_irq(hwdev, MALIDP_SE_BLOCK,
1356 hwdev->hw->map.se_irq_map.irq_mask);
1357 }
1358
malidp_se_irq_thread_handler(int irq,void * arg)1359 static irqreturn_t malidp_se_irq_thread_handler(int irq, void *arg)
1360 {
1361 return IRQ_HANDLED;
1362 }
1363
malidp_se_irq_init(struct drm_device * drm,int irq)1364 int malidp_se_irq_init(struct drm_device *drm, int irq)
1365 {
1366 struct malidp_drm *malidp = drm->dev_private;
1367 struct malidp_hw_device *hwdev = malidp->dev;
1368 int ret;
1369
1370 /* ensure interrupts are disabled */
1371 malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
1372 malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
1373
1374 ret = devm_request_threaded_irq(drm->dev, irq, malidp_se_irq,
1375 malidp_se_irq_thread_handler,
1376 IRQF_SHARED, "malidp-se", drm);
1377 if (ret < 0) {
1378 DRM_ERROR("failed to install SE IRQ handler\n");
1379 return ret;
1380 }
1381
1382 hwdev->mw_state = MW_NOT_ENABLED;
1383 malidp_se_irq_hw_init(hwdev);
1384
1385 return 0;
1386 }
1387
malidp_se_irq_fini(struct malidp_hw_device * hwdev)1388 void malidp_se_irq_fini(struct malidp_hw_device *hwdev)
1389 {
1390 malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK,
1391 hwdev->hw->map.se_irq_map.irq_mask);
1392 }
1393
