1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (c) 2015 Google, Inc
4 * Copyright 2014 Rockchip Inc.
16 #include <asm/hardware.h>
18 #include <asm/arch/clock.h>
19 #include <asm/arch/edp_rk3288.h>
20 #include <asm/arch/vop_rk3288.h>
21 #include <dm/device-internal.h>
22 #include <dm/uclass-internal.h>
23 #include <power/regulator.h>
26 DECLARE_GLOBAL_DATA_PTR
;
35 static void rkvop_enable(struct rk3288_vop
*regs
, ulong fbbase
,
36 int fb_bits_per_pixel
,
37 const struct display_timing
*edid
)
41 u32 hactive
= edid
->hactive
.typ
;
42 u32 vactive
= edid
->vactive
.typ
;
44 writel(V_ACT_WIDTH(hactive
- 1) | V_ACT_HEIGHT(vactive
- 1),
45 ®s
->win0_act_info
);
47 writel(V_DSP_XST(edid
->hsync_len
.typ
+ edid
->hback_porch
.typ
) |
48 V_DSP_YST(edid
->vsync_len
.typ
+ edid
->vback_porch
.typ
),
51 writel(V_DSP_WIDTH(hactive
- 1) |
52 V_DSP_HEIGHT(vactive
- 1),
53 ®s
->win0_dsp_info
);
55 clrsetbits_le32(®s
->win0_color_key
, M_WIN0_KEY_EN
| M_WIN0_KEY_COLOR
,
56 V_WIN0_KEY_EN(0) | V_WIN0_KEY_COLOR(0));
58 switch (fb_bits_per_pixel
) {
61 writel(V_RGB565_VIRWIDTH(hactive
), ®s
->win0_vir
);
65 writel(V_RGB888_VIRWIDTH(hactive
), ®s
->win0_vir
);
70 writel(V_ARGB888_VIRWIDTH(hactive
), ®s
->win0_vir
);
75 lb_mode
= LB_RGB_3840X2
;
76 else if (hactive
> 1920)
77 lb_mode
= LB_RGB_2560X4
;
78 else if (hactive
> 1280)
79 lb_mode
= LB_RGB_1920X5
;
81 lb_mode
= LB_RGB_1280X8
;
83 clrsetbits_le32(®s
->win0_ctrl0
,
84 M_WIN0_LB_MODE
| M_WIN0_DATA_FMT
| M_WIN0_EN
,
85 V_WIN0_LB_MODE(lb_mode
) | V_WIN0_DATA_FMT(rgb_mode
) |
88 writel(fbbase
, ®s
->win0_yrgb_mst
);
89 writel(0x01, ®s
->reg_cfg_done
); /* enable reg config */
92 static void rkvop_set_pin_polarity(struct udevice
*dev
,
93 enum vop_modes mode
, u32 polarity
)
95 struct rkvop_driverdata
*ops
=
96 (struct rkvop_driverdata
*)dev_get_driver_data(dev
);
98 if (ops
->set_pin_polarity
)
99 ops
->set_pin_polarity(dev
, mode
, polarity
);
102 static void rkvop_enable_output(struct udevice
*dev
, enum vop_modes mode
)
104 struct rk_vop_priv
*priv
= dev_get_priv(dev
);
105 struct rk3288_vop
*regs
= priv
->regs
;
107 /* remove from standby */
108 clrbits_le32(®s
->sys_ctrl
, V_STANDBY_EN(1));
112 clrsetbits_le32(®s
->sys_ctrl
, M_ALL_OUT_EN
,
117 clrsetbits_le32(®s
->sys_ctrl
, M_ALL_OUT_EN
,
122 clrsetbits_le32(®s
->sys_ctrl
, M_ALL_OUT_EN
,
127 clrsetbits_le32(®s
->sys_ctrl
, M_ALL_OUT_EN
,
132 debug("%s: unsupported output mode %x\n", __func__
, mode
);
136 static void rkvop_mode_set(struct udevice
*dev
,
137 const struct display_timing
*edid
,
140 struct rk_vop_priv
*priv
= dev_get_priv(dev
);
141 struct rk3288_vop
*regs
= priv
->regs
;
142 struct rkvop_driverdata
*data
=
143 (struct rkvop_driverdata
*)dev_get_driver_data(dev
);
145 u32 hactive
= edid
->hactive
.typ
;
146 u32 vactive
= edid
->vactive
.typ
;
147 u32 hsync_len
= edid
->hsync_len
.typ
;
148 u32 hback_porch
= edid
->hback_porch
.typ
;
149 u32 vsync_len
= edid
->vsync_len
.typ
;
150 u32 vback_porch
= edid
->vback_porch
.typ
;
151 u32 hfront_porch
= edid
->hfront_porch
.typ
;
152 u32 vfront_porch
= edid
->vfront_porch
.typ
;
156 pin_polarity
= BIT(DCLK_INVERT
);
157 if (edid
->flags
& DISPLAY_FLAGS_HSYNC_HIGH
)
158 pin_polarity
|= BIT(HSYNC_POSITIVE
);
159 if (edid
->flags
& DISPLAY_FLAGS_VSYNC_HIGH
)
160 pin_polarity
|= BIT(VSYNC_POSITIVE
);
162 rkvop_set_pin_polarity(dev
, mode
, pin_polarity
);
163 rkvop_enable_output(dev
, mode
);
165 mode_flags
= 0; /* RGB888 */
166 if ((data
->features
& VOP_FEATURE_OUTPUT_10BIT
) &&
167 (mode
== VOP_MODE_HDMI
|| mode
== VOP_MODE_EDP
))
168 mode_flags
= 15; /* RGBaaa */
170 clrsetbits_le32(®s
->dsp_ctrl0
, M_DSP_OUT_MODE
,
171 V_DSP_OUT_MODE(mode_flags
));
173 writel(V_HSYNC(hsync_len
) |
174 V_HORPRD(hsync_len
+ hback_porch
+ hactive
+ hfront_porch
),
175 ®s
->dsp_htotal_hs_end
);
177 writel(V_HEAP(hsync_len
+ hback_porch
+ hactive
) |
178 V_HASP(hsync_len
+ hback_porch
),
179 ®s
->dsp_hact_st_end
);
181 writel(V_VSYNC(vsync_len
) |
182 V_VERPRD(vsync_len
+ vback_porch
+ vactive
+ vfront_porch
),
183 ®s
->dsp_vtotal_vs_end
);
185 writel(V_VAEP(vsync_len
+ vback_porch
+ vactive
)|
186 V_VASP(vsync_len
+ vback_porch
),
187 ®s
->dsp_vact_st_end
);
189 writel(V_HEAP(hsync_len
+ hback_porch
+ hactive
) |
190 V_HASP(hsync_len
+ hback_porch
),
191 ®s
->post_dsp_hact_info
);
193 writel(V_VAEP(vsync_len
+ vback_porch
+ vactive
)|
194 V_VASP(vsync_len
+ vback_porch
),
195 ®s
->post_dsp_vact_info
);
197 writel(0x01, ®s
->reg_cfg_done
); /* enable reg config */
201 * rk_display_init() - Try to enable the given display device
203 * This function performs many steps:
204 * - Finds the display device being referenced by @ep_node
205 * - Puts the VOP's ID into its uclass platform data
206 * - Probes the device to set it up
207 * - Reads the EDID timing information
208 * - Sets up the VOP clocks, etc. for the selected pixel clock and display mode
209 * - Enables the display (the display device handles this and will do different
210 * things depending on the display type)
211 * - Tells the uclass about the display resolution so that the console will
214 * @dev: VOP device that we want to connect to the display
215 * @fbbase: Frame buffer address
216 * @ep_node: Device tree node to process - this is the offset of an endpoint
217 * node within the VOP's 'port' list.
218 * @return 0 if OK, -ve if something went wrong
220 static int rk_display_init(struct udevice
*dev
, ulong fbbase
, ofnode ep_node
)
222 struct video_priv
*uc_priv
= dev_get_uclass_priv(dev
);
223 struct rk_vop_priv
*priv
= dev_get_priv(dev
);
224 int vop_id
, remote_vop_id
;
225 struct rk3288_vop
*regs
= priv
->regs
;
226 struct display_timing timing
;
227 struct udevice
*disp
;
230 struct display_plat
*disp_uc_plat
;
232 enum video_log2_bpp l2bpp
;
235 debug("%s(%s, %lu, %s)\n", __func__
,
236 dev_read_name(dev
), fbbase
, ofnode_get_name(ep_node
));
238 vop_id
= ofnode_read_s32_default(ep_node
, "reg", -1);
239 debug("vop_id=%d\n", vop_id
);
240 ret
= ofnode_read_u32(ep_node
, "remote-endpoint", &remote_phandle
);
244 remote
= ofnode_get_by_phandle(remote_phandle
);
245 if (!ofnode_valid(remote
))
247 remote_vop_id
= ofnode_read_u32_default(remote
, "reg", -1);
248 debug("remote vop_id=%d\n", remote_vop_id
);
251 * The remote-endpoint references into a subnode of the encoder
252 * (i.e. HDMI, MIPI, etc.) with the DTS looking something like
253 * the following (assume 'hdmi_in_vopl' to be referenced):
255 * hdmi: hdmi@ff940000 {
258 * hdmi_in_vopb: endpoint@0 { ... };
259 * hdmi_in_vopl: endpoint@1 { ... };
264 * The original code had 3 steps of "walking the parent", but
265 * a much better (as in: less likely to break if the DTS
266 * changes) way of doing this is to "find the enclosing device
267 * of UCLASS_DISPLAY".
269 while (ofnode_valid(remote
)) {
270 remote
= ofnode_get_parent(remote
);
271 if (!ofnode_valid(remote
)) {
272 debug("%s(%s): no UCLASS_DISPLAY for remote-endpoint\n",
273 __func__
, dev_read_name(dev
));
277 uclass_find_device_by_ofnode(UCLASS_DISPLAY
, remote
, &disp
);
282 disp_uc_plat
= dev_get_uclass_platdata(disp
);
283 debug("Found device '%s', disp_uc_priv=%p\n", disp
->name
, disp_uc_plat
);
284 if (display_in_use(disp
)) {
285 debug(" - device in use\n");
289 disp_uc_plat
->source_id
= remote_vop_id
;
290 disp_uc_plat
->src_dev
= dev
;
292 ret
= device_probe(disp
);
294 debug("%s: device '%s' display won't probe (ret=%d)\n",
295 __func__
, dev
->name
, ret
);
299 ret
= display_read_timing(disp
, &timing
);
301 debug("%s: Failed to read timings\n", __func__
);
305 ret
= clk_get_by_index(dev
, 1, &clk
);
307 ret
= clk_set_rate(&clk
, timing
.pixelclock
.typ
);
308 if (IS_ERR_VALUE(ret
)) {
309 debug("%s: Failed to set pixel clock: ret=%d\n", __func__
, ret
);
313 /* Set bitwidth for vop display according to vop mode */
327 rkvop_mode_set(dev
, &timing
, vop_id
);
328 rkvop_enable(regs
, fbbase
, 1 << l2bpp
, &timing
);
330 ret
= display_enable(disp
, 1 << l2bpp
, &timing
);
334 uc_priv
->xsize
= timing
.hactive
.typ
;
335 uc_priv
->ysize
= timing
.vactive
.typ
;
336 uc_priv
->bpix
= l2bpp
;
337 debug("fb=%lx, size=%d %d\n", fbbase
, uc_priv
->xsize
, uc_priv
->ysize
);
342 void rk_vop_probe_regulators(struct udevice
*dev
,
343 const char * const *names
, int cnt
)
349 for (i
= 0; i
< cnt
; ++i
) {
351 debug("%s: probing regulator '%s'\n", dev
->name
, name
);
353 ret
= regulator_autoset_by_name(name
, ®
);
355 ret
= regulator_set_enable(reg
, true);
359 int rk_vop_probe(struct udevice
*dev
)
361 struct video_uc_platdata
*plat
= dev_get_uclass_platdata(dev
);
362 struct rk_vop_priv
*priv
= dev_get_priv(dev
);
366 /* Before relocation we don't need to do anything */
367 if (!(gd
->flags
& GD_FLG_RELOC
))
370 priv
->regs
= (struct rk3288_vop
*)dev_read_addr(dev
);
373 * Try all the ports until we find one that works. In practice this
374 * tries EDP first if available, then HDMI.
376 * Note that rockchip_vop_set_clk() always uses NPLL as the source
377 * clock so it is currently not possible to use more than one display
378 * device simultaneously.
380 port
= dev_read_subnode(dev
, "port");
381 if (!ofnode_valid(port
)) {
382 debug("%s(%s): 'port' subnode not found\n",
383 __func__
, dev_read_name(dev
));
387 for (node
= ofnode_first_subnode(port
);
389 node
= dev_read_next_subnode(node
)) {
390 ret
= rk_display_init(dev
, plat
->base
, node
);
392 debug("Device failed: ret=%d\n", ret
);
396 video_set_flush_dcache(dev
, 1);
401 int rk_vop_bind(struct udevice
*dev
)
403 struct video_uc_platdata
*plat
= dev_get_uclass_platdata(dev
);
405 plat
->size
= 4 * (CONFIG_VIDEO_ROCKCHIP_MAX_XRES
*
406 CONFIG_VIDEO_ROCKCHIP_MAX_YRES
);