?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/exynos: Stop using drm_framebuffer_unregister_private
[linux/fpc-iii.git] / drivers / gpu / drm / arm / malidp_hw.c
blob4bdf531f78440fa8f124017dd4517c1aaf488333
1 /*
2 * (C) COPYRIGHT 2016 ARM Limited. All rights reserved.
3 * Author: Liviu Dudau <Liviu.Dudau@arm.com>
4 *
5 * This program is free software and is provided to you under the terms of the
6 * GNU General Public License version 2 as published by the Free Software
7 * Foundation, and any use by you of this program is subject to the terms
8 * of such GNU licence.
9 *
10 * ARM Mali DP500/DP550/DP650 hardware manipulation routines. This is where
11 * the difference between various versions of the hardware is being dealt with
12 * in an attempt to provide to the rest of the driver code a unified view
13 */
14
15 #include <linux/types.h>
16 #include <linux/io.h>
17 #include <drm/drmP.h>
18 #include <video/videomode.h>
19 #include <video/display_timing.h>
20
21 #include "malidp_drv.h"
22 #include "malidp_hw.h"
23
24 static const struct malidp_input_format malidp500_de_formats[] = {
25 /* fourcc, layers supporting the format, internal id */
26 { DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 0 },
27 { DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 1 },
28 { DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 2 },
29 { DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 3 },
30 { DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 4 },
31 { DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 5 },
32 { DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 6 },
33 { DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 7 },
34 { DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 8 },
35 { DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 9 },
36 { DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 10 },
37 { DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_GRAPHICS2, 11 },
38 { DRM_FORMAT_UYVY, DE_VIDEO1, 12 },
39 { DRM_FORMAT_YUYV, DE_VIDEO1, 13 },
40 { DRM_FORMAT_NV12, DE_VIDEO1, 14 },
41 { DRM_FORMAT_YUV420, DE_VIDEO1, 15 },
42 };
43
44 #define MALIDP_ID(__group, __format) \
45 ((((__group) & 0x7) << 3) | ((__format) & 0x7))
46
47 #define MALIDP_COMMON_FORMATS \
48 /* fourcc, layers supporting the format, internal id */ \
49 { DRM_FORMAT_ARGB2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 0) }, \
50 { DRM_FORMAT_ABGR2101010, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 1) }, \
51 { DRM_FORMAT_RGBA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 2) }, \
52 { DRM_FORMAT_BGRA1010102, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(0, 3) }, \
53 { DRM_FORMAT_ARGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 0) }, \
54 { DRM_FORMAT_ABGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 1) }, \
55 { DRM_FORMAT_RGBA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 2) }, \
56 { DRM_FORMAT_BGRA8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(1, 3) }, \
57 { DRM_FORMAT_XRGB8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 0) }, \
58 { DRM_FORMAT_XBGR8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 1) }, \
59 { DRM_FORMAT_RGBX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 2) }, \
60 { DRM_FORMAT_BGRX8888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2 | DE_SMART, MALIDP_ID(2, 3) }, \
61 { DRM_FORMAT_RGB888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 0) }, \
62 { DRM_FORMAT_BGR888, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(3, 1) }, \
63 { DRM_FORMAT_RGBA5551, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 0) }, \
64 { DRM_FORMAT_ABGR1555, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 1) }, \
65 { DRM_FORMAT_RGB565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 2) }, \
66 { DRM_FORMAT_BGR565, DE_VIDEO1 | DE_GRAPHICS1 | DE_VIDEO2, MALIDP_ID(4, 3) }, \
67 { DRM_FORMAT_YUYV, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 2) }, \
68 { DRM_FORMAT_UYVY, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 3) }, \
69 { DRM_FORMAT_NV12, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 6) }, \
70 { DRM_FORMAT_YUV420, DE_VIDEO1 | DE_VIDEO2, MALIDP_ID(5, 7) }
71
72 static const struct malidp_input_format malidp550_de_formats[] = {
73 MALIDP_COMMON_FORMATS,
74 };
75
76 static const struct malidp_layer malidp500_layers[] = {
77 { DE_VIDEO1, MALIDP500_DE_LV_BASE, MALIDP500_DE_LV_PTR_BASE },
78 { DE_GRAPHICS1, MALIDP500_DE_LG1_BASE, MALIDP500_DE_LG1_PTR_BASE },
79 { DE_GRAPHICS2, MALIDP500_DE_LG2_BASE, MALIDP500_DE_LG2_PTR_BASE },
80 };
81
82 static const struct malidp_layer malidp550_layers[] = {
83 { DE_VIDEO1, MALIDP550_DE_LV1_BASE, MALIDP550_DE_LV1_PTR_BASE },
84 { DE_GRAPHICS1, MALIDP550_DE_LG_BASE, MALIDP550_DE_LG_PTR_BASE },
85 { DE_VIDEO2, MALIDP550_DE_LV2_BASE, MALIDP550_DE_LV2_PTR_BASE },
86 { DE_SMART, MALIDP550_DE_LS_BASE, MALIDP550_DE_LS_PTR_BASE },
87 };
88
89 #define MALIDP_DE_DEFAULT_PREFETCH_START 5
90
91 static int malidp500_query_hw(struct malidp_hw_device *hwdev)
92 {
93 u32 conf = malidp_hw_read(hwdev, MALIDP500_CONFIG_ID);
94 /* bit 4 of the CONFIG_ID register holds the line size multiplier */
95 u8 ln_size_mult = conf & 0x10 ? 2 : 1;
96
97 hwdev->min_line_size = 2;
98 hwdev->max_line_size = SZ_2K * ln_size_mult;
99 hwdev->rotation_memory[0] = SZ_1K * 64 * ln_size_mult;
100 hwdev->rotation_memory[1] = 0; /* no second rotation memory bank */
101
102 return 0;
103 }
104
105 static void malidp500_enter_config_mode(struct malidp_hw_device *hwdev)
106 {
107 u32 status, count = 100;
108
109 malidp_hw_setbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
110 while (count) {
111 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
112 if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
113 break;
114 /*
115 * entering config mode can take as long as the rendering
116 * of a full frame, hence the long sleep here
117 */
118 usleep_range(1000, 10000);
119 count--;
120 }
121 WARN(count == 0, "timeout while entering config mode");
122 }
123
124 static void malidp500_leave_config_mode(struct malidp_hw_device *hwdev)
125 {
126 u32 status, count = 100;
127
128 malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
129 malidp_hw_clearbits(hwdev, MALIDP500_DC_CONFIG_REQ, MALIDP500_DC_CONTROL);
130 while (count) {
131 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
132 if ((status & MALIDP500_DC_CONFIG_REQ) == 0)
133 break;
134 usleep_range(100, 1000);
135 count--;
136 }
137 WARN(count == 0, "timeout while leaving config mode");
138 }
139
140 static bool malidp500_in_config_mode(struct malidp_hw_device *hwdev)
141 {
142 u32 status;
143
144 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
145 if ((status & MALIDP500_DC_CONFIG_REQ) == MALIDP500_DC_CONFIG_REQ)
146 return true;
147
148 return false;
149 }
150
151 static void malidp500_set_config_valid(struct malidp_hw_device *hwdev)
152 {
153 malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP500_CONFIG_VALID);
154 }
155
156 static void malidp500_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
157 {
158 u32 val = 0;
159
160 malidp_hw_clearbits(hwdev, MALIDP500_DC_CLEAR_MASK, MALIDP500_DC_CONTROL);
161 if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
162 val |= MALIDP500_HSYNCPOL;
163 if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
164 val |= MALIDP500_VSYNCPOL;
165 val |= MALIDP_DE_DEFAULT_PREFETCH_START;
166 malidp_hw_setbits(hwdev, val, MALIDP500_DC_CONTROL);
167
168 /*
169 * Mali-DP500 encodes the background color like this:
170 * - red @ MALIDP500_BGND_COLOR[12:0]
171 * - green @ MALIDP500_BGND_COLOR[27:16]
172 * - blue @ (MALIDP500_BGND_COLOR + 4)[12:0]
173 */
174 val = ((MALIDP_BGND_COLOR_G & 0xfff) << 16) |
175 (MALIDP_BGND_COLOR_R & 0xfff);
176 malidp_hw_write(hwdev, val, MALIDP500_BGND_COLOR);
177 malidp_hw_write(hwdev, MALIDP_BGND_COLOR_B, MALIDP500_BGND_COLOR + 4);
178
179 val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
180 MALIDP_DE_H_BACKPORCH(mode->hback_porch);
181 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
182
183 val = MALIDP500_DE_V_FRONTPORCH(mode->vfront_porch) |
184 MALIDP_DE_V_BACKPORCH(mode->vback_porch);
185 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
186
187 val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
188 MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
189 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
190
191 val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
192 malidp_hw_write(hwdev, val, MALIDP500_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
193
194 if (mode->flags & DISPLAY_FLAGS_INTERLACED)
195 malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
196 else
197 malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
198 }
199
200 static int malidp500_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
201 {
202 /* RGB888 or BGR888 can't be rotated */
203 if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
204 return -EINVAL;
205
206 /*
207 * Each layer needs enough rotation memory to fit 8 lines
208 * worth of pixel data. Required size is then:
209 * size = rotated_width * (bpp / 8) * 8;
210 */
211 return w * drm_format_plane_cpp(fmt, 0) * 8;
212 }
213
214 static int malidp550_query_hw(struct malidp_hw_device *hwdev)
215 {
216 u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
217 u8 ln_size = (conf >> 4) & 0x3, rsize;
218
219 hwdev->min_line_size = 2;
220
221 switch (ln_size) {
222 case 0:
223 hwdev->max_line_size = SZ_2K;
224 /* two banks of 64KB for rotation memory */
225 rsize = 64;
226 break;
227 case 1:
228 hwdev->max_line_size = SZ_4K;
229 /* two banks of 128KB for rotation memory */
230 rsize = 128;
231 break;
232 case 2:
233 hwdev->max_line_size = 1280;
234 /* two banks of 40KB for rotation memory */
235 rsize = 40;
236 break;
237 case 3:
238 /* reserved value */
239 hwdev->max_line_size = 0;
240 return -EINVAL;
241 }
242
243 hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
244 return 0;
245 }
246
247 static void malidp550_enter_config_mode(struct malidp_hw_device *hwdev)
248 {
249 u32 status, count = 100;
250
251 malidp_hw_setbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
252 while (count) {
253 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
254 if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
255 break;
256 /*
257 * entering config mode can take as long as the rendering
258 * of a full frame, hence the long sleep here
259 */
260 usleep_range(1000, 10000);
261 count--;
262 }
263 WARN(count == 0, "timeout while entering config mode");
264 }
265
266 static void malidp550_leave_config_mode(struct malidp_hw_device *hwdev)
267 {
268 u32 status, count = 100;
269
270 malidp_hw_clearbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
271 malidp_hw_clearbits(hwdev, MALIDP550_DC_CONFIG_REQ, MALIDP550_DC_CONTROL);
272 while (count) {
273 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
274 if ((status & MALIDP550_DC_CONFIG_REQ) == 0)
275 break;
276 usleep_range(100, 1000);
277 count--;
278 }
279 WARN(count == 0, "timeout while leaving config mode");
280 }
281
282 static bool malidp550_in_config_mode(struct malidp_hw_device *hwdev)
283 {
284 u32 status;
285
286 status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
287 if ((status & MALIDP550_DC_CONFIG_REQ) == MALIDP550_DC_CONFIG_REQ)
288 return true;
289
290 return false;
291 }
292
293 static void malidp550_set_config_valid(struct malidp_hw_device *hwdev)
294 {
295 malidp_hw_setbits(hwdev, MALIDP_CFG_VALID, MALIDP550_CONFIG_VALID);
296 }
297
298 static void malidp550_modeset(struct malidp_hw_device *hwdev, struct videomode *mode)
299 {
300 u32 val = MALIDP_DE_DEFAULT_PREFETCH_START;
301
302 malidp_hw_write(hwdev, val, MALIDP550_DE_CONTROL);
303 /*
304 * Mali-DP550 and Mali-DP650 encode the background color like this:
305 * - red @ MALIDP550_DE_BGND_COLOR[23:16]
306 * - green @ MALIDP550_DE_BGND_COLOR[15:8]
307 * - blue @ MALIDP550_DE_BGND_COLOR[7:0]
308 *
309 * We need to truncate the least significant 4 bits from the default
310 * MALIDP_BGND_COLOR_x values
311 */
312 val = (((MALIDP_BGND_COLOR_R >> 4) & 0xff) << 16) |
313 (((MALIDP_BGND_COLOR_G >> 4) & 0xff) << 8) |
314 ((MALIDP_BGND_COLOR_B >> 4) & 0xff);
315 malidp_hw_write(hwdev, val, MALIDP550_DE_BGND_COLOR);
316
317 val = MALIDP_DE_H_FRONTPORCH(mode->hfront_porch) |
318 MALIDP_DE_H_BACKPORCH(mode->hback_porch);
319 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_H_TIMINGS);
320
321 val = MALIDP550_DE_V_FRONTPORCH(mode->vfront_porch) |
322 MALIDP_DE_V_BACKPORCH(mode->vback_porch);
323 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_V_TIMINGS);
324
325 val = MALIDP_DE_H_SYNCWIDTH(mode->hsync_len) |
326 MALIDP_DE_V_SYNCWIDTH(mode->vsync_len);
327 if (mode->flags & DISPLAY_FLAGS_HSYNC_HIGH)
328 val |= MALIDP550_HSYNCPOL;
329 if (mode->flags & DISPLAY_FLAGS_VSYNC_HIGH)
330 val |= MALIDP550_VSYNCPOL;
331 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_SYNC_WIDTH);
332
333 val = MALIDP_DE_H_ACTIVE(mode->hactive) | MALIDP_DE_V_ACTIVE(mode->vactive);
334 malidp_hw_write(hwdev, val, MALIDP550_TIMINGS_BASE + MALIDP_DE_HV_ACTIVE);
335
336 if (mode->flags & DISPLAY_FLAGS_INTERLACED)
337 malidp_hw_setbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
338 else
339 malidp_hw_clearbits(hwdev, MALIDP_DISP_FUNC_ILACED, MALIDP_DE_DISPLAY_FUNC);
340 }
341
342 static int malidp550_rotmem_required(struct malidp_hw_device *hwdev, u16 w, u16 h, u32 fmt)
343 {
344 u32 bytes_per_col;
345
346 /* raw RGB888 or BGR888 can't be rotated */
347 if ((fmt == DRM_FORMAT_RGB888) || (fmt == DRM_FORMAT_BGR888))
348 return -EINVAL;
349
350 switch (fmt) {
351 /* 8 lines at 4 bytes per pixel */
352 case DRM_FORMAT_ARGB2101010:
353 case DRM_FORMAT_ABGR2101010:
354 case DRM_FORMAT_RGBA1010102:
355 case DRM_FORMAT_BGRA1010102:
356 case DRM_FORMAT_ARGB8888:
357 case DRM_FORMAT_ABGR8888:
358 case DRM_FORMAT_RGBA8888:
359 case DRM_FORMAT_BGRA8888:
360 case DRM_FORMAT_XRGB8888:
361 case DRM_FORMAT_XBGR8888:
362 case DRM_FORMAT_RGBX8888:
363 case DRM_FORMAT_BGRX8888:
364 case DRM_FORMAT_RGB888:
365 case DRM_FORMAT_BGR888:
366 /* 16 lines at 2 bytes per pixel */
367 case DRM_FORMAT_RGBA5551:
368 case DRM_FORMAT_ABGR1555:
369 case DRM_FORMAT_RGB565:
370 case DRM_FORMAT_BGR565:
371 case DRM_FORMAT_UYVY:
372 case DRM_FORMAT_YUYV:
373 bytes_per_col = 32;
374 break;
375 /* 16 lines at 1.5 bytes per pixel */
376 case DRM_FORMAT_NV12:
377 case DRM_FORMAT_YUV420:
378 bytes_per_col = 24;
379 break;
380 default:
381 return -EINVAL;
382 }
383
384 return w * bytes_per_col;
385 }
386
387 static int malidp650_query_hw(struct malidp_hw_device *hwdev)
388 {
389 u32 conf = malidp_hw_read(hwdev, MALIDP550_CONFIG_ID);
390 u8 ln_size = (conf >> 4) & 0x3, rsize;
391
392 hwdev->min_line_size = 4;
393
394 switch (ln_size) {
395 case 0:
396 case 2:
397 /* reserved values */
398 hwdev->max_line_size = 0;
399 return -EINVAL;
400 case 1:
401 hwdev->max_line_size = SZ_4K;
402 /* two banks of 128KB for rotation memory */
403 rsize = 128;
404 break;
405 case 3:
406 hwdev->max_line_size = 2560;
407 /* two banks of 80KB for rotation memory */
408 rsize = 80;
409 }
410
411 hwdev->rotation_memory[0] = hwdev->rotation_memory[1] = rsize * SZ_1K;
412 return 0;
413 }
414
415 const struct malidp_hw_device malidp_device[MALIDP_MAX_DEVICES] = {
416 [MALIDP_500] = {
417 .map = {
418 .se_base = MALIDP500_SE_BASE,
419 .dc_base = MALIDP500_DC_BASE,
420 .out_depth_base = MALIDP500_OUTPUT_DEPTH,
421 .features = 0, /* no CLEARIRQ register */
422 .n_layers = ARRAY_SIZE(malidp500_layers),
423 .layers = malidp500_layers,
424 .de_irq_map = {
425 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
426 MALIDP500_DE_IRQ_AXI_ERR |
427 MALIDP500_DE_IRQ_VSYNC |
428 MALIDP500_DE_IRQ_GLOBAL,
429 .vsync_irq = MALIDP500_DE_IRQ_VSYNC,
430 },
431 .se_irq_map = {
432 .irq_mask = MALIDP500_SE_IRQ_CONF_MODE,
433 .vsync_irq = 0,
434 },
435 .dc_irq_map = {
436 .irq_mask = MALIDP500_DE_IRQ_CONF_VALID,
437 .vsync_irq = MALIDP500_DE_IRQ_CONF_VALID,
438 },
439 .input_formats = malidp500_de_formats,
440 .n_input_formats = ARRAY_SIZE(malidp500_de_formats),
441 .bus_align_bytes = 8,
442 },
443 .query_hw = malidp500_query_hw,
444 .enter_config_mode = malidp500_enter_config_mode,
445 .leave_config_mode = malidp500_leave_config_mode,
446 .in_config_mode = malidp500_in_config_mode,
447 .set_config_valid = malidp500_set_config_valid,
448 .modeset = malidp500_modeset,
449 .rotmem_required = malidp500_rotmem_required,
450 },
451 [MALIDP_550] = {
452 .map = {
453 .se_base = MALIDP550_SE_BASE,
454 .dc_base = MALIDP550_DC_BASE,
455 .out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
456 .features = MALIDP_REGMAP_HAS_CLEARIRQ,
457 .n_layers = ARRAY_SIZE(malidp550_layers),
458 .layers = malidp550_layers,
459 .de_irq_map = {
460 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
461 MALIDP550_DE_IRQ_VSYNC,
462 .vsync_irq = MALIDP550_DE_IRQ_VSYNC,
463 },
464 .se_irq_map = {
465 .irq_mask = MALIDP550_SE_IRQ_EOW |
466 MALIDP550_SE_IRQ_AXI_ERR,
467 },
468 .dc_irq_map = {
469 .irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
470 .vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
471 },
472 .input_formats = malidp550_de_formats,
473 .n_input_formats = ARRAY_SIZE(malidp550_de_formats),
474 .bus_align_bytes = 8,
475 },
476 .query_hw = malidp550_query_hw,
477 .enter_config_mode = malidp550_enter_config_mode,
478 .leave_config_mode = malidp550_leave_config_mode,
479 .in_config_mode = malidp550_in_config_mode,
480 .set_config_valid = malidp550_set_config_valid,
481 .modeset = malidp550_modeset,
482 .rotmem_required = malidp550_rotmem_required,
483 },
484 [MALIDP_650] = {
485 .map = {
486 .se_base = MALIDP550_SE_BASE,
487 .dc_base = MALIDP550_DC_BASE,
488 .out_depth_base = MALIDP550_DE_OUTPUT_DEPTH,
489 .features = MALIDP_REGMAP_HAS_CLEARIRQ,
490 .n_layers = ARRAY_SIZE(malidp550_layers),
491 .layers = malidp550_layers,
492 .de_irq_map = {
493 .irq_mask = MALIDP_DE_IRQ_UNDERRUN |
494 MALIDP650_DE_IRQ_DRIFT |
495 MALIDP550_DE_IRQ_VSYNC,
496 .vsync_irq = MALIDP550_DE_IRQ_VSYNC,
497 },
498 .se_irq_map = {
499 .irq_mask = MALIDP550_SE_IRQ_EOW |
500 MALIDP550_SE_IRQ_AXI_ERR,
501 },
502 .dc_irq_map = {
503 .irq_mask = MALIDP550_DC_IRQ_CONF_VALID,
504 .vsync_irq = MALIDP550_DC_IRQ_CONF_VALID,
505 },
506 .input_formats = malidp550_de_formats,
507 .n_input_formats = ARRAY_SIZE(malidp550_de_formats),
508 .bus_align_bytes = 16,
509 },
510 .query_hw = malidp650_query_hw,
511 .enter_config_mode = malidp550_enter_config_mode,
512 .leave_config_mode = malidp550_leave_config_mode,
513 .in_config_mode = malidp550_in_config_mode,
514 .set_config_valid = malidp550_set_config_valid,
515 .modeset = malidp550_modeset,
516 .rotmem_required = malidp550_rotmem_required,
517 },
518 };
519
520 u8 malidp_hw_get_format_id(const struct malidp_hw_regmap *map,
521 u8 layer_id, u32 format)
522 {
523 unsigned int i;
524
525 for (i = 0; i < map->n_input_formats; i++) {
526 if (((map->input_formats[i].layer & layer_id) == layer_id) &&
527 (map->input_formats[i].format == format))
528 return map->input_formats[i].id;
529 }
530
531 return MALIDP_INVALID_FORMAT_ID;
532 }
533
534 static void malidp_hw_clear_irq(struct malidp_hw_device *hwdev, u8 block, u32 irq)
535 {
536 u32 base = malidp_get_block_base(hwdev, block);
537
538 if (hwdev->map.features & MALIDP_REGMAP_HAS_CLEARIRQ)
539 malidp_hw_write(hwdev, irq, base + MALIDP_REG_CLEARIRQ);
540 else
541 malidp_hw_write(hwdev, irq, base + MALIDP_REG_STATUS);
542 }
543
544 static irqreturn_t malidp_de_irq(int irq, void *arg)
545 {
546 struct drm_device *drm = arg;
547 struct malidp_drm *malidp = drm->dev_private;
548 struct malidp_hw_device *hwdev;
549 const struct malidp_irq_map *de;
550 u32 status, mask, dc_status;
551 irqreturn_t ret = IRQ_NONE;
552
553 if (!drm->dev_private)
554 return IRQ_HANDLED;
555
556 hwdev = malidp->dev;
557 de = &hwdev->map.de_irq_map;
558
559 /* first handle the config valid IRQ */
560 dc_status = malidp_hw_read(hwdev, hwdev->map.dc_base + MALIDP_REG_STATUS);
561 if (dc_status & hwdev->map.dc_irq_map.vsync_irq) {
562 /* we have a page flip event */
563 atomic_set(&malidp->config_valid, 1);
564 malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, dc_status);
565 ret = IRQ_WAKE_THREAD;
566 }
567
568 status = malidp_hw_read(hwdev, MALIDP_REG_STATUS);
569 if (!(status & de->irq_mask))
570 return ret;
571
572 mask = malidp_hw_read(hwdev, MALIDP_REG_MASKIRQ);
573 status &= mask;
574 if (status & de->vsync_irq)
575 drm_crtc_handle_vblank(&malidp->crtc);
576
577 malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, status);
578
579 return (ret == IRQ_NONE) ? IRQ_HANDLED : ret;
580 }
581
582 static irqreturn_t malidp_de_irq_thread_handler(int irq, void *arg)
583 {
584 struct drm_device *drm = arg;
585 struct malidp_drm *malidp = drm->dev_private;
586
587 wake_up(&malidp->wq);
588
589 return IRQ_HANDLED;
590 }
591
592 int malidp_de_irq_init(struct drm_device *drm, int irq)
593 {
594 struct malidp_drm *malidp = drm->dev_private;
595 struct malidp_hw_device *hwdev = malidp->dev;
596 int ret;
597
598 /* ensure interrupts are disabled */
599 malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
600 malidp_hw_clear_irq(hwdev, MALIDP_DE_BLOCK, 0xffffffff);
601 malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
602 malidp_hw_clear_irq(hwdev, MALIDP_DC_BLOCK, 0xffffffff);
603
604 ret = devm_request_threaded_irq(drm->dev, irq, malidp_de_irq,
605 malidp_de_irq_thread_handler,
606 IRQF_SHARED, "malidp-de", drm);
607 if (ret < 0) {
608 DRM_ERROR("failed to install DE IRQ handler\n");
609 return ret;
610 }
611
612 /* first enable the DC block IRQs */
613 malidp_hw_enable_irq(hwdev, MALIDP_DC_BLOCK,
614 hwdev->map.dc_irq_map.irq_mask);
615
616 /* now enable the DE block IRQs */
617 malidp_hw_enable_irq(hwdev, MALIDP_DE_BLOCK,
618 hwdev->map.de_irq_map.irq_mask);
619
620 return 0;
621 }
622
623 void malidp_de_irq_fini(struct drm_device *drm)
624 {
625 struct malidp_drm *malidp = drm->dev_private;
626 struct malidp_hw_device *hwdev = malidp->dev;
627
628 malidp_hw_disable_irq(hwdev, MALIDP_DE_BLOCK,
629 hwdev->map.de_irq_map.irq_mask);
630 malidp_hw_disable_irq(hwdev, MALIDP_DC_BLOCK,
631 hwdev->map.dc_irq_map.irq_mask);
632 }
633
634 static irqreturn_t malidp_se_irq(int irq, void *arg)
635 {
636 struct drm_device *drm = arg;
637 struct malidp_drm *malidp = drm->dev_private;
638 struct malidp_hw_device *hwdev = malidp->dev;
639 u32 status, mask;
640
641 status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
642 if (!(status & hwdev->map.se_irq_map.irq_mask))
643 return IRQ_NONE;
644
645 mask = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_MASKIRQ);
646 status = malidp_hw_read(hwdev, hwdev->map.se_base + MALIDP_REG_STATUS);
647 status &= mask;
648 /* ToDo: status decoding and firing up of VSYNC and page flip events */
649
650 malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, status);
651
652 return IRQ_HANDLED;
653 }
654
655 static irqreturn_t malidp_se_irq_thread_handler(int irq, void *arg)
656 {
657 return IRQ_HANDLED;
658 }
659
660 int malidp_se_irq_init(struct drm_device *drm, int irq)
661 {
662 struct malidp_drm *malidp = drm->dev_private;
663 struct malidp_hw_device *hwdev = malidp->dev;
664 int ret;
665
666 /* ensure interrupts are disabled */
667 malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
668 malidp_hw_clear_irq(hwdev, MALIDP_SE_BLOCK, 0xffffffff);
669
670 ret = devm_request_threaded_irq(drm->dev, irq, malidp_se_irq,
671 malidp_se_irq_thread_handler,
672 IRQF_SHARED, "malidp-se", drm);
673 if (ret < 0) {
674 DRM_ERROR("failed to install SE IRQ handler\n");
675 return ret;
676 }
677
678 malidp_hw_enable_irq(hwdev, MALIDP_SE_BLOCK,
679 hwdev->map.se_irq_map.irq_mask);
680
681 return 0;
682 }
683
684 void malidp_se_irq_fini(struct drm_device *drm)
685 {
686 struct malidp_drm *malidp = drm->dev_private;
687 struct malidp_hw_device *hwdev = malidp->dev;
688
689 malidp_hw_disable_irq(hwdev, MALIDP_SE_BLOCK,
690 hwdev->map.se_irq_map.irq_mask);
691 }
Linux with added FPC-III support