?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PM / sleep: Asynchronous threads for suspend_noirq
[linux/fpc-iii.git] / drivers / gpu / drm / exynos / exynos_hdmi.c
blobc021ddc1ffb4b4e982ac01874953dbb7239ddc31
1 /*
2 * Copyright (C) 2011 Samsung Electronics Co.Ltd
3 * Authors:
4 * Seung-Woo Kim <sw0312.kim@samsung.com>
5 * Inki Dae <inki.dae@samsung.com>
6 * Joonyoung Shim <jy0922.shim@samsung.com>
7 *
8 * Based on drivers/media/video/s5p-tv/hdmi_drv.c
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 *
15 */
16
17 #include <drm/drmP.h>
18 #include <drm/drm_edid.h>
19 #include <drm/drm_crtc_helper.h>
20
21 #include "regs-hdmi.h"
22
23 #include <linux/kernel.h>
24 #include <linux/spinlock.h>
25 #include <linux/wait.h>
26 #include <linux/i2c.h>
27 #include <linux/platform_device.h>
28 #include <linux/interrupt.h>
29 #include <linux/irq.h>
30 #include <linux/delay.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/clk.h>
33 #include <linux/regulator/consumer.h>
34 #include <linux/io.h>
35 #include <linux/of.h>
36 #include <linux/of_gpio.h>
37 #include <linux/hdmi.h>
38
39 #include <drm/exynos_drm.h>
40
41 #include "exynos_drm_drv.h"
42 #include "exynos_drm_hdmi.h"
43
44 #include "exynos_hdmi.h"
45
46 #include <linux/gpio.h>
47 #include <media/s5p_hdmi.h>
48
49 #define MAX_WIDTH 1920
50 #define MAX_HEIGHT 1080
51 #define get_hdmi_context(dev) platform_get_drvdata(to_platform_device(dev))
52
53 /* AVI header and aspect ratio */
54 #define HDMI_AVI_VERSION 0x02
55 #define HDMI_AVI_LENGTH 0x0D
56 #define AVI_PIC_ASPECT_RATIO_16_9 (2 << 4)
57 #define AVI_SAME_AS_PIC_ASPECT_RATIO 8
58
59 /* AUI header info */
60 #define HDMI_AUI_VERSION 0x01
61 #define HDMI_AUI_LENGTH 0x0A
62
63 enum hdmi_type {
64 HDMI_TYPE13,
65 HDMI_TYPE14,
66 };
67
68 struct hdmi_resources {
69 struct clk *hdmi;
70 struct clk *sclk_hdmi;
71 struct clk *sclk_pixel;
72 struct clk *sclk_hdmiphy;
73 struct clk *hdmiphy;
74 struct clk *mout_hdmi;
75 struct regulator_bulk_data *regul_bulk;
76 int regul_count;
77 };
78
79 struct hdmi_tg_regs {
80 u8 cmd[1];
81 u8 h_fsz[2];
82 u8 hact_st[2];
83 u8 hact_sz[2];
84 u8 v_fsz[2];
85 u8 vsync[2];
86 u8 vsync2[2];
87 u8 vact_st[2];
88 u8 vact_sz[2];
89 u8 field_chg[2];
90 u8 vact_st2[2];
91 u8 vact_st3[2];
92 u8 vact_st4[2];
93 u8 vsync_top_hdmi[2];
94 u8 vsync_bot_hdmi[2];
95 u8 field_top_hdmi[2];
96 u8 field_bot_hdmi[2];
97 u8 tg_3d[1];
98 };
99
100 struct hdmi_v13_core_regs {
101 u8 h_blank[2];
102 u8 v_blank[3];
103 u8 h_v_line[3];
104 u8 vsync_pol[1];
105 u8 int_pro_mode[1];
106 u8 v_blank_f[3];
107 u8 h_sync_gen[3];
108 u8 v_sync_gen1[3];
109 u8 v_sync_gen2[3];
110 u8 v_sync_gen3[3];
111 };
112
113 struct hdmi_v14_core_regs {
114 u8 h_blank[2];
115 u8 v2_blank[2];
116 u8 v1_blank[2];
117 u8 v_line[2];
118 u8 h_line[2];
119 u8 hsync_pol[1];
120 u8 vsync_pol[1];
121 u8 int_pro_mode[1];
122 u8 v_blank_f0[2];
123 u8 v_blank_f1[2];
124 u8 h_sync_start[2];
125 u8 h_sync_end[2];
126 u8 v_sync_line_bef_2[2];
127 u8 v_sync_line_bef_1[2];
128 u8 v_sync_line_aft_2[2];
129 u8 v_sync_line_aft_1[2];
130 u8 v_sync_line_aft_pxl_2[2];
131 u8 v_sync_line_aft_pxl_1[2];
132 u8 v_blank_f2[2]; /* for 3D mode */
133 u8 v_blank_f3[2]; /* for 3D mode */
134 u8 v_blank_f4[2]; /* for 3D mode */
135 u8 v_blank_f5[2]; /* for 3D mode */
136 u8 v_sync_line_aft_3[2];
137 u8 v_sync_line_aft_4[2];
138 u8 v_sync_line_aft_5[2];
139 u8 v_sync_line_aft_6[2];
140 u8 v_sync_line_aft_pxl_3[2];
141 u8 v_sync_line_aft_pxl_4[2];
142 u8 v_sync_line_aft_pxl_5[2];
143 u8 v_sync_line_aft_pxl_6[2];
144 u8 vact_space_1[2];
145 u8 vact_space_2[2];
146 u8 vact_space_3[2];
147 u8 vact_space_4[2];
148 u8 vact_space_5[2];
149 u8 vact_space_6[2];
150 };
151
152 struct hdmi_v13_conf {
153 struct hdmi_v13_core_regs core;
154 struct hdmi_tg_regs tg;
155 };
156
157 struct hdmi_v14_conf {
158 struct hdmi_v14_core_regs core;
159 struct hdmi_tg_regs tg;
160 };
161
162 struct hdmi_conf_regs {
163 int pixel_clock;
164 int cea_video_id;
165 union {
166 struct hdmi_v13_conf v13_conf;
167 struct hdmi_v14_conf v14_conf;
168 } conf;
169 };
170
171 struct hdmi_context {
172 struct device *dev;
173 struct drm_device *drm_dev;
174 bool hpd;
175 bool powered;
176 bool dvi_mode;
177 struct mutex hdmi_mutex;
178
179 void __iomem *regs;
180 void *parent_ctx;
181 int irq;
182
183 struct i2c_client *ddc_port;
184 struct i2c_client *hdmiphy_port;
185
186 /* current hdmiphy conf regs */
187 struct hdmi_conf_regs mode_conf;
188
189 struct hdmi_resources res;
190
191 int hpd_gpio;
192
193 enum hdmi_type type;
194 };
195
196 struct hdmiphy_config {
197 int pixel_clock;
198 u8 conf[32];
199 };
200
201 /* list of phy config settings */
202 static const struct hdmiphy_config hdmiphy_v13_configs[] = {
203 {
204 .pixel_clock = 27000000,
205 .conf = {
206 0x01, 0x05, 0x00, 0xD8, 0x10, 0x1C, 0x30, 0x40,
207 0x6B, 0x10, 0x02, 0x51, 0xDF, 0xF2, 0x54, 0x87,
208 0x84, 0x00, 0x30, 0x38, 0x00, 0x08, 0x10, 0xE0,
209 0x22, 0x40, 0xE3, 0x26, 0x00, 0x00, 0x00, 0x00,
210 },
211 },
212 {
213 .pixel_clock = 27027000,
214 .conf = {
215 0x01, 0x05, 0x00, 0xD4, 0x10, 0x9C, 0x09, 0x64,
216 0x6B, 0x10, 0x02, 0x51, 0xDF, 0xF2, 0x54, 0x87,
217 0x84, 0x00, 0x30, 0x38, 0x00, 0x08, 0x10, 0xE0,
218 0x22, 0x40, 0xE3, 0x26, 0x00, 0x00, 0x00, 0x00,
219 },
220 },
221 {
222 .pixel_clock = 74176000,
223 .conf = {
224 0x01, 0x05, 0x00, 0xD8, 0x10, 0x9C, 0xef, 0x5B,
225 0x6D, 0x10, 0x01, 0x51, 0xef, 0xF3, 0x54, 0xb9,
226 0x84, 0x00, 0x30, 0x38, 0x00, 0x08, 0x10, 0xE0,
227 0x22, 0x40, 0xa5, 0x26, 0x01, 0x00, 0x00, 0x00,
228 },
229 },
230 {
231 .pixel_clock = 74250000,
232 .conf = {
233 0x01, 0x05, 0x00, 0xd8, 0x10, 0x9c, 0xf8, 0x40,
234 0x6a, 0x10, 0x01, 0x51, 0xff, 0xf1, 0x54, 0xba,
235 0x84, 0x00, 0x10, 0x38, 0x00, 0x08, 0x10, 0xe0,
236 0x22, 0x40, 0xa4, 0x26, 0x01, 0x00, 0x00, 0x00,
237 },
238 },
239 {
240 .pixel_clock = 148500000,
241 .conf = {
242 0x01, 0x05, 0x00, 0xD8, 0x10, 0x9C, 0xf8, 0x40,
243 0x6A, 0x18, 0x00, 0x51, 0xff, 0xF1, 0x54, 0xba,
244 0x84, 0x00, 0x10, 0x38, 0x00, 0x08, 0x10, 0xE0,
245 0x22, 0x40, 0xa4, 0x26, 0x02, 0x00, 0x00, 0x00,
246 },
247 },
248 };
249
250 static const struct hdmiphy_config hdmiphy_v14_configs[] = {
251 {
252 .pixel_clock = 25200000,
253 .conf = {
254 0x01, 0x51, 0x2A, 0x75, 0x40, 0x01, 0x00, 0x08,
255 0x82, 0x80, 0xfc, 0xd8, 0x45, 0xa0, 0xac, 0x80,
256 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
257 0x54, 0xf4, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80,
258 },
259 },
260 {
261 .pixel_clock = 27000000,
262 .conf = {
263 0x01, 0xd1, 0x22, 0x51, 0x40, 0x08, 0xfc, 0x20,
264 0x98, 0xa0, 0xcb, 0xd8, 0x45, 0xa0, 0xac, 0x80,
265 0x06, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
266 0x54, 0xe4, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80,
267 },
268 },
269 {
270 .pixel_clock = 27027000,
271 .conf = {
272 0x01, 0xd1, 0x2d, 0x72, 0x40, 0x64, 0x12, 0x08,
273 0x43, 0xa0, 0x0e, 0xd9, 0x45, 0xa0, 0xac, 0x80,
274 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
275 0x54, 0xe3, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00,
276 },
277 },
278 {
279 .pixel_clock = 36000000,
280 .conf = {
281 0x01, 0x51, 0x2d, 0x55, 0x40, 0x01, 0x00, 0x08,
282 0x82, 0x80, 0x0e, 0xd9, 0x45, 0xa0, 0xac, 0x80,
283 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
284 0x54, 0xab, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80,
285 },
286 },
287 {
288 .pixel_clock = 40000000,
289 .conf = {
290 0x01, 0x51, 0x32, 0x55, 0x40, 0x01, 0x00, 0x08,
291 0x82, 0x80, 0x2c, 0xd9, 0x45, 0xa0, 0xac, 0x80,
292 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
293 0x54, 0x9a, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80,
294 },
295 },
296 {
297 .pixel_clock = 65000000,
298 .conf = {
299 0x01, 0xd1, 0x36, 0x34, 0x40, 0x1e, 0x0a, 0x08,
300 0x82, 0xa0, 0x45, 0xd9, 0x45, 0xa0, 0xac, 0x80,
301 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
302 0x54, 0xbd, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80,
303 },
304 },
305 {
306 .pixel_clock = 74176000,
307 .conf = {
308 0x01, 0xd1, 0x3e, 0x35, 0x40, 0x5b, 0xde, 0x08,
309 0x82, 0xa0, 0x73, 0xd9, 0x45, 0xa0, 0xac, 0x80,
310 0x56, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
311 0x54, 0xa6, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80,
312 },
313 },
314 {
315 .pixel_clock = 74250000,
316 .conf = {
317 0x01, 0xd1, 0x1f, 0x10, 0x40, 0x40, 0xf8, 0x08,
318 0x81, 0xa0, 0xba, 0xd8, 0x45, 0xa0, 0xac, 0x80,
319 0x3c, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
320 0x54, 0xa5, 0x24, 0x01, 0x00, 0x00, 0x01, 0x00,
321 },
322 },
323 {
324 .pixel_clock = 83500000,
325 .conf = {
326 0x01, 0xd1, 0x23, 0x11, 0x40, 0x0c, 0xfb, 0x08,
327 0x85, 0xa0, 0xd1, 0xd8, 0x45, 0xa0, 0xac, 0x80,
328 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
329 0x54, 0x93, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80,
330 },
331 },
332 {
333 .pixel_clock = 106500000,
334 .conf = {
335 0x01, 0xd1, 0x2c, 0x12, 0x40, 0x0c, 0x09, 0x08,
336 0x84, 0xa0, 0x0a, 0xd9, 0x45, 0xa0, 0xac, 0x80,
337 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
338 0x54, 0x73, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80,
339 },
340 },
341 {
342 .pixel_clock = 108000000,
343 .conf = {
344 0x01, 0x51, 0x2d, 0x15, 0x40, 0x01, 0x00, 0x08,
345 0x82, 0x80, 0x0e, 0xd9, 0x45, 0xa0, 0xac, 0x80,
346 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
347 0x54, 0xc7, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80,
348 },
349 },
350 {
351 .pixel_clock = 146250000,
352 .conf = {
353 0x01, 0xd1, 0x3d, 0x15, 0x40, 0x18, 0xfd, 0x08,
354 0x83, 0xa0, 0x6e, 0xd9, 0x45, 0xa0, 0xac, 0x80,
355 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
356 0x54, 0x50, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80,
357 },
358 },
359 {
360 .pixel_clock = 148500000,
361 .conf = {
362 0x01, 0xd1, 0x1f, 0x00, 0x40, 0x40, 0xf8, 0x08,
363 0x81, 0xa0, 0xba, 0xd8, 0x45, 0xa0, 0xac, 0x80,
364 0x3c, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86,
365 0x54, 0x4b, 0x25, 0x03, 0x00, 0x00, 0x01, 0x00,
366 },
367 },
368 };
369
370 static inline u32 hdmi_reg_read(struct hdmi_context *hdata, u32 reg_id)
371 {
372 return readl(hdata->regs + reg_id);
373 }
374
375 static inline void hdmi_reg_writeb(struct hdmi_context *hdata,
376 u32 reg_id, u8 value)
377 {
378 writeb(value, hdata->regs + reg_id);
379 }
380
381 static inline void hdmi_reg_writemask(struct hdmi_context *hdata,
382 u32 reg_id, u32 value, u32 mask)
383 {
384 u32 old = readl(hdata->regs + reg_id);
385 value = (value & mask) | (old & ~mask);
386 writel(value, hdata->regs + reg_id);
387 }
388
389 static void hdmi_v13_regs_dump(struct hdmi_context *hdata, char *prefix)
390 {
391 #define DUMPREG(reg_id) \
392 DRM_DEBUG_KMS("%s:" #reg_id " = %08x\n", prefix, \
393 readl(hdata->regs + reg_id))
394 DRM_DEBUG_KMS("%s: ---- CONTROL REGISTERS ----\n", prefix);
395 DUMPREG(HDMI_INTC_FLAG);
396 DUMPREG(HDMI_INTC_CON);
397 DUMPREG(HDMI_HPD_STATUS);
398 DUMPREG(HDMI_V13_PHY_RSTOUT);
399 DUMPREG(HDMI_V13_PHY_VPLL);
400 DUMPREG(HDMI_V13_PHY_CMU);
401 DUMPREG(HDMI_V13_CORE_RSTOUT);
402
403 DRM_DEBUG_KMS("%s: ---- CORE REGISTERS ----\n", prefix);
404 DUMPREG(HDMI_CON_0);
405 DUMPREG(HDMI_CON_1);
406 DUMPREG(HDMI_CON_2);
407 DUMPREG(HDMI_SYS_STATUS);
408 DUMPREG(HDMI_V13_PHY_STATUS);
409 DUMPREG(HDMI_STATUS_EN);
410 DUMPREG(HDMI_HPD);
411 DUMPREG(HDMI_MODE_SEL);
412 DUMPREG(HDMI_V13_HPD_GEN);
413 DUMPREG(HDMI_V13_DC_CONTROL);
414 DUMPREG(HDMI_V13_VIDEO_PATTERN_GEN);
415
416 DRM_DEBUG_KMS("%s: ---- CORE SYNC REGISTERS ----\n", prefix);
417 DUMPREG(HDMI_H_BLANK_0);
418 DUMPREG(HDMI_H_BLANK_1);
419 DUMPREG(HDMI_V13_V_BLANK_0);
420 DUMPREG(HDMI_V13_V_BLANK_1);
421 DUMPREG(HDMI_V13_V_BLANK_2);
422 DUMPREG(HDMI_V13_H_V_LINE_0);
423 DUMPREG(HDMI_V13_H_V_LINE_1);
424 DUMPREG(HDMI_V13_H_V_LINE_2);
425 DUMPREG(HDMI_VSYNC_POL);
426 DUMPREG(HDMI_INT_PRO_MODE);
427 DUMPREG(HDMI_V13_V_BLANK_F_0);
428 DUMPREG(HDMI_V13_V_BLANK_F_1);
429 DUMPREG(HDMI_V13_V_BLANK_F_2);
430 DUMPREG(HDMI_V13_H_SYNC_GEN_0);
431 DUMPREG(HDMI_V13_H_SYNC_GEN_1);
432 DUMPREG(HDMI_V13_H_SYNC_GEN_2);
433 DUMPREG(HDMI_V13_V_SYNC_GEN_1_0);
434 DUMPREG(HDMI_V13_V_SYNC_GEN_1_1);
435 DUMPREG(HDMI_V13_V_SYNC_GEN_1_2);
436 DUMPREG(HDMI_V13_V_SYNC_GEN_2_0);
437 DUMPREG(HDMI_V13_V_SYNC_GEN_2_1);
438 DUMPREG(HDMI_V13_V_SYNC_GEN_2_2);
439 DUMPREG(HDMI_V13_V_SYNC_GEN_3_0);
440 DUMPREG(HDMI_V13_V_SYNC_GEN_3_1);
441 DUMPREG(HDMI_V13_V_SYNC_GEN_3_2);
442
443 DRM_DEBUG_KMS("%s: ---- TG REGISTERS ----\n", prefix);
444 DUMPREG(HDMI_TG_CMD);
445 DUMPREG(HDMI_TG_H_FSZ_L);
446 DUMPREG(HDMI_TG_H_FSZ_H);
447 DUMPREG(HDMI_TG_HACT_ST_L);
448 DUMPREG(HDMI_TG_HACT_ST_H);
449 DUMPREG(HDMI_TG_HACT_SZ_L);
450 DUMPREG(HDMI_TG_HACT_SZ_H);
451 DUMPREG(HDMI_TG_V_FSZ_L);
452 DUMPREG(HDMI_TG_V_FSZ_H);
453 DUMPREG(HDMI_TG_VSYNC_L);
454 DUMPREG(HDMI_TG_VSYNC_H);
455 DUMPREG(HDMI_TG_VSYNC2_L);
456 DUMPREG(HDMI_TG_VSYNC2_H);
457 DUMPREG(HDMI_TG_VACT_ST_L);
458 DUMPREG(HDMI_TG_VACT_ST_H);
459 DUMPREG(HDMI_TG_VACT_SZ_L);
460 DUMPREG(HDMI_TG_VACT_SZ_H);
461 DUMPREG(HDMI_TG_FIELD_CHG_L);
462 DUMPREG(HDMI_TG_FIELD_CHG_H);
463 DUMPREG(HDMI_TG_VACT_ST2_L);
464 DUMPREG(HDMI_TG_VACT_ST2_H);
465 DUMPREG(HDMI_TG_VSYNC_TOP_HDMI_L);
466 DUMPREG(HDMI_TG_VSYNC_TOP_HDMI_H);
467 DUMPREG(HDMI_TG_VSYNC_BOT_HDMI_L);
468 DUMPREG(HDMI_TG_VSYNC_BOT_HDMI_H);
469 DUMPREG(HDMI_TG_FIELD_TOP_HDMI_L);
470 DUMPREG(HDMI_TG_FIELD_TOP_HDMI_H);
471 DUMPREG(HDMI_TG_FIELD_BOT_HDMI_L);
472 DUMPREG(HDMI_TG_FIELD_BOT_HDMI_H);
473 #undef DUMPREG
474 }
475
476 static void hdmi_v14_regs_dump(struct hdmi_context *hdata, char *prefix)
477 {
478 int i;
479
480 #define DUMPREG(reg_id) \
481 DRM_DEBUG_KMS("%s:" #reg_id " = %08x\n", prefix, \
482 readl(hdata->regs + reg_id))
483
484 DRM_DEBUG_KMS("%s: ---- CONTROL REGISTERS ----\n", prefix);
485 DUMPREG(HDMI_INTC_CON);
486 DUMPREG(HDMI_INTC_FLAG);
487 DUMPREG(HDMI_HPD_STATUS);
488 DUMPREG(HDMI_INTC_CON_1);
489 DUMPREG(HDMI_INTC_FLAG_1);
490 DUMPREG(HDMI_PHY_STATUS_0);
491 DUMPREG(HDMI_PHY_STATUS_PLL);
492 DUMPREG(HDMI_PHY_CON_0);
493 DUMPREG(HDMI_PHY_RSTOUT);
494 DUMPREG(HDMI_PHY_VPLL);
495 DUMPREG(HDMI_PHY_CMU);
496 DUMPREG(HDMI_CORE_RSTOUT);
497
498 DRM_DEBUG_KMS("%s: ---- CORE REGISTERS ----\n", prefix);
499 DUMPREG(HDMI_CON_0);
500 DUMPREG(HDMI_CON_1);
501 DUMPREG(HDMI_CON_2);
502 DUMPREG(HDMI_SYS_STATUS);
503 DUMPREG(HDMI_PHY_STATUS_0);
504 DUMPREG(HDMI_STATUS_EN);
505 DUMPREG(HDMI_HPD);
506 DUMPREG(HDMI_MODE_SEL);
507 DUMPREG(HDMI_ENC_EN);
508 DUMPREG(HDMI_DC_CONTROL);
509 DUMPREG(HDMI_VIDEO_PATTERN_GEN);
510
511 DRM_DEBUG_KMS("%s: ---- CORE SYNC REGISTERS ----\n", prefix);
512 DUMPREG(HDMI_H_BLANK_0);
513 DUMPREG(HDMI_H_BLANK_1);
514 DUMPREG(HDMI_V2_BLANK_0);
515 DUMPREG(HDMI_V2_BLANK_1);
516 DUMPREG(HDMI_V1_BLANK_0);
517 DUMPREG(HDMI_V1_BLANK_1);
518 DUMPREG(HDMI_V_LINE_0);
519 DUMPREG(HDMI_V_LINE_1);
520 DUMPREG(HDMI_H_LINE_0);
521 DUMPREG(HDMI_H_LINE_1);
522 DUMPREG(HDMI_HSYNC_POL);
523
524 DUMPREG(HDMI_VSYNC_POL);
525 DUMPREG(HDMI_INT_PRO_MODE);
526 DUMPREG(HDMI_V_BLANK_F0_0);
527 DUMPREG(HDMI_V_BLANK_F0_1);
528 DUMPREG(HDMI_V_BLANK_F1_0);
529 DUMPREG(HDMI_V_BLANK_F1_1);
530
531 DUMPREG(HDMI_H_SYNC_START_0);
532 DUMPREG(HDMI_H_SYNC_START_1);
533 DUMPREG(HDMI_H_SYNC_END_0);
534 DUMPREG(HDMI_H_SYNC_END_1);
535
536 DUMPREG(HDMI_V_SYNC_LINE_BEF_2_0);
537 DUMPREG(HDMI_V_SYNC_LINE_BEF_2_1);
538 DUMPREG(HDMI_V_SYNC_LINE_BEF_1_0);
539 DUMPREG(HDMI_V_SYNC_LINE_BEF_1_1);
540
541 DUMPREG(HDMI_V_SYNC_LINE_AFT_2_0);
542 DUMPREG(HDMI_V_SYNC_LINE_AFT_2_1);
543 DUMPREG(HDMI_V_SYNC_LINE_AFT_1_0);
544 DUMPREG(HDMI_V_SYNC_LINE_AFT_1_1);
545
546 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_2_0);
547 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_2_1);
548 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_1_0);
549 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_1_1);
550
551 DUMPREG(HDMI_V_BLANK_F2_0);
552 DUMPREG(HDMI_V_BLANK_F2_1);
553 DUMPREG(HDMI_V_BLANK_F3_0);
554 DUMPREG(HDMI_V_BLANK_F3_1);
555 DUMPREG(HDMI_V_BLANK_F4_0);
556 DUMPREG(HDMI_V_BLANK_F4_1);
557 DUMPREG(HDMI_V_BLANK_F5_0);
558 DUMPREG(HDMI_V_BLANK_F5_1);
559
560 DUMPREG(HDMI_V_SYNC_LINE_AFT_3_0);
561 DUMPREG(HDMI_V_SYNC_LINE_AFT_3_1);
562 DUMPREG(HDMI_V_SYNC_LINE_AFT_4_0);
563 DUMPREG(HDMI_V_SYNC_LINE_AFT_4_1);
564 DUMPREG(HDMI_V_SYNC_LINE_AFT_5_0);
565 DUMPREG(HDMI_V_SYNC_LINE_AFT_5_1);
566 DUMPREG(HDMI_V_SYNC_LINE_AFT_6_0);
567 DUMPREG(HDMI_V_SYNC_LINE_AFT_6_1);
568
569 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_3_0);
570 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_3_1);
571 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_4_0);
572 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_4_1);
573 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_5_0);
574 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_5_1);
575 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_6_0);
576 DUMPREG(HDMI_V_SYNC_LINE_AFT_PXL_6_1);
577
578 DUMPREG(HDMI_VACT_SPACE_1_0);
579 DUMPREG(HDMI_VACT_SPACE_1_1);
580 DUMPREG(HDMI_VACT_SPACE_2_0);
581 DUMPREG(HDMI_VACT_SPACE_2_1);
582 DUMPREG(HDMI_VACT_SPACE_3_0);
583 DUMPREG(HDMI_VACT_SPACE_3_1);
584 DUMPREG(HDMI_VACT_SPACE_4_0);
585 DUMPREG(HDMI_VACT_SPACE_4_1);
586 DUMPREG(HDMI_VACT_SPACE_5_0);
587 DUMPREG(HDMI_VACT_SPACE_5_1);
588 DUMPREG(HDMI_VACT_SPACE_6_0);
589 DUMPREG(HDMI_VACT_SPACE_6_1);
590
591 DRM_DEBUG_KMS("%s: ---- TG REGISTERS ----\n", prefix);
592 DUMPREG(HDMI_TG_CMD);
593 DUMPREG(HDMI_TG_H_FSZ_L);
594 DUMPREG(HDMI_TG_H_FSZ_H);
595 DUMPREG(HDMI_TG_HACT_ST_L);
596 DUMPREG(HDMI_TG_HACT_ST_H);
597 DUMPREG(HDMI_TG_HACT_SZ_L);
598 DUMPREG(HDMI_TG_HACT_SZ_H);
599 DUMPREG(HDMI_TG_V_FSZ_L);
600 DUMPREG(HDMI_TG_V_FSZ_H);
601 DUMPREG(HDMI_TG_VSYNC_L);
602 DUMPREG(HDMI_TG_VSYNC_H);
603 DUMPREG(HDMI_TG_VSYNC2_L);
604 DUMPREG(HDMI_TG_VSYNC2_H);
605 DUMPREG(HDMI_TG_VACT_ST_L);
606 DUMPREG(HDMI_TG_VACT_ST_H);
607 DUMPREG(HDMI_TG_VACT_SZ_L);
608 DUMPREG(HDMI_TG_VACT_SZ_H);
609 DUMPREG(HDMI_TG_FIELD_CHG_L);
610 DUMPREG(HDMI_TG_FIELD_CHG_H);
611 DUMPREG(HDMI_TG_VACT_ST2_L);
612 DUMPREG(HDMI_TG_VACT_ST2_H);
613 DUMPREG(HDMI_TG_VACT_ST3_L);
614 DUMPREG(HDMI_TG_VACT_ST3_H);
615 DUMPREG(HDMI_TG_VACT_ST4_L);
616 DUMPREG(HDMI_TG_VACT_ST4_H);
617 DUMPREG(HDMI_TG_VSYNC_TOP_HDMI_L);
618 DUMPREG(HDMI_TG_VSYNC_TOP_HDMI_H);
619 DUMPREG(HDMI_TG_VSYNC_BOT_HDMI_L);
620 DUMPREG(HDMI_TG_VSYNC_BOT_HDMI_H);
621 DUMPREG(HDMI_TG_FIELD_TOP_HDMI_L);
622 DUMPREG(HDMI_TG_FIELD_TOP_HDMI_H);
623 DUMPREG(HDMI_TG_FIELD_BOT_HDMI_L);
624 DUMPREG(HDMI_TG_FIELD_BOT_HDMI_H);
625 DUMPREG(HDMI_TG_3D);
626
627 DRM_DEBUG_KMS("%s: ---- PACKET REGISTERS ----\n", prefix);
628 DUMPREG(HDMI_AVI_CON);
629 DUMPREG(HDMI_AVI_HEADER0);
630 DUMPREG(HDMI_AVI_HEADER1);
631 DUMPREG(HDMI_AVI_HEADER2);
632 DUMPREG(HDMI_AVI_CHECK_SUM);
633 DUMPREG(HDMI_VSI_CON);
634 DUMPREG(HDMI_VSI_HEADER0);
635 DUMPREG(HDMI_VSI_HEADER1);
636 DUMPREG(HDMI_VSI_HEADER2);
637 for (i = 0; i < 7; ++i)
638 DUMPREG(HDMI_VSI_DATA(i));
639
640 #undef DUMPREG
641 }
642
643 static void hdmi_regs_dump(struct hdmi_context *hdata, char *prefix)
644 {
645 if (hdata->type == HDMI_TYPE13)
646 hdmi_v13_regs_dump(hdata, prefix);
647 else
648 hdmi_v14_regs_dump(hdata, prefix);
649 }
650
651 static u8 hdmi_chksum(struct hdmi_context *hdata,
652 u32 start, u8 len, u32 hdr_sum)
653 {
654 int i;
655
656 /* hdr_sum : header0 + header1 + header2
657 * start : start address of packet byte1
658 * len : packet bytes - 1 */
659 for (i = 0; i < len; ++i)
660 hdr_sum += 0xff & hdmi_reg_read(hdata, start + i * 4);
661
662 /* return 2's complement of 8 bit hdr_sum */
663 return (u8)(~(hdr_sum & 0xff) + 1);
664 }
665
666 static void hdmi_reg_infoframe(struct hdmi_context *hdata,
667 union hdmi_infoframe *infoframe)
668 {
669 u32 hdr_sum;
670 u8 chksum;
671 u32 aspect_ratio;
672 u32 mod;
673 u32 vic;
674
675 mod = hdmi_reg_read(hdata, HDMI_MODE_SEL);
676 if (hdata->dvi_mode) {
677 hdmi_reg_writeb(hdata, HDMI_VSI_CON,
678 HDMI_VSI_CON_DO_NOT_TRANSMIT);
679 hdmi_reg_writeb(hdata, HDMI_AVI_CON,
680 HDMI_AVI_CON_DO_NOT_TRANSMIT);
681 hdmi_reg_writeb(hdata, HDMI_AUI_CON, HDMI_AUI_CON_NO_TRAN);
682 return;
683 }
684
685 switch (infoframe->any.type) {
686 case HDMI_INFOFRAME_TYPE_AVI:
687 hdmi_reg_writeb(hdata, HDMI_AVI_CON, HDMI_AVI_CON_EVERY_VSYNC);
688 hdmi_reg_writeb(hdata, HDMI_AVI_HEADER0, infoframe->any.type);
689 hdmi_reg_writeb(hdata, HDMI_AVI_HEADER1,
690 infoframe->any.version);
691 hdmi_reg_writeb(hdata, HDMI_AVI_HEADER2, infoframe->any.length);
692 hdr_sum = infoframe->any.type + infoframe->any.version +
693 infoframe->any.length;
694
695 /* Output format zero hardcoded ,RGB YBCR selection */
696 hdmi_reg_writeb(hdata, HDMI_AVI_BYTE(1), 0 << 5 |
697 AVI_ACTIVE_FORMAT_VALID |
698 AVI_UNDERSCANNED_DISPLAY_VALID);
699
700 aspect_ratio = AVI_PIC_ASPECT_RATIO_16_9;
701
702 hdmi_reg_writeb(hdata, HDMI_AVI_BYTE(2), aspect_ratio |
703 AVI_SAME_AS_PIC_ASPECT_RATIO);
704
705 vic = hdata->mode_conf.cea_video_id;
706 hdmi_reg_writeb(hdata, HDMI_AVI_BYTE(4), vic);
707
708 chksum = hdmi_chksum(hdata, HDMI_AVI_BYTE(1),
709 infoframe->any.length, hdr_sum);
710 DRM_DEBUG_KMS("AVI checksum = 0x%x\n", chksum);
711 hdmi_reg_writeb(hdata, HDMI_AVI_CHECK_SUM, chksum);
712 break;
713 case HDMI_INFOFRAME_TYPE_AUDIO:
714 hdmi_reg_writeb(hdata, HDMI_AUI_CON, 0x02);
715 hdmi_reg_writeb(hdata, HDMI_AUI_HEADER0, infoframe->any.type);
716 hdmi_reg_writeb(hdata, HDMI_AUI_HEADER1,
717 infoframe->any.version);
718 hdmi_reg_writeb(hdata, HDMI_AUI_HEADER2, infoframe->any.length);
719 hdr_sum = infoframe->any.type + infoframe->any.version +
720 infoframe->any.length;
721 chksum = hdmi_chksum(hdata, HDMI_AUI_BYTE(1),
722 infoframe->any.length, hdr_sum);
723 DRM_DEBUG_KMS("AUI checksum = 0x%x\n", chksum);
724 hdmi_reg_writeb(hdata, HDMI_AUI_CHECK_SUM, chksum);
725 break;
726 default:
727 break;
728 }
729 }
730
731 static bool hdmi_is_connected(void *ctx)
732 {
733 struct hdmi_context *hdata = ctx;
734
735 return hdata->hpd;
736 }
737
738 static struct edid *hdmi_get_edid(void *ctx, struct drm_connector *connector)
739 {
740 struct edid *raw_edid;
741 struct hdmi_context *hdata = ctx;
742
743 if (!hdata->ddc_port)
744 return ERR_PTR(-ENODEV);
745
746 raw_edid = drm_get_edid(connector, hdata->ddc_port->adapter);
747 if (!raw_edid)
748 return ERR_PTR(-ENODEV);
749
750 hdata->dvi_mode = !drm_detect_hdmi_monitor(raw_edid);
751 DRM_DEBUG_KMS("%s : width[%d] x height[%d]\n",
752 (hdata->dvi_mode ? "dvi monitor" : "hdmi monitor"),
753 raw_edid->width_cm, raw_edid->height_cm);
754
755 return raw_edid;
756 }
757
758 static int hdmi_find_phy_conf(struct hdmi_context *hdata, u32 pixel_clock)
759 {
760 const struct hdmiphy_config *confs;
761 int count, i;
762
763 if (hdata->type == HDMI_TYPE13) {
764 confs = hdmiphy_v13_configs;
765 count = ARRAY_SIZE(hdmiphy_v13_configs);
766 } else if (hdata->type == HDMI_TYPE14) {
767 confs = hdmiphy_v14_configs;
768 count = ARRAY_SIZE(hdmiphy_v14_configs);
769 } else
770 return -EINVAL;
771
772 for (i = 0; i < count; i++)
773 if (confs[i].pixel_clock == pixel_clock)
774 return i;
775
776 DRM_DEBUG_KMS("Could not find phy config for %d\n", pixel_clock);
777 return -EINVAL;
778 }
779
780 static int hdmi_check_mode(void *ctx, struct drm_display_mode *mode)
781 {
782 struct hdmi_context *hdata = ctx;
783 int ret;
784
785 DRM_DEBUG_KMS("xres=%d, yres=%d, refresh=%d, intl=%d clock=%d\n",
786 mode->hdisplay, mode->vdisplay, mode->vrefresh,
787 (mode->flags & DRM_MODE_FLAG_INTERLACE) ? true :
788 false, mode->clock * 1000);
789
790 ret = hdmi_find_phy_conf(hdata, mode->clock * 1000);
791 if (ret < 0)
792 return ret;
793 return 0;
794 }
795
796 static void hdmi_set_acr(u32 freq, u8 *acr)
797 {
798 u32 n, cts;
799
800 switch (freq) {
801 case 32000:
802 n = 4096;
803 cts = 27000;
804 break;
805 case 44100:
806 n = 6272;
807 cts = 30000;
808 break;
809 case 88200:
810 n = 12544;
811 cts = 30000;
812 break;
813 case 176400:
814 n = 25088;
815 cts = 30000;
816 break;
817 case 48000:
818 n = 6144;
819 cts = 27000;
820 break;
821 case 96000:
822 n = 12288;
823 cts = 27000;
824 break;
825 case 192000:
826 n = 24576;
827 cts = 27000;
828 break;
829 default:
830 n = 0;
831 cts = 0;
832 break;
833 }
834
835 acr[1] = cts >> 16;
836 acr[2] = cts >> 8 & 0xff;
837 acr[3] = cts & 0xff;
838
839 acr[4] = n >> 16;
840 acr[5] = n >> 8 & 0xff;
841 acr[6] = n & 0xff;
842 }
843
844 static void hdmi_reg_acr(struct hdmi_context *hdata, u8 *acr)
845 {
846 hdmi_reg_writeb(hdata, HDMI_ACR_N0, acr[6]);
847 hdmi_reg_writeb(hdata, HDMI_ACR_N1, acr[5]);
848 hdmi_reg_writeb(hdata, HDMI_ACR_N2, acr[4]);
849 hdmi_reg_writeb(hdata, HDMI_ACR_MCTS0, acr[3]);
850 hdmi_reg_writeb(hdata, HDMI_ACR_MCTS1, acr[2]);
851 hdmi_reg_writeb(hdata, HDMI_ACR_MCTS2, acr[1]);
852 hdmi_reg_writeb(hdata, HDMI_ACR_CTS0, acr[3]);
853 hdmi_reg_writeb(hdata, HDMI_ACR_CTS1, acr[2]);
854 hdmi_reg_writeb(hdata, HDMI_ACR_CTS2, acr[1]);
855
856 if (hdata->type == HDMI_TYPE13)
857 hdmi_reg_writeb(hdata, HDMI_V13_ACR_CON, 4);
858 else
859 hdmi_reg_writeb(hdata, HDMI_ACR_CON, 4);
860 }
861
862 static void hdmi_audio_init(struct hdmi_context *hdata)
863 {
864 u32 sample_rate, bits_per_sample, frame_size_code;
865 u32 data_num, bit_ch, sample_frq;
866 u32 val;
867 u8 acr[7];
868
869 sample_rate = 44100;
870 bits_per_sample = 16;
871 frame_size_code = 0;
872
873 switch (bits_per_sample) {
874 case 20:
875 data_num = 2;
876 bit_ch = 1;
877 break;
878 case 24:
879 data_num = 3;
880 bit_ch = 1;
881 break;
882 default:
883 data_num = 1;
884 bit_ch = 0;
885 break;
886 }
887
888 hdmi_set_acr(sample_rate, acr);
889 hdmi_reg_acr(hdata, acr);
890
891 hdmi_reg_writeb(hdata, HDMI_I2S_MUX_CON, HDMI_I2S_IN_DISABLE
892 | HDMI_I2S_AUD_I2S | HDMI_I2S_CUV_I2S_ENABLE
893 | HDMI_I2S_MUX_ENABLE);
894
895 hdmi_reg_writeb(hdata, HDMI_I2S_MUX_CH, HDMI_I2S_CH0_EN
896 | HDMI_I2S_CH1_EN | HDMI_I2S_CH2_EN);
897
898 hdmi_reg_writeb(hdata, HDMI_I2S_MUX_CUV, HDMI_I2S_CUV_RL_EN);
899
900 sample_frq = (sample_rate == 44100) ? 0 :
901 (sample_rate == 48000) ? 2 :
902 (sample_rate == 32000) ? 3 :
903 (sample_rate == 96000) ? 0xa : 0x0;
904
905 hdmi_reg_writeb(hdata, HDMI_I2S_CLK_CON, HDMI_I2S_CLK_DIS);
906 hdmi_reg_writeb(hdata, HDMI_I2S_CLK_CON, HDMI_I2S_CLK_EN);
907
908 val = hdmi_reg_read(hdata, HDMI_I2S_DSD_CON) | 0x01;
909 hdmi_reg_writeb(hdata, HDMI_I2S_DSD_CON, val);
910
911 /* Configuration I2S input ports. Configure I2S_PIN_SEL_0~4 */
912 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_0, HDMI_I2S_SEL_SCLK(5)
913 | HDMI_I2S_SEL_LRCK(6));
914 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_1, HDMI_I2S_SEL_SDATA1(1)
915 | HDMI_I2S_SEL_SDATA2(4));
916 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_2, HDMI_I2S_SEL_SDATA3(1)
917 | HDMI_I2S_SEL_SDATA2(2));
918 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_3, HDMI_I2S_SEL_DSD(0));
919
920 /* I2S_CON_1 & 2 */
921 hdmi_reg_writeb(hdata, HDMI_I2S_CON_1, HDMI_I2S_SCLK_FALLING_EDGE
922 | HDMI_I2S_L_CH_LOW_POL);
923 hdmi_reg_writeb(hdata, HDMI_I2S_CON_2, HDMI_I2S_MSB_FIRST_MODE
924 | HDMI_I2S_SET_BIT_CH(bit_ch)
925 | HDMI_I2S_SET_SDATA_BIT(data_num)
926 | HDMI_I2S_BASIC_FORMAT);
927
928 /* Configure register related to CUV information */
929 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_0, HDMI_I2S_CH_STATUS_MODE_0
930 | HDMI_I2S_2AUD_CH_WITHOUT_PREEMPH
931 | HDMI_I2S_COPYRIGHT
932 | HDMI_I2S_LINEAR_PCM
933 | HDMI_I2S_CONSUMER_FORMAT);
934 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_1, HDMI_I2S_CD_PLAYER);
935 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_2, HDMI_I2S_SET_SOURCE_NUM(0));
936 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_3, HDMI_I2S_CLK_ACCUR_LEVEL_2
937 | HDMI_I2S_SET_SMP_FREQ(sample_frq));
938 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_4,
939 HDMI_I2S_ORG_SMP_FREQ_44_1
940 | HDMI_I2S_WORD_LEN_MAX24_24BITS
941 | HDMI_I2S_WORD_LEN_MAX_24BITS);
942
943 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_CON, HDMI_I2S_CH_STATUS_RELOAD);
944 }
945
946 static void hdmi_audio_control(struct hdmi_context *hdata, bool onoff)
947 {
948 if (hdata->dvi_mode)
949 return;
950
951 hdmi_reg_writeb(hdata, HDMI_AUI_CON, onoff ? 2 : 0);
952 hdmi_reg_writemask(hdata, HDMI_CON_0, onoff ?
953 HDMI_ASP_EN : HDMI_ASP_DIS, HDMI_ASP_MASK);
954 }
955
956 static void hdmi_conf_reset(struct hdmi_context *hdata)
957 {
958 u32 reg;
959
960 if (hdata->type == HDMI_TYPE13)
961 reg = HDMI_V13_CORE_RSTOUT;
962 else
963 reg = HDMI_CORE_RSTOUT;
964
965 /* resetting HDMI core */
966 hdmi_reg_writemask(hdata, reg, 0, HDMI_CORE_SW_RSTOUT);
967 usleep_range(10000, 12000);
968 hdmi_reg_writemask(hdata, reg, ~0, HDMI_CORE_SW_RSTOUT);
969 usleep_range(10000, 12000);
970 }
971
972 static void hdmi_conf_init(struct hdmi_context *hdata)
973 {
974 union hdmi_infoframe infoframe;
975
976 /* disable HPD interrupts from HDMI IP block, use GPIO instead */
977 hdmi_reg_writemask(hdata, HDMI_INTC_CON, 0, HDMI_INTC_EN_GLOBAL |
978 HDMI_INTC_EN_HPD_PLUG | HDMI_INTC_EN_HPD_UNPLUG);
979
980 /* choose HDMI mode */
981 hdmi_reg_writemask(hdata, HDMI_MODE_SEL,
982 HDMI_MODE_HDMI_EN, HDMI_MODE_MASK);
983 /* disable bluescreen */
984 hdmi_reg_writemask(hdata, HDMI_CON_0, 0, HDMI_BLUE_SCR_EN);
985
986 if (hdata->dvi_mode) {
987 /* choose DVI mode */
988 hdmi_reg_writemask(hdata, HDMI_MODE_SEL,
989 HDMI_MODE_DVI_EN, HDMI_MODE_MASK);
990 hdmi_reg_writeb(hdata, HDMI_CON_2,
991 HDMI_VID_PREAMBLE_DIS | HDMI_GUARD_BAND_DIS);
992 }
993
994 if (hdata->type == HDMI_TYPE13) {
995 /* choose bluescreen (fecal) color */
996 hdmi_reg_writeb(hdata, HDMI_V13_BLUE_SCREEN_0, 0x12);
997 hdmi_reg_writeb(hdata, HDMI_V13_BLUE_SCREEN_1, 0x34);
998 hdmi_reg_writeb(hdata, HDMI_V13_BLUE_SCREEN_2, 0x56);
999
1000 /* enable AVI packet every vsync, fixes purple line problem */
1001 hdmi_reg_writeb(hdata, HDMI_V13_AVI_CON, 0x02);
1002 /* force RGB, look to CEA-861-D, table 7 for more detail */
1003 hdmi_reg_writeb(hdata, HDMI_V13_AVI_BYTE(0), 0 << 5);
1004 hdmi_reg_writemask(hdata, HDMI_CON_1, 0x10 << 5, 0x11 << 5);
1005
1006 hdmi_reg_writeb(hdata, HDMI_V13_SPD_CON, 0x02);
1007 hdmi_reg_writeb(hdata, HDMI_V13_AUI_CON, 0x02);
1008 hdmi_reg_writeb(hdata, HDMI_V13_ACR_CON, 0x04);
1009 } else {
1010 infoframe.any.type = HDMI_INFOFRAME_TYPE_AVI;
1011 infoframe.any.version = HDMI_AVI_VERSION;
1012 infoframe.any.length = HDMI_AVI_LENGTH;
1013 hdmi_reg_infoframe(hdata, &infoframe);
1014
1015 infoframe.any.type = HDMI_INFOFRAME_TYPE_AUDIO;
1016 infoframe.any.version = HDMI_AUI_VERSION;
1017 infoframe.any.length = HDMI_AUI_LENGTH;
1018 hdmi_reg_infoframe(hdata, &infoframe);
1019
1020 /* enable AVI packet every vsync, fixes purple line problem */
1021 hdmi_reg_writemask(hdata, HDMI_CON_1, 2, 3 << 5);
1022 }
1023 }
1024
1025 static void hdmi_v13_mode_apply(struct hdmi_context *hdata)
1026 {
1027 const struct hdmi_tg_regs *tg = &hdata->mode_conf.conf.v13_conf.tg;
1028 const struct hdmi_v13_core_regs *core =
1029 &hdata->mode_conf.conf.v13_conf.core;
1030 int tries;
1031
1032 /* setting core registers */
1033 hdmi_reg_writeb(hdata, HDMI_H_BLANK_0, core->h_blank[0]);
1034 hdmi_reg_writeb(hdata, HDMI_H_BLANK_1, core->h_blank[1]);
1035 hdmi_reg_writeb(hdata, HDMI_V13_V_BLANK_0, core->v_blank[0]);
1036 hdmi_reg_writeb(hdata, HDMI_V13_V_BLANK_1, core->v_blank[1]);
1037 hdmi_reg_writeb(hdata, HDMI_V13_V_BLANK_2, core->v_blank[2]);
1038 hdmi_reg_writeb(hdata, HDMI_V13_H_V_LINE_0, core->h_v_line[0]);
1039 hdmi_reg_writeb(hdata, HDMI_V13_H_V_LINE_1, core->h_v_line[1]);
1040 hdmi_reg_writeb(hdata, HDMI_V13_H_V_LINE_2, core->h_v_line[2]);
1041 hdmi_reg_writeb(hdata, HDMI_VSYNC_POL, core->vsync_pol[0]);
1042 hdmi_reg_writeb(hdata, HDMI_INT_PRO_MODE, core->int_pro_mode[0]);
1043 hdmi_reg_writeb(hdata, HDMI_V13_V_BLANK_F_0, core->v_blank_f[0]);
1044 hdmi_reg_writeb(hdata, HDMI_V13_V_BLANK_F_1, core->v_blank_f[1]);
1045 hdmi_reg_writeb(hdata, HDMI_V13_V_BLANK_F_2, core->v_blank_f[2]);
1046 hdmi_reg_writeb(hdata, HDMI_V13_H_SYNC_GEN_0, core->h_sync_gen[0]);
1047 hdmi_reg_writeb(hdata, HDMI_V13_H_SYNC_GEN_1, core->h_sync_gen[1]);
1048 hdmi_reg_writeb(hdata, HDMI_V13_H_SYNC_GEN_2, core->h_sync_gen[2]);
1049 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_1_0, core->v_sync_gen1[0]);
1050 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_1_1, core->v_sync_gen1[1]);
1051 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_1_2, core->v_sync_gen1[2]);
1052 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_2_0, core->v_sync_gen2[0]);
1053 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_2_1, core->v_sync_gen2[1]);
1054 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_2_2, core->v_sync_gen2[2]);
1055 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_3_0, core->v_sync_gen3[0]);
1056 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_3_1, core->v_sync_gen3[1]);
1057 hdmi_reg_writeb(hdata, HDMI_V13_V_SYNC_GEN_3_2, core->v_sync_gen3[2]);
1058 /* Timing generator registers */
1059 hdmi_reg_writeb(hdata, HDMI_TG_H_FSZ_L, tg->h_fsz[0]);
1060 hdmi_reg_writeb(hdata, HDMI_TG_H_FSZ_H, tg->h_fsz[1]);
1061 hdmi_reg_writeb(hdata, HDMI_TG_HACT_ST_L, tg->hact_st[0]);
1062 hdmi_reg_writeb(hdata, HDMI_TG_HACT_ST_H, tg->hact_st[1]);
1063 hdmi_reg_writeb(hdata, HDMI_TG_HACT_SZ_L, tg->hact_sz[0]);
1064 hdmi_reg_writeb(hdata, HDMI_TG_HACT_SZ_H, tg->hact_sz[1]);
1065 hdmi_reg_writeb(hdata, HDMI_TG_V_FSZ_L, tg->v_fsz[0]);
1066 hdmi_reg_writeb(hdata, HDMI_TG_V_FSZ_H, tg->v_fsz[1]);
1067 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_L, tg->vsync[0]);
1068 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_H, tg->vsync[1]);
1069 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC2_L, tg->vsync2[0]);
1070 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC2_H, tg->vsync2[1]);
1071 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST_L, tg->vact_st[0]);
1072 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST_H, tg->vact_st[1]);
1073 hdmi_reg_writeb(hdata, HDMI_TG_VACT_SZ_L, tg->vact_sz[0]);
1074 hdmi_reg_writeb(hdata, HDMI_TG_VACT_SZ_H, tg->vact_sz[1]);
1075 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_CHG_L, tg->field_chg[0]);
1076 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_CHG_H, tg->field_chg[1]);
1077 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST2_L, tg->vact_st2[0]);
1078 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST2_H, tg->vact_st2[1]);
1079 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_TOP_HDMI_L, tg->vsync_top_hdmi[0]);
1080 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_TOP_HDMI_H, tg->vsync_top_hdmi[1]);
1081 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_BOT_HDMI_L, tg->vsync_bot_hdmi[0]);
1082 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_BOT_HDMI_H, tg->vsync_bot_hdmi[1]);
1083 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_TOP_HDMI_L, tg->field_top_hdmi[0]);
1084 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_TOP_HDMI_H, tg->field_top_hdmi[1]);
1085 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_BOT_HDMI_L, tg->field_bot_hdmi[0]);
1086 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_BOT_HDMI_H, tg->field_bot_hdmi[1]);
1087
1088 /* waiting for HDMIPHY's PLL to get to steady state */
1089 for (tries = 100; tries; --tries) {
1090 u32 val = hdmi_reg_read(hdata, HDMI_V13_PHY_STATUS);
1091 if (val & HDMI_PHY_STATUS_READY)
1092 break;
1093 usleep_range(1000, 2000);
1094 }
1095 /* steady state not achieved */
1096 if (tries == 0) {
1097 DRM_ERROR("hdmiphy's pll could not reach steady state.\n");
1098 hdmi_regs_dump(hdata, "timing apply");
1099 }
1100
1101 clk_disable_unprepare(hdata->res.sclk_hdmi);
1102 clk_set_parent(hdata->res.mout_hdmi, hdata->res.sclk_hdmiphy);
1103 clk_prepare_enable(hdata->res.sclk_hdmi);
1104
1105 /* enable HDMI and timing generator */
1106 hdmi_reg_writemask(hdata, HDMI_CON_0, ~0, HDMI_EN);
1107 if (core->int_pro_mode[0])
1108 hdmi_reg_writemask(hdata, HDMI_TG_CMD, ~0, HDMI_TG_EN |
1109 HDMI_FIELD_EN);
1110 else
1111 hdmi_reg_writemask(hdata, HDMI_TG_CMD, ~0, HDMI_TG_EN);
1112 }
1113
1114 static void hdmi_v14_mode_apply(struct hdmi_context *hdata)
1115 {
1116 const struct hdmi_tg_regs *tg = &hdata->mode_conf.conf.v14_conf.tg;
1117 const struct hdmi_v14_core_regs *core =
1118 &hdata->mode_conf.conf.v14_conf.core;
1119 int tries;
1120
1121 /* setting core registers */
1122 hdmi_reg_writeb(hdata, HDMI_H_BLANK_0, core->h_blank[0]);
1123 hdmi_reg_writeb(hdata, HDMI_H_BLANK_1, core->h_blank[1]);
1124 hdmi_reg_writeb(hdata, HDMI_V2_BLANK_0, core->v2_blank[0]);
1125 hdmi_reg_writeb(hdata, HDMI_V2_BLANK_1, core->v2_blank[1]);
1126 hdmi_reg_writeb(hdata, HDMI_V1_BLANK_0, core->v1_blank[0]);
1127 hdmi_reg_writeb(hdata, HDMI_V1_BLANK_1, core->v1_blank[1]);
1128 hdmi_reg_writeb(hdata, HDMI_V_LINE_0, core->v_line[0]);
1129 hdmi_reg_writeb(hdata, HDMI_V_LINE_1, core->v_line[1]);
1130 hdmi_reg_writeb(hdata, HDMI_H_LINE_0, core->h_line[0]);
1131 hdmi_reg_writeb(hdata, HDMI_H_LINE_1, core->h_line[1]);
1132 hdmi_reg_writeb(hdata, HDMI_HSYNC_POL, core->hsync_pol[0]);
1133 hdmi_reg_writeb(hdata, HDMI_VSYNC_POL, core->vsync_pol[0]);
1134 hdmi_reg_writeb(hdata, HDMI_INT_PRO_MODE, core->int_pro_mode[0]);
1135 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F0_0, core->v_blank_f0[0]);
1136 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F0_1, core->v_blank_f0[1]);
1137 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F1_0, core->v_blank_f1[0]);
1138 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F1_1, core->v_blank_f1[1]);
1139 hdmi_reg_writeb(hdata, HDMI_H_SYNC_START_0, core->h_sync_start[0]);
1140 hdmi_reg_writeb(hdata, HDMI_H_SYNC_START_1, core->h_sync_start[1]);
1141 hdmi_reg_writeb(hdata, HDMI_H_SYNC_END_0, core->h_sync_end[0]);
1142 hdmi_reg_writeb(hdata, HDMI_H_SYNC_END_1, core->h_sync_end[1]);
1143 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_BEF_2_0,
1144 core->v_sync_line_bef_2[0]);
1145 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_BEF_2_1,
1146 core->v_sync_line_bef_2[1]);
1147 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_BEF_1_0,
1148 core->v_sync_line_bef_1[0]);
1149 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_BEF_1_1,
1150 core->v_sync_line_bef_1[1]);
1151 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_2_0,
1152 core->v_sync_line_aft_2[0]);
1153 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_2_1,
1154 core->v_sync_line_aft_2[1]);
1155 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_1_0,
1156 core->v_sync_line_aft_1[0]);
1157 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_1_1,
1158 core->v_sync_line_aft_1[1]);
1159 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_2_0,
1160 core->v_sync_line_aft_pxl_2[0]);
1161 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_2_1,
1162 core->v_sync_line_aft_pxl_2[1]);
1163 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_1_0,
1164 core->v_sync_line_aft_pxl_1[0]);
1165 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_1_1,
1166 core->v_sync_line_aft_pxl_1[1]);
1167 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F2_0, core->v_blank_f2[0]);
1168 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F2_1, core->v_blank_f2[1]);
1169 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F3_0, core->v_blank_f3[0]);
1170 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F3_1, core->v_blank_f3[1]);
1171 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F4_0, core->v_blank_f4[0]);
1172 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F4_1, core->v_blank_f4[1]);
1173 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F5_0, core->v_blank_f5[0]);
1174 hdmi_reg_writeb(hdata, HDMI_V_BLANK_F5_1, core->v_blank_f5[1]);
1175 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_3_0,
1176 core->v_sync_line_aft_3[0]);
1177 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_3_1,
1178 core->v_sync_line_aft_3[1]);
1179 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_4_0,
1180 core->v_sync_line_aft_4[0]);
1181 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_4_1,
1182 core->v_sync_line_aft_4[1]);
1183 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_5_0,
1184 core->v_sync_line_aft_5[0]);
1185 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_5_1,
1186 core->v_sync_line_aft_5[1]);
1187 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_6_0,
1188 core->v_sync_line_aft_6[0]);
1189 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_6_1,
1190 core->v_sync_line_aft_6[1]);
1191 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_3_0,
1192 core->v_sync_line_aft_pxl_3[0]);
1193 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_3_1,
1194 core->v_sync_line_aft_pxl_3[1]);
1195 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_4_0,
1196 core->v_sync_line_aft_pxl_4[0]);
1197 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_4_1,
1198 core->v_sync_line_aft_pxl_4[1]);
1199 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_5_0,
1200 core->v_sync_line_aft_pxl_5[0]);
1201 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_5_1,
1202 core->v_sync_line_aft_pxl_5[1]);
1203 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_6_0,
1204 core->v_sync_line_aft_pxl_6[0]);
1205 hdmi_reg_writeb(hdata, HDMI_V_SYNC_LINE_AFT_PXL_6_1,
1206 core->v_sync_line_aft_pxl_6[1]);
1207 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_1_0, core->vact_space_1[0]);
1208 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_1_1, core->vact_space_1[1]);
1209 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_2_0, core->vact_space_2[0]);
1210 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_2_1, core->vact_space_2[1]);
1211 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_3_0, core->vact_space_3[0]);
1212 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_3_1, core->vact_space_3[1]);
1213 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_4_0, core->vact_space_4[0]);
1214 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_4_1, core->vact_space_4[1]);
1215 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_5_0, core->vact_space_5[0]);
1216 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_5_1, core->vact_space_5[1]);
1217 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_6_0, core->vact_space_6[0]);
1218 hdmi_reg_writeb(hdata, HDMI_VACT_SPACE_6_1, core->vact_space_6[1]);
1219
1220 /* Timing generator registers */
1221 hdmi_reg_writeb(hdata, HDMI_TG_H_FSZ_L, tg->h_fsz[0]);
1222 hdmi_reg_writeb(hdata, HDMI_TG_H_FSZ_H, tg->h_fsz[1]);
1223 hdmi_reg_writeb(hdata, HDMI_TG_HACT_ST_L, tg->hact_st[0]);
1224 hdmi_reg_writeb(hdata, HDMI_TG_HACT_ST_H, tg->hact_st[1]);
1225 hdmi_reg_writeb(hdata, HDMI_TG_HACT_SZ_L, tg->hact_sz[0]);
1226 hdmi_reg_writeb(hdata, HDMI_TG_HACT_SZ_H, tg->hact_sz[1]);
1227 hdmi_reg_writeb(hdata, HDMI_TG_V_FSZ_L, tg->v_fsz[0]);
1228 hdmi_reg_writeb(hdata, HDMI_TG_V_FSZ_H, tg->v_fsz[1]);
1229 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_L, tg->vsync[0]);
1230 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_H, tg->vsync[1]);
1231 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC2_L, tg->vsync2[0]);
1232 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC2_H, tg->vsync2[1]);
1233 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST_L, tg->vact_st[0]);
1234 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST_H, tg->vact_st[1]);
1235 hdmi_reg_writeb(hdata, HDMI_TG_VACT_SZ_L, tg->vact_sz[0]);
1236 hdmi_reg_writeb(hdata, HDMI_TG_VACT_SZ_H, tg->vact_sz[1]);
1237 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_CHG_L, tg->field_chg[0]);
1238 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_CHG_H, tg->field_chg[1]);
1239 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST2_L, tg->vact_st2[0]);
1240 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST2_H, tg->vact_st2[1]);
1241 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST3_L, tg->vact_st3[0]);
1242 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST3_H, tg->vact_st3[1]);
1243 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST4_L, tg->vact_st4[0]);
1244 hdmi_reg_writeb(hdata, HDMI_TG_VACT_ST4_H, tg->vact_st4[1]);
1245 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_TOP_HDMI_L, tg->vsync_top_hdmi[0]);
1246 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_TOP_HDMI_H, tg->vsync_top_hdmi[1]);
1247 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_BOT_HDMI_L, tg->vsync_bot_hdmi[0]);
1248 hdmi_reg_writeb(hdata, HDMI_TG_VSYNC_BOT_HDMI_H, tg->vsync_bot_hdmi[1]);
1249 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_TOP_HDMI_L, tg->field_top_hdmi[0]);
1250 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_TOP_HDMI_H, tg->field_top_hdmi[1]);
1251 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_BOT_HDMI_L, tg->field_bot_hdmi[0]);
1252 hdmi_reg_writeb(hdata, HDMI_TG_FIELD_BOT_HDMI_H, tg->field_bot_hdmi[1]);
1253 hdmi_reg_writeb(hdata, HDMI_TG_3D, tg->tg_3d[0]);
1254
1255 /* waiting for HDMIPHY's PLL to get to steady state */
1256 for (tries = 100; tries; --tries) {
1257 u32 val = hdmi_reg_read(hdata, HDMI_PHY_STATUS_0);
1258 if (val & HDMI_PHY_STATUS_READY)
1259 break;
1260 usleep_range(1000, 2000);
1261 }
1262 /* steady state not achieved */
1263 if (tries == 0) {
1264 DRM_ERROR("hdmiphy's pll could not reach steady state.\n");
1265 hdmi_regs_dump(hdata, "timing apply");
1266 }
1267
1268 clk_disable_unprepare(hdata->res.sclk_hdmi);
1269 clk_set_parent(hdata->res.mout_hdmi, hdata->res.sclk_hdmiphy);
1270 clk_prepare_enable(hdata->res.sclk_hdmi);
1271
1272 /* enable HDMI and timing generator */
1273 hdmi_reg_writemask(hdata, HDMI_CON_0, ~0, HDMI_EN);
1274 if (core->int_pro_mode[0])
1275 hdmi_reg_writemask(hdata, HDMI_TG_CMD, ~0, HDMI_TG_EN |
1276 HDMI_FIELD_EN);
1277 else
1278 hdmi_reg_writemask(hdata, HDMI_TG_CMD, ~0, HDMI_TG_EN);
1279 }
1280
1281 static void hdmi_mode_apply(struct hdmi_context *hdata)
1282 {
1283 if (hdata->type == HDMI_TYPE13)
1284 hdmi_v13_mode_apply(hdata);
1285 else
1286 hdmi_v14_mode_apply(hdata);
1287 }
1288
1289 static void hdmiphy_conf_reset(struct hdmi_context *hdata)
1290 {
1291 u8 buffer[2];
1292 u32 reg;
1293
1294 clk_disable_unprepare(hdata->res.sclk_hdmi);
1295 clk_set_parent(hdata->res.mout_hdmi, hdata->res.sclk_pixel);
1296 clk_prepare_enable(hdata->res.sclk_hdmi);
1297
1298 /* operation mode */
1299 buffer[0] = 0x1f;
1300 buffer[1] = 0x00;
1301
1302 if (hdata->hdmiphy_port)
1303 i2c_master_send(hdata->hdmiphy_port, buffer, 2);
1304
1305 if (hdata->type == HDMI_TYPE13)
1306 reg = HDMI_V13_PHY_RSTOUT;
1307 else
1308 reg = HDMI_PHY_RSTOUT;
1309
1310 /* reset hdmiphy */
1311 hdmi_reg_writemask(hdata, reg, ~0, HDMI_PHY_SW_RSTOUT);
1312 usleep_range(10000, 12000);
1313 hdmi_reg_writemask(hdata, reg, 0, HDMI_PHY_SW_RSTOUT);
1314 usleep_range(10000, 12000);
1315 }
1316
1317 static void hdmiphy_poweron(struct hdmi_context *hdata)
1318 {
1319 if (hdata->type == HDMI_TYPE14)
1320 hdmi_reg_writemask(hdata, HDMI_PHY_CON_0, 0,
1321 HDMI_PHY_POWER_OFF_EN);
1322 }
1323
1324 static void hdmiphy_poweroff(struct hdmi_context *hdata)
1325 {
1326 if (hdata->type == HDMI_TYPE14)
1327 hdmi_reg_writemask(hdata, HDMI_PHY_CON_0, ~0,
1328 HDMI_PHY_POWER_OFF_EN);
1329 }
1330
1331 static void hdmiphy_conf_apply(struct hdmi_context *hdata)
1332 {
1333 const u8 *hdmiphy_data;
1334 u8 buffer[32];
1335 u8 operation[2];
1336 u8 read_buffer[32] = {0, };
1337 int ret;
1338 int i;
1339
1340 if (!hdata->hdmiphy_port) {
1341 DRM_ERROR("hdmiphy is not attached\n");
1342 return;
1343 }
1344
1345 /* pixel clock */
1346 i = hdmi_find_phy_conf(hdata, hdata->mode_conf.pixel_clock);
1347 if (i < 0) {
1348 DRM_ERROR("failed to find hdmiphy conf\n");
1349 return;
1350 }
1351
1352 if (hdata->type == HDMI_TYPE13)
1353 hdmiphy_data = hdmiphy_v13_configs[i].conf;
1354 else
1355 hdmiphy_data = hdmiphy_v14_configs[i].conf;
1356
1357 memcpy(buffer, hdmiphy_data, 32);
1358 ret = i2c_master_send(hdata->hdmiphy_port, buffer, 32);
1359 if (ret != 32) {
1360 DRM_ERROR("failed to configure HDMIPHY via I2C\n");
1361 return;
1362 }
1363
1364 usleep_range(10000, 12000);
1365
1366 /* operation mode */
1367 operation[0] = 0x1f;
1368 operation[1] = 0x80;
1369
1370 ret = i2c_master_send(hdata->hdmiphy_port, operation, 2);
1371 if (ret != 2) {
1372 DRM_ERROR("failed to enable hdmiphy\n");
1373 return;
1374 }
1375
1376 ret = i2c_master_recv(hdata->hdmiphy_port, read_buffer, 32);
1377 if (ret < 0) {
1378 DRM_ERROR("failed to read hdmiphy config\n");
1379 return;
1380 }
1381
1382 for (i = 0; i < ret; i++)
1383 DRM_DEBUG_KMS("hdmiphy[0x%02x] write[0x%02x] - "
1384 "recv [0x%02x]\n", i, buffer[i], read_buffer[i]);
1385 }
1386
1387 static void hdmi_conf_apply(struct hdmi_context *hdata)
1388 {
1389 hdmiphy_conf_reset(hdata);
1390 hdmiphy_conf_apply(hdata);
1391
1392 mutex_lock(&hdata->hdmi_mutex);
1393 hdmi_conf_reset(hdata);
1394 hdmi_conf_init(hdata);
1395 mutex_unlock(&hdata->hdmi_mutex);
1396
1397 hdmi_audio_init(hdata);
1398
1399 /* setting core registers */
1400 hdmi_mode_apply(hdata);
1401 hdmi_audio_control(hdata, true);
1402
1403 hdmi_regs_dump(hdata, "start");
1404 }
1405
1406 static void hdmi_set_reg(u8 *reg_pair, int num_bytes, u32 value)
1407 {
1408 int i;
1409 BUG_ON(num_bytes > 4);
1410 for (i = 0; i < num_bytes; i++)
1411 reg_pair[i] = (value >> (8 * i)) & 0xff;
1412 }
1413
1414 static void hdmi_v13_mode_set(struct hdmi_context *hdata,
1415 struct drm_display_mode *m)
1416 {
1417 struct hdmi_v13_core_regs *core = &hdata->mode_conf.conf.v13_conf.core;
1418 struct hdmi_tg_regs *tg = &hdata->mode_conf.conf.v13_conf.tg;
1419 unsigned int val;
1420
1421 hdata->mode_conf.cea_video_id =
1422 drm_match_cea_mode((struct drm_display_mode *)m);
1423 hdata->mode_conf.pixel_clock = m->clock * 1000;
1424
1425 hdmi_set_reg(core->h_blank, 2, m->htotal - m->hdisplay);
1426 hdmi_set_reg(core->h_v_line, 3, (m->htotal << 12) | m->vtotal);
1427
1428 val = (m->flags & DRM_MODE_FLAG_NVSYNC) ? 1 : 0;
1429 hdmi_set_reg(core->vsync_pol, 1, val);
1430
1431 val = (m->flags & DRM_MODE_FLAG_INTERLACE) ? 1 : 0;
1432 hdmi_set_reg(core->int_pro_mode, 1, val);
1433
1434 val = (m->hsync_start - m->hdisplay - 2);
1435 val |= ((m->hsync_end - m->hdisplay - 2) << 10);
1436 val |= ((m->flags & DRM_MODE_FLAG_NHSYNC) ? 1 : 0)<<20;
1437 hdmi_set_reg(core->h_sync_gen, 3, val);
1438
1439 /*
1440 * Quirk requirement for exynos HDMI IP design,
1441 * 2 pixels less than the actual calculation for hsync_start
1442 * and end.
1443 */
1444
1445 /* Following values & calculations differ for different type of modes */
1446 if (m->flags & DRM_MODE_FLAG_INTERLACE) {
1447 /* Interlaced Mode */
1448 val = ((m->vsync_end - m->vdisplay) / 2);
1449 val |= ((m->vsync_start - m->vdisplay) / 2) << 12;
1450 hdmi_set_reg(core->v_sync_gen1, 3, val);
1451
1452 val = m->vtotal / 2;
1453 val |= ((m->vtotal - m->vdisplay) / 2) << 11;
1454 hdmi_set_reg(core->v_blank, 3, val);
1455
1456 val = (m->vtotal +
1457 ((m->vsync_end - m->vsync_start) * 4) + 5) / 2;
1458 val |= m->vtotal << 11;
1459 hdmi_set_reg(core->v_blank_f, 3, val);
1460
1461 val = ((m->vtotal / 2) + 7);
1462 val |= ((m->vtotal / 2) + 2) << 12;
1463 hdmi_set_reg(core->v_sync_gen2, 3, val);
1464
1465 val = ((m->htotal / 2) + (m->hsync_start - m->hdisplay));
1466 val |= ((m->htotal / 2) +
1467 (m->hsync_start - m->hdisplay)) << 12;
1468 hdmi_set_reg(core->v_sync_gen3, 3, val);
1469
1470 hdmi_set_reg(tg->vact_st, 2, (m->vtotal - m->vdisplay) / 2);
1471 hdmi_set_reg(tg->vact_sz, 2, m->vdisplay / 2);
1472
1473 hdmi_set_reg(tg->vact_st2, 2, 0x249);/* Reset value + 1*/
1474 } else {
1475 /* Progressive Mode */
1476
1477 val = m->vtotal;
1478 val |= (m->vtotal - m->vdisplay) << 11;
1479 hdmi_set_reg(core->v_blank, 3, val);
1480
1481 hdmi_set_reg(core->v_blank_f, 3, 0);
1482
1483 val = (m->vsync_end - m->vdisplay);
1484 val |= ((m->vsync_start - m->vdisplay) << 12);
1485 hdmi_set_reg(core->v_sync_gen1, 3, val);
1486
1487 hdmi_set_reg(core->v_sync_gen2, 3, 0x1001);/* Reset value */
1488 hdmi_set_reg(core->v_sync_gen3, 3, 0x1001);/* Reset value */
1489 hdmi_set_reg(tg->vact_st, 2, m->vtotal - m->vdisplay);
1490 hdmi_set_reg(tg->vact_sz, 2, m->vdisplay);
1491 hdmi_set_reg(tg->vact_st2, 2, 0x248); /* Reset value */
1492 }
1493
1494 /* Timing generator registers */
1495 hdmi_set_reg(tg->cmd, 1, 0x0);
1496 hdmi_set_reg(tg->h_fsz, 2, m->htotal);
1497 hdmi_set_reg(tg->hact_st, 2, m->htotal - m->hdisplay);
1498 hdmi_set_reg(tg->hact_sz, 2, m->hdisplay);
1499 hdmi_set_reg(tg->v_fsz, 2, m->vtotal);
1500 hdmi_set_reg(tg->vsync, 2, 0x1);
1501 hdmi_set_reg(tg->vsync2, 2, 0x233); /* Reset value */
1502 hdmi_set_reg(tg->field_chg, 2, 0x233); /* Reset value */
1503 hdmi_set_reg(tg->vsync_top_hdmi, 2, 0x1); /* Reset value */
1504 hdmi_set_reg(tg->vsync_bot_hdmi, 2, 0x233); /* Reset value */
1505 hdmi_set_reg(tg->field_top_hdmi, 2, 0x1); /* Reset value */
1506 hdmi_set_reg(tg->field_bot_hdmi, 2, 0x233); /* Reset value */
1507 hdmi_set_reg(tg->tg_3d, 1, 0x0); /* Not used */
1508 }
1509
1510 static void hdmi_v14_mode_set(struct hdmi_context *hdata,
1511 struct drm_display_mode *m)
1512 {
1513 struct hdmi_tg_regs *tg = &hdata->mode_conf.conf.v14_conf.tg;
1514 struct hdmi_v14_core_regs *core =
1515 &hdata->mode_conf.conf.v14_conf.core;
1516
1517 hdata->mode_conf.cea_video_id =
1518 drm_match_cea_mode((struct drm_display_mode *)m);
1519 hdata->mode_conf.pixel_clock = m->clock * 1000;
1520
1521 hdmi_set_reg(core->h_blank, 2, m->htotal - m->hdisplay);
1522 hdmi_set_reg(core->v_line, 2, m->vtotal);
1523 hdmi_set_reg(core->h_line, 2, m->htotal);
1524 hdmi_set_reg(core->hsync_pol, 1,
1525 (m->flags & DRM_MODE_FLAG_NHSYNC) ? 1 : 0);
1526 hdmi_set_reg(core->vsync_pol, 1,
1527 (m->flags & DRM_MODE_FLAG_NVSYNC) ? 1 : 0);
1528 hdmi_set_reg(core->int_pro_mode, 1,
1529 (m->flags & DRM_MODE_FLAG_INTERLACE) ? 1 : 0);
1530
1531 /*
1532 * Quirk requirement for exynos 5 HDMI IP design,
1533 * 2 pixels less than the actual calculation for hsync_start
1534 * and end.
1535 */
1536
1537 /* Following values & calculations differ for different type of modes */
1538 if (m->flags & DRM_MODE_FLAG_INTERLACE) {
1539 /* Interlaced Mode */
1540 hdmi_set_reg(core->v_sync_line_bef_2, 2,
1541 (m->vsync_end - m->vdisplay) / 2);
1542 hdmi_set_reg(core->v_sync_line_bef_1, 2,
1543 (m->vsync_start - m->vdisplay) / 2);
1544 hdmi_set_reg(core->v2_blank, 2, m->vtotal / 2);
1545 hdmi_set_reg(core->v1_blank, 2, (m->vtotal - m->vdisplay) / 2);
1546 hdmi_set_reg(core->v_blank_f0, 2, m->vtotal - m->vdisplay / 2);
1547 hdmi_set_reg(core->v_blank_f1, 2, m->vtotal);
1548 hdmi_set_reg(core->v_sync_line_aft_2, 2, (m->vtotal / 2) + 7);
1549 hdmi_set_reg(core->v_sync_line_aft_1, 2, (m->vtotal / 2) + 2);
1550 hdmi_set_reg(core->v_sync_line_aft_pxl_2, 2,
1551 (m->htotal / 2) + (m->hsync_start - m->hdisplay));
1552 hdmi_set_reg(core->v_sync_line_aft_pxl_1, 2,
1553 (m->htotal / 2) + (m->hsync_start - m->hdisplay));
1554 hdmi_set_reg(tg->vact_st, 2, (m->vtotal - m->vdisplay) / 2);
1555 hdmi_set_reg(tg->vact_sz, 2, m->vdisplay / 2);
1556 hdmi_set_reg(tg->vact_st2, 2, m->vtotal - m->vdisplay / 2);
1557 hdmi_set_reg(tg->vsync2, 2, (m->vtotal / 2) + 1);
1558 hdmi_set_reg(tg->vsync_bot_hdmi, 2, (m->vtotal / 2) + 1);
1559 hdmi_set_reg(tg->field_bot_hdmi, 2, (m->vtotal / 2) + 1);
1560 hdmi_set_reg(tg->vact_st3, 2, 0x0);
1561 hdmi_set_reg(tg->vact_st4, 2, 0x0);
1562 } else {
1563 /* Progressive Mode */
1564 hdmi_set_reg(core->v_sync_line_bef_2, 2,
1565 m->vsync_end - m->vdisplay);
1566 hdmi_set_reg(core->v_sync_line_bef_1, 2,
1567 m->vsync_start - m->vdisplay);
1568 hdmi_set_reg(core->v2_blank, 2, m->vtotal);
1569 hdmi_set_reg(core->v1_blank, 2, m->vtotal - m->vdisplay);
1570 hdmi_set_reg(core->v_blank_f0, 2, 0xffff);
1571 hdmi_set_reg(core->v_blank_f1, 2, 0xffff);
1572 hdmi_set_reg(core->v_sync_line_aft_2, 2, 0xffff);
1573 hdmi_set_reg(core->v_sync_line_aft_1, 2, 0xffff);
1574 hdmi_set_reg(core->v_sync_line_aft_pxl_2, 2, 0xffff);
1575 hdmi_set_reg(core->v_sync_line_aft_pxl_1, 2, 0xffff);
1576 hdmi_set_reg(tg->vact_st, 2, m->vtotal - m->vdisplay);
1577 hdmi_set_reg(tg->vact_sz, 2, m->vdisplay);
1578 hdmi_set_reg(tg->vact_st2, 2, 0x248); /* Reset value */
1579 hdmi_set_reg(tg->vact_st3, 2, 0x47b); /* Reset value */
1580 hdmi_set_reg(tg->vact_st4, 2, 0x6ae); /* Reset value */
1581 hdmi_set_reg(tg->vsync2, 2, 0x233); /* Reset value */
1582 hdmi_set_reg(tg->vsync_bot_hdmi, 2, 0x233); /* Reset value */
1583 hdmi_set_reg(tg->field_bot_hdmi, 2, 0x233); /* Reset value */
1584 }
1585
1586 /* Following values & calculations are same irrespective of mode type */
1587 hdmi_set_reg(core->h_sync_start, 2, m->hsync_start - m->hdisplay - 2);
1588 hdmi_set_reg(core->h_sync_end, 2, m->hsync_end - m->hdisplay - 2);
1589 hdmi_set_reg(core->vact_space_1, 2, 0xffff);
1590 hdmi_set_reg(core->vact_space_2, 2, 0xffff);
1591 hdmi_set_reg(core->vact_space_3, 2, 0xffff);
1592 hdmi_set_reg(core->vact_space_4, 2, 0xffff);
1593 hdmi_set_reg(core->vact_space_5, 2, 0xffff);
1594 hdmi_set_reg(core->vact_space_6, 2, 0xffff);
1595 hdmi_set_reg(core->v_blank_f2, 2, 0xffff);
1596 hdmi_set_reg(core->v_blank_f3, 2, 0xffff);
1597 hdmi_set_reg(core->v_blank_f4, 2, 0xffff);
1598 hdmi_set_reg(core->v_blank_f5, 2, 0xffff);
1599 hdmi_set_reg(core->v_sync_line_aft_3, 2, 0xffff);
1600 hdmi_set_reg(core->v_sync_line_aft_4, 2, 0xffff);
1601 hdmi_set_reg(core->v_sync_line_aft_5, 2, 0xffff);
1602 hdmi_set_reg(core->v_sync_line_aft_6, 2, 0xffff);
1603 hdmi_set_reg(core->v_sync_line_aft_pxl_3, 2, 0xffff);
1604 hdmi_set_reg(core->v_sync_line_aft_pxl_4, 2, 0xffff);
1605 hdmi_set_reg(core->v_sync_line_aft_pxl_5, 2, 0xffff);
1606 hdmi_set_reg(core->v_sync_line_aft_pxl_6, 2, 0xffff);
1607
1608 /* Timing generator registers */
1609 hdmi_set_reg(tg->cmd, 1, 0x0);
1610 hdmi_set_reg(tg->h_fsz, 2, m->htotal);
1611 hdmi_set_reg(tg->hact_st, 2, m->htotal - m->hdisplay);
1612 hdmi_set_reg(tg->hact_sz, 2, m->hdisplay);
1613 hdmi_set_reg(tg->v_fsz, 2, m->vtotal);
1614 hdmi_set_reg(tg->vsync, 2, 0x1);
1615 hdmi_set_reg(tg->field_chg, 2, 0x233); /* Reset value */
1616 hdmi_set_reg(tg->vsync_top_hdmi, 2, 0x1); /* Reset value */
1617 hdmi_set_reg(tg->field_top_hdmi, 2, 0x1); /* Reset value */
1618 hdmi_set_reg(tg->tg_3d, 1, 0x0);
1619 }
1620
1621 static void hdmi_mode_set(void *ctx, struct drm_display_mode *mode)
1622 {
1623 struct hdmi_context *hdata = ctx;
1624 struct drm_display_mode *m = mode;
1625
1626 DRM_DEBUG_KMS("xres=%d, yres=%d, refresh=%d, intl=%s\n",
1627 m->hdisplay, m->vdisplay,
1628 m->vrefresh, (m->flags & DRM_MODE_FLAG_INTERLACE) ?
1629 "INTERLACED" : "PROGERESSIVE");
1630
1631 if (hdata->type == HDMI_TYPE13)
1632 hdmi_v13_mode_set(hdata, mode);
1633 else
1634 hdmi_v14_mode_set(hdata, mode);
1635 }
1636
1637 static void hdmi_get_max_resol(void *ctx, unsigned int *width,
1638 unsigned int *height)
1639 {
1640 *width = MAX_WIDTH;
1641 *height = MAX_HEIGHT;
1642 }
1643
1644 static void hdmi_commit(void *ctx)
1645 {
1646 struct hdmi_context *hdata = ctx;
1647
1648 mutex_lock(&hdata->hdmi_mutex);
1649 if (!hdata->powered) {
1650 mutex_unlock(&hdata->hdmi_mutex);
1651 return;
1652 }
1653 mutex_unlock(&hdata->hdmi_mutex);
1654
1655 hdmi_conf_apply(hdata);
1656 }
1657
1658 static void hdmi_poweron(struct hdmi_context *hdata)
1659 {
1660 struct hdmi_resources *res = &hdata->res;
1661
1662 mutex_lock(&hdata->hdmi_mutex);
1663 if (hdata->powered) {
1664 mutex_unlock(&hdata->hdmi_mutex);
1665 return;
1666 }
1667
1668 hdata->powered = true;
1669
1670 mutex_unlock(&hdata->hdmi_mutex);
1671
1672 if (regulator_bulk_enable(res->regul_count, res->regul_bulk))
1673 DRM_DEBUG_KMS("failed to enable regulator bulk\n");
1674
1675 clk_prepare_enable(res->hdmiphy);
1676 clk_prepare_enable(res->hdmi);
1677 clk_prepare_enable(res->sclk_hdmi);
1678
1679 hdmiphy_poweron(hdata);
1680 }
1681
1682 static void hdmi_poweroff(struct hdmi_context *hdata)
1683 {
1684 struct hdmi_resources *res = &hdata->res;
1685
1686 mutex_lock(&hdata->hdmi_mutex);
1687 if (!hdata->powered)
1688 goto out;
1689 mutex_unlock(&hdata->hdmi_mutex);
1690
1691 /*
1692 * The TV power domain needs any condition of hdmiphy to turn off and
1693 * its reset state seems to meet the condition.
1694 */
1695 hdmiphy_conf_reset(hdata);
1696 hdmiphy_poweroff(hdata);
1697
1698 clk_disable_unprepare(res->sclk_hdmi);
1699 clk_disable_unprepare(res->hdmi);
1700 clk_disable_unprepare(res->hdmiphy);
1701 regulator_bulk_disable(res->regul_count, res->regul_bulk);
1702
1703 mutex_lock(&hdata->hdmi_mutex);
1704
1705 hdata->powered = false;
1706
1707 out:
1708 mutex_unlock(&hdata->hdmi_mutex);
1709 }
1710
1711 static void hdmi_dpms(void *ctx, int mode)
1712 {
1713 struct hdmi_context *hdata = ctx;
1714
1715 DRM_DEBUG_KMS("mode %d\n", mode);
1716
1717 switch (mode) {
1718 case DRM_MODE_DPMS_ON:
1719 if (pm_runtime_suspended(hdata->dev))
1720 pm_runtime_get_sync(hdata->dev);
1721 break;
1722 case DRM_MODE_DPMS_STANDBY:
1723 case DRM_MODE_DPMS_SUSPEND:
1724 case DRM_MODE_DPMS_OFF:
1725 if (!pm_runtime_suspended(hdata->dev))
1726 pm_runtime_put_sync(hdata->dev);
1727 break;
1728 default:
1729 DRM_DEBUG_KMS("unknown dpms mode: %d\n", mode);
1730 break;
1731 }
1732 }
1733
1734 static struct exynos_hdmi_ops hdmi_ops = {
1735 /* display */
1736 .is_connected = hdmi_is_connected,
1737 .get_edid = hdmi_get_edid,
1738 .check_mode = hdmi_check_mode,
1739
1740 /* manager */
1741 .mode_set = hdmi_mode_set,
1742 .get_max_resol = hdmi_get_max_resol,
1743 .commit = hdmi_commit,
1744 .dpms = hdmi_dpms,
1745 };
1746
1747 static irqreturn_t hdmi_irq_thread(int irq, void *arg)
1748 {
1749 struct exynos_drm_hdmi_context *ctx = arg;
1750 struct hdmi_context *hdata = ctx->ctx;
1751
1752 mutex_lock(&hdata->hdmi_mutex);
1753 hdata->hpd = gpio_get_value(hdata->hpd_gpio);
1754 mutex_unlock(&hdata->hdmi_mutex);
1755
1756 if (ctx->drm_dev)
1757 drm_helper_hpd_irq_event(ctx->drm_dev);
1758
1759 return IRQ_HANDLED;
1760 }
1761
1762 static int hdmi_resources_init(struct hdmi_context *hdata)
1763 {
1764 struct device *dev = hdata->dev;
1765 struct hdmi_resources *res = &hdata->res;
1766 static char *supply[] = {
1767 "hdmi-en",
1768 "vdd",
1769 "vdd_osc",
1770 "vdd_pll",
1771 };
1772 int i, ret;
1773
1774 DRM_DEBUG_KMS("HDMI resource init\n");
1775
1776 memset(res, 0, sizeof(*res));
1777
1778 /* get clocks, power */
1779 res->hdmi = devm_clk_get(dev, "hdmi");
1780 if (IS_ERR(res->hdmi)) {
1781 DRM_ERROR("failed to get clock 'hdmi'\n");
1782 goto fail;
1783 }
1784 res->sclk_hdmi = devm_clk_get(dev, "sclk_hdmi");
1785 if (IS_ERR(res->sclk_hdmi)) {
1786 DRM_ERROR("failed to get clock 'sclk_hdmi'\n");
1787 goto fail;
1788 }
1789 res->sclk_pixel = devm_clk_get(dev, "sclk_pixel");
1790 if (IS_ERR(res->sclk_pixel)) {
1791 DRM_ERROR("failed to get clock 'sclk_pixel'\n");
1792 goto fail;
1793 }
1794 res->sclk_hdmiphy = devm_clk_get(dev, "sclk_hdmiphy");
1795 if (IS_ERR(res->sclk_hdmiphy)) {
1796 DRM_ERROR("failed to get clock 'sclk_hdmiphy'\n");
1797 goto fail;
1798 }
1799 res->hdmiphy = devm_clk_get(dev, "hdmiphy");
1800 if (IS_ERR(res->hdmiphy)) {
1801 DRM_ERROR("failed to get clock 'hdmiphy'\n");
1802 goto fail;
1803 }
1804 res->mout_hdmi = devm_clk_get(dev, "mout_hdmi");
1805 if (IS_ERR(res->mout_hdmi)) {
1806 DRM_ERROR("failed to get clock 'mout_hdmi'\n");
1807 goto fail;
1808 }
1809
1810 clk_set_parent(res->mout_hdmi, res->sclk_pixel);
1811
1812 res->regul_bulk = devm_kzalloc(dev, ARRAY_SIZE(supply) *
1813 sizeof(res->regul_bulk[0]), GFP_KERNEL);
1814 if (!res->regul_bulk)
1815 goto fail;
1816 for (i = 0; i < ARRAY_SIZE(supply); ++i) {
1817 res->regul_bulk[i].supply = supply[i];
1818 res->regul_bulk[i].consumer = NULL;
1819 }
1820 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(supply), res->regul_bulk);
1821 if (ret) {
1822 DRM_ERROR("failed to get regulators\n");
1823 goto fail;
1824 }
1825 res->regul_count = ARRAY_SIZE(supply);
1826
1827 return 0;
1828 fail:
1829 DRM_ERROR("HDMI resource init - failed\n");
1830 return -ENODEV;
1831 }
1832
1833 static struct i2c_client *hdmi_ddc, *hdmi_hdmiphy;
1834
1835 void hdmi_attach_ddc_client(struct i2c_client *ddc)
1836 {
1837 if (ddc)
1838 hdmi_ddc = ddc;
1839 }
1840
1841 void hdmi_attach_hdmiphy_client(struct i2c_client *hdmiphy)
1842 {
1843 if (hdmiphy)
1844 hdmi_hdmiphy = hdmiphy;
1845 }
1846
1847 static struct s5p_hdmi_platform_data *drm_hdmi_dt_parse_pdata
1848 (struct device *dev)
1849 {
1850 struct device_node *np = dev->of_node;
1851 struct s5p_hdmi_platform_data *pd;
1852 u32 value;
1853
1854 pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL);
1855 if (!pd)
1856 goto err_data;
1857
1858 if (!of_find_property(np, "hpd-gpio", &value)) {
1859 DRM_ERROR("no hpd gpio property found\n");
1860 goto err_data;
1861 }
1862
1863 pd->hpd_gpio = of_get_named_gpio(np, "hpd-gpio", 0);
1864
1865 return pd;
1866
1867 err_data:
1868 return NULL;
1869 }
1870
1871 static struct of_device_id hdmi_match_types[] = {
1872 {
1873 .compatible = "samsung,exynos5-hdmi",
1874 .data = (void *)HDMI_TYPE14,
1875 }, {
1876 .compatible = "samsung,exynos4212-hdmi",
1877 .data = (void *)HDMI_TYPE14,
1878 }, {
1879 /* end node */
1880 }
1881 };
1882
1883 static int hdmi_probe(struct platform_device *pdev)
1884 {
1885 struct device *dev = &pdev->dev;
1886 struct exynos_drm_hdmi_context *drm_hdmi_ctx;
1887 struct hdmi_context *hdata;
1888 struct s5p_hdmi_platform_data *pdata;
1889 struct resource *res;
1890 const struct of_device_id *match;
1891 int ret;
1892
1893 if (!dev->of_node)
1894 return -ENODEV;
1895
1896 pdata = drm_hdmi_dt_parse_pdata(dev);
1897 if (!pdata)
1898 return -EINVAL;
1899
1900 drm_hdmi_ctx = devm_kzalloc(dev, sizeof(*drm_hdmi_ctx), GFP_KERNEL);
1901 if (!drm_hdmi_ctx)
1902 return -ENOMEM;
1903
1904 hdata = devm_kzalloc(dev, sizeof(struct hdmi_context), GFP_KERNEL);
1905 if (!hdata)
1906 return -ENOMEM;
1907
1908 mutex_init(&hdata->hdmi_mutex);
1909
1910 drm_hdmi_ctx->ctx = (void *)hdata;
1911 hdata->parent_ctx = (void *)drm_hdmi_ctx;
1912
1913 platform_set_drvdata(pdev, drm_hdmi_ctx);
1914
1915 match = of_match_node(hdmi_match_types, dev->of_node);
1916 if (!match)
1917 return -ENODEV;
1918 hdata->type = (enum hdmi_type)match->data;
1919
1920 hdata->hpd_gpio = pdata->hpd_gpio;
1921 hdata->dev = dev;
1922
1923 ret = hdmi_resources_init(hdata);
1924 if (ret) {
1925 DRM_ERROR("hdmi_resources_init failed\n");
1926 return -EINVAL;
1927 }
1928
1929 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1930 hdata->regs = devm_ioremap_resource(dev, res);
1931 if (IS_ERR(hdata->regs))
1932 return PTR_ERR(hdata->regs);
1933
1934 ret = devm_gpio_request(dev, hdata->hpd_gpio, "HPD");
1935 if (ret) {
1936 DRM_ERROR("failed to request HPD gpio\n");
1937 return ret;
1938 }
1939
1940 /* DDC i2c driver */
1941 if (i2c_add_driver(&ddc_driver)) {
1942 DRM_ERROR("failed to register ddc i2c driver\n");
1943 return -ENOENT;
1944 }
1945
1946 hdata->ddc_port = hdmi_ddc;
1947
1948 /* hdmiphy i2c driver */
1949 if (i2c_add_driver(&hdmiphy_driver)) {
1950 DRM_ERROR("failed to register hdmiphy i2c driver\n");
1951 ret = -ENOENT;
1952 goto err_ddc;
1953 }
1954
1955 hdata->hdmiphy_port = hdmi_hdmiphy;
1956
1957 hdata->irq = gpio_to_irq(hdata->hpd_gpio);
1958 if (hdata->irq < 0) {
1959 DRM_ERROR("failed to get GPIO irq\n");
1960 ret = hdata->irq;
1961 goto err_hdmiphy;
1962 }
1963
1964 hdata->hpd = gpio_get_value(hdata->hpd_gpio);
1965
1966 ret = devm_request_threaded_irq(dev, hdata->irq, NULL,
1967 hdmi_irq_thread, IRQF_TRIGGER_RISING |
1968 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1969 "hdmi", drm_hdmi_ctx);
1970 if (ret) {
1971 DRM_ERROR("failed to register hdmi interrupt\n");
1972 goto err_hdmiphy;
1973 }
1974
1975 /* Attach HDMI Driver to common hdmi. */
1976 exynos_hdmi_drv_attach(drm_hdmi_ctx);
1977
1978 /* register specific callbacks to common hdmi. */
1979 exynos_hdmi_ops_register(&hdmi_ops);
1980
1981 pm_runtime_enable(dev);
1982
1983 return 0;
1984
1985 err_hdmiphy:
1986 i2c_del_driver(&hdmiphy_driver);
1987 err_ddc:
1988 i2c_del_driver(&ddc_driver);
1989 return ret;
1990 }
1991
1992 static int hdmi_remove(struct platform_device *pdev)
1993 {
1994 struct device *dev = &pdev->dev;
1995
1996 pm_runtime_disable(dev);
1997
1998 /* hdmiphy i2c driver */
1999 i2c_del_driver(&hdmiphy_driver);
2000 /* DDC i2c driver */
2001 i2c_del_driver(&ddc_driver);
2002
2003 return 0;
2004 }
2005
2006 #ifdef CONFIG_PM_SLEEP
2007 static int hdmi_suspend(struct device *dev)
2008 {
2009 struct exynos_drm_hdmi_context *ctx = get_hdmi_context(dev);
2010 struct hdmi_context *hdata = ctx->ctx;
2011
2012 disable_irq(hdata->irq);
2013
2014 hdata->hpd = false;
2015 if (ctx->drm_dev)
2016 drm_helper_hpd_irq_event(ctx->drm_dev);
2017
2018 if (pm_runtime_suspended(dev)) {
2019 DRM_DEBUG_KMS("Already suspended\n");
2020 return 0;
2021 }
2022
2023 hdmi_poweroff(hdata);
2024
2025 return 0;
2026 }
2027
2028 static int hdmi_resume(struct device *dev)
2029 {
2030 struct exynos_drm_hdmi_context *ctx = get_hdmi_context(dev);
2031 struct hdmi_context *hdata = ctx->ctx;
2032
2033 hdata->hpd = gpio_get_value(hdata->hpd_gpio);
2034
2035 enable_irq(hdata->irq);
2036
2037 if (!pm_runtime_suspended(dev)) {
2038 DRM_DEBUG_KMS("Already resumed\n");
2039 return 0;
2040 }
2041
2042 hdmi_poweron(hdata);
2043
2044 return 0;
2045 }
2046 #endif
2047
2048 #ifdef CONFIG_PM_RUNTIME
2049 static int hdmi_runtime_suspend(struct device *dev)
2050 {
2051 struct exynos_drm_hdmi_context *ctx = get_hdmi_context(dev);
2052 struct hdmi_context *hdata = ctx->ctx;
2053
2054 hdmi_poweroff(hdata);
2055
2056 return 0;
2057 }
2058
2059 static int hdmi_runtime_resume(struct device *dev)
2060 {
2061 struct exynos_drm_hdmi_context *ctx = get_hdmi_context(dev);
2062 struct hdmi_context *hdata = ctx->ctx;
2063
2064 hdmi_poweron(hdata);
2065
2066 return 0;
2067 }
2068 #endif
2069
2070 static const struct dev_pm_ops hdmi_pm_ops = {
2071 SET_SYSTEM_SLEEP_PM_OPS(hdmi_suspend, hdmi_resume)
2072 SET_RUNTIME_PM_OPS(hdmi_runtime_suspend, hdmi_runtime_resume, NULL)
2073 };
2074
2075 struct platform_driver hdmi_driver = {
2076 .probe = hdmi_probe,
2077 .remove = hdmi_remove,
2078 .driver = {
2079 .name = "exynos-hdmi",
2080 .owner = THIS_MODULE,
2081 .pm = &hdmi_pm_ops,
2082 .of_match_table = hdmi_match_types,
2083 },
2084 };
Linux with added FPC-III support