1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
4 *
5 * Author: Wyon Bi <bivvy.bi@rock-chips.com>
6 */
7
8 #include <linux/module.h>
9 #include <linux/clk.h>
10 #include <linux/platform_device.h>
11 #include <linux/of.h>
12 #include <linux/regmap.h>
13 #include <linux/mfd/rk628.h>
14 #include <linux/phy/phy.h>
15 #include <linux/reset.h>
16
17 #include <drm/drm_of.h>
18 #include <drm/drm_atomic.h>
19 #include <drm/drm_probe_helper.h>
20 #include <drm/drm_atomic_helper.h>
21 #include <drm/drm_panel.h>
22
23 #include <video/of_display_timing.h>
24 #include <video/videomode.h>
25
26 enum interface_type {
27 RGB_TX,
28 YUV_RX,
29 YUV_TX,
30 BT1120_RX,
31 BT1120_TX,
32 };
33
34 struct rk628_rgb {
35 struct drm_bridge base;
36 struct drm_connector connector;
37 struct drm_display_mode mode;
38 struct drm_panel *panel;
39 struct drm_bridge *bridge;
40 struct device *dev;
41 struct regmap *grf;
42 struct rk628 *parent;
43 struct clk *decclk;
44 struct reset_control *rstc;
45 bool dual_edge;
46 enum interface_type interface_type;
47 };
48
bridge_to_rgb(struct drm_bridge * b)49 static inline struct rk628_rgb *bridge_to_rgb(struct drm_bridge *b)
50 {
51 return container_of(b, struct rk628_rgb, base);
52 }
53
connector_to_rgb(struct drm_connector * c)54 static inline struct rk628_rgb *connector_to_rgb(struct drm_connector *c)
55 {
56 return container_of(c, struct rk628_rgb, connector);
57 }
58
rk628_rgb_get_interface_type(struct rk628_rgb * rgb)59 static enum interface_type rk628_rgb_get_interface_type(struct rk628_rgb *rgb)
60 {
61 const struct device_node *of_node = rgb->dev->of_node;
62
63 if (of_device_is_compatible(of_node, "rockchip,rk628-yuv-rx"))
64 return YUV_RX;
65 else if (of_device_is_compatible(of_node, "rockchip,rk628-yuv-tx"))
66 return YUV_TX;
67 else if (of_device_is_compatible(of_node, "rockchip,rk628-bt1120-rx"))
68 return BT1120_RX;
69 else if (of_device_is_compatible(of_node, "rockchip,rk628-bt1120-tx"))
70 return BT1120_TX;
71 else
72 return RGB_TX;
73 }
74
75 static struct drm_encoder *
rk628_rgb_connector_best_encoder(struct drm_connector * connector)76 rk628_rgb_connector_best_encoder(struct drm_connector *connector)
77 {
78 struct rk628_rgb *rgb = connector_to_rgb(connector);
79
80 return rgb->base.encoder;
81 }
82
rk628_rgb_connector_get_modes(struct drm_connector * connector)83 static int rk628_rgb_connector_get_modes(struct drm_connector *connector)
84 {
85 struct rk628_rgb *rgb = connector_to_rgb(connector);
86
87 return drm_panel_get_modes(rgb->panel, connector);
88 }
89
90 static const struct drm_connector_helper_funcs
91 rk628_rgb_connector_helper_funcs = {
92 .get_modes = rk628_rgb_connector_get_modes,
93 .best_encoder = rk628_rgb_connector_best_encoder,
94 };
95
rk628_rgb_connector_destroy(struct drm_connector * connector)96 static void rk628_rgb_connector_destroy(struct drm_connector *connector)
97 {
98 drm_connector_cleanup(connector);
99 }
100
101 static const struct drm_connector_funcs rk628_rgb_connector_funcs = {
102 .fill_modes = drm_helper_probe_single_connector_modes,
103 .destroy = rk628_rgb_connector_destroy,
104 .reset = drm_atomic_helper_connector_reset,
105 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
106 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
107 };
108
rk628_bt1120_rx_enable(struct rk628_rgb * rgb)109 static void rk628_bt1120_rx_enable(struct rk628_rgb *rgb)
110 {
111 const struct drm_display_mode *mode = &rgb->mode;
112
113 reset_control_assert(rgb->rstc);
114 udelay(10);
115 reset_control_deassert(rgb->rstc);
116 udelay(10);
117
118 clk_set_rate(rgb->decclk, mode->clock * 1000);
119 clk_prepare_enable(rgb->decclk);
120
121 if (rgb->dual_edge) {
122 regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON0,
123 DEC_DUALEDGE_EN, DEC_DUALEDGE_EN);
124
125 regmap_write(rgb->grf,
126 GRF_BT1120_DCLK_DELAY_CON0, 0x10000000);
127 regmap_write(rgb->grf, GRF_BT1120_DCLK_DELAY_CON1, 0);
128 } else
129 regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON0,
130 DEC_DUALEDGE_EN, 0);
131
132 regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON1,
133 SW_SET_X_MASK, SW_SET_X(mode->hdisplay));
134 regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON2,
135 SW_SET_Y_MASK, SW_SET_Y(mode->vdisplay));
136
137 regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
138 SW_BT_DATA_OEN_MASK | SW_INPUT_MODE_MASK,
139 SW_BT_DATA_OEN | SW_INPUT_MODE(INPUT_MODE_BT1120));
140
141 regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_Y2R_EN(1));
142
143 regmap_update_bits(rgb->grf, GRF_RGB_DEC_CON0,
144 SW_CAP_EN_PSYNC | SW_CAP_EN_ASYNC | SW_PROGRESS_EN,
145 SW_CAP_EN_PSYNC | SW_CAP_EN_ASYNC | SW_PROGRESS_EN);
146 }
147
rk628_bt1120_tx_enable(struct rk628_rgb * rgb)148 static void rk628_bt1120_tx_enable(struct rk628_rgb *rgb)
149 {
150 u32 val = 0;
151
152 regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
153 SW_BT_DATA_OEN_MASK | SW_OUTPUT_MODE_MASK,
154 SW_OUTPUT_MODE(OUTPUT_MODE_BT1120));
155 regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_R2Y_EN(1));
156 regmap_update_bits(rgb->grf, GRF_POST_PROC_CON,
157 SW_DCLK_OUT_INV_EN, SW_DCLK_OUT_INV_EN);
158
159 if (rgb->dual_edge) {
160 val |= ENC_DUALEDGE_EN(1);
161 regmap_write(rgb->grf, GRF_BT1120_DCLK_DELAY_CON0, 0x10000000);
162 regmap_write(rgb->grf, GRF_BT1120_DCLK_DELAY_CON1, 0);
163 }
164
165 val |= BT1120_UV_SWAP(1);
166 regmap_write(rgb->grf, GRF_RGB_ENC_CON, val);
167
168 }
169
rk628_rgb_bridge_enable(struct drm_bridge * bridge)170 static void rk628_rgb_bridge_enable(struct drm_bridge *bridge)
171 {
172 struct rk628_rgb *rgb = bridge_to_rgb(bridge);
173
174 switch (rgb->interface_type) {
175 case YUV_RX:
176 regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_Y2R_EN(1));
177 regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
178 SW_BT_DATA_OEN_MASK | SW_INPUT_MODE_MASK,
179 SW_BT_DATA_OEN | SW_INPUT_MODE(INPUT_MODE_YUV));
180 break;
181 case YUV_TX:
182 regmap_write(rgb->grf, GRF_CSC_CTRL_CON, SW_R2Y_EN(1));
183 regmap_update_bits(rgb->grf, GRF_POST_PROC_CON,
184 SW_DCLK_OUT_INV_EN, SW_DCLK_OUT_INV_EN);
185
186 regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
187 SW_BT_DATA_OEN_MASK | SW_OUTPUT_MODE_MASK,
188 SW_OUTPUT_MODE(OUTPUT_MODE_YUV));
189 break;
190 case BT1120_RX:
191 rk628_bt1120_rx_enable(rgb);
192 break;
193 case BT1120_TX:
194 rk628_bt1120_tx_enable(rgb);
195 break;
196 case RGB_TX:
197 default:
198 regmap_update_bits(rgb->grf, GRF_SYSTEM_CON0,
199 SW_BT_DATA_OEN_MASK | SW_OUTPUT_MODE_MASK,
200 SW_OUTPUT_MODE(OUTPUT_MODE_RGB));
201 regmap_update_bits(rgb->grf, GRF_POST_PROC_CON,
202 SW_DCLK_OUT_INV_EN, SW_DCLK_OUT_INV_EN);
203 break;
204 }
205
206 if (rgb->panel) {
207 drm_panel_prepare(rgb->panel);
208 drm_panel_enable(rgb->panel);
209 }
210 }
211
rk628_rgb_bridge_disable(struct drm_bridge * bridge)212 static void rk628_rgb_bridge_disable(struct drm_bridge *bridge)
213 {
214 struct rk628_rgb *rgb = bridge_to_rgb(bridge);
215
216 if (rgb->panel) {
217 drm_panel_disable(rgb->panel);
218 drm_panel_unprepare(rgb->panel);
219 }
220
221 if (rgb->decclk)
222 clk_disable_unprepare(rgb->decclk);
223
224 if (rgb->rstc)
225 reset_control_assert(rgb->rstc);
226 }
227
rk628_rgb_bridge_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)228 static int rk628_rgb_bridge_attach(struct drm_bridge *bridge,
229 enum drm_bridge_attach_flags flags)
230 {
231 struct rk628_rgb *rgb = bridge_to_rgb(bridge);
232 struct drm_connector *connector = &rgb->connector;
233 struct drm_device *drm = bridge->dev;
234 struct device *dev = rgb->dev;
235 int ret;
236
237 ret = drm_of_find_panel_or_bridge(dev->of_node, 1, -1,
238 &rgb->panel, &rgb->bridge);
239 if (ret)
240 return ret;
241
242 if (rgb->interface_type == YUV_RX || rgb->interface_type == BT1120_RX) {
243 if (!rgb->bridge) {
244 dev_err(dev, "decoder failed to find bridge\n");
245 return -EPROBE_DEFER;
246 }
247
248 ret = drm_bridge_attach(bridge->encoder, rgb->bridge, bridge,
249 flags);
250 if (ret) {
251 dev_err(dev, "failed to attach bridge\n");
252 return ret;
253 }
254 } else {
255 if (rgb->bridge) {
256 ret = drm_bridge_attach(bridge->encoder, rgb->bridge,
257 bridge, flags);
258 if (ret) {
259 dev_err(dev, "failed to attach bridge\n");
260 return ret;
261 }
262 }
263
264 if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
265 return 0;
266
267 if (rgb->panel) {
268 ret = drm_connector_init(drm, connector,
269 &rk628_rgb_connector_funcs,
270 DRM_MODE_CONNECTOR_DPI);
271 if (ret) {
272 dev_err(dev,
273 "Failed to initialize connector with drm\n");
274 return ret;
275 }
276
277 drm_connector_helper_add(connector,
278 &rk628_rgb_connector_helper_funcs);
279 drm_connector_attach_encoder(connector,
280 bridge->encoder);
281 }
282 }
283
284 return 0;
285 }
286
rk628_rgb_bridge_mode_set(struct drm_bridge * bridge,const struct drm_display_mode * mode,const struct drm_display_mode * adj)287 static void rk628_rgb_bridge_mode_set(struct drm_bridge *bridge,
288 const struct drm_display_mode *mode,
289 const struct drm_display_mode *adj)
290 {
291 struct rk628_rgb *rgb = bridge_to_rgb(bridge);
292
293 drm_mode_copy(&rgb->mode, adj);
294 }
295
296 static const struct drm_bridge_funcs rk628_rgb_bridge_funcs = {
297 .attach = rk628_rgb_bridge_attach,
298 .enable = rk628_rgb_bridge_enable,
299 .disable = rk628_rgb_bridge_disable,
300 .mode_set = rk628_rgb_bridge_mode_set,
301 };
302
rk628_rgb_probe(struct platform_device * pdev)303 static int rk628_rgb_probe(struct platform_device *pdev)
304 {
305 struct rk628 *rk628 = dev_get_drvdata(pdev->dev.parent);
306 struct device *dev = &pdev->dev;
307 struct rk628_rgb *rgb;
308 int ret;
309
310 if (!of_device_is_available(dev->of_node))
311 return -ENODEV;
312
313 rgb = devm_kzalloc(dev, sizeof(*rgb), GFP_KERNEL);
314 if (!rgb)
315 return -ENOMEM;
316
317 rgb->dev = dev;
318 rgb->parent = rk628;
319 rgb->grf = rk628->grf;
320 rgb->interface_type = rk628_rgb_get_interface_type(rgb);
321 rgb->dual_edge = of_property_read_bool(dev->of_node, "dual-edge");
322 platform_set_drvdata(pdev, rgb);
323
324 if (rgb->interface_type == BT1120_RX) {
325 rgb->decclk = devm_clk_get(dev, "bt1120dec");
326 if (IS_ERR(rgb->decclk)) {
327 ret = PTR_ERR(rgb->decclk);
328 dev_err(dev, "failed to get dec clk: %d\n", ret);
329 return ret;
330 }
331
332 rgb->rstc = of_reset_control_get(dev->of_node, NULL);
333 if (IS_ERR(rgb->rstc)) {
334 ret = PTR_ERR(rgb->rstc);
335 dev_err(dev, "failed to get reset control: %d\n", ret);
336 return ret;
337 }
338 }
339
340 rgb->base.funcs = &rk628_rgb_bridge_funcs;
341 rgb->base.of_node = dev->of_node;
342 drm_bridge_add(&rgb->base);
343
344 return 0;
345 }
346
rk628_rgb_remove(struct platform_device * pdev)347 static int rk628_rgb_remove(struct platform_device *pdev)
348 {
349 struct rk628_rgb *rgb = platform_get_drvdata(pdev);
350
351 drm_bridge_remove(&rgb->base);
352
353 return 0;
354 }
355
356 static const struct of_device_id rk628_rgb_of_match[] = {
357 { .compatible = "rockchip,rk628-rgb-tx", },
358 { .compatible = "rockchip,rk628-yuv-rx", },
359 { .compatible = "rockchip,rk628-yuv-tx", },
360 { .compatible = "rockchip,rk628-bt1120-rx", },
361 { .compatible = "rockchip,rk628-bt1120-tx", },
362 {},
363 };
364 MODULE_DEVICE_TABLE(of, rk628_rgb_of_match);
365
366 static struct platform_driver rk628_rgb_driver = {
367 .driver = {
368 .name = "rk628-rgb",
369 .of_match_table = of_match_ptr(rk628_rgb_of_match),
370 },
371 .probe = rk628_rgb_probe,
372 .remove = rk628_rgb_remove,
373 };
374 module_platform_driver(rk628_rgb_driver);
375
376 MODULE_AUTHOR("Wyon Bi <bivvy.bi@rock-chips.com>");
377 MODULE_DESCRIPTION("Rockchip RK628 RGB driver");
378 MODULE_LICENSE("GPL v2");
379