1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
4 *
5 * Author: Algea Cao <algea.cao@rock-chips.com>
6 */
7
8 #include <linux/delay.h>
9 #include <linux/i2c.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/mfd/rk630.h>
13 #include <linux/mfd/syscon.h>
14
15 #include <drm/drm_atomic_helper.h>
16 #include <drm/drm_crtc_helper.h>
17 #include <drm/drm_of.h>
18 #include <drm/drm_probe_helper.h>
19
20 #include "../rockchip/rockchip_drm_drv.h"
21
22 static const struct drm_display_mode rk630_tve_mode[2] = {
23 { DRM_MODE("720x576i", DRM_MODE_TYPE_DRIVER, 13500, 720, 753,
24 816, 864, 0, 576, 580, 586, 625, 0,
25 DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC |
26 DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
27 0, },
28 { DRM_MODE("720x480i", DRM_MODE_TYPE_DRIVER, 13500, 720, 753,
29 815, 858, 0, 480, 483, 489, 525, 0,
30 DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
31 DRM_MODE_FLAG_INTERLACE | DRM_MODE_FLAG_DBLCLK),
32 0, },
33 };
34
35 struct rk630_tve {
36 struct device *dev;
37 struct drm_connector connector;
38 struct drm_bridge bridge;
39 struct drm_encoder *encoder;
40
41 struct regmap *grf;
42 struct regmap *cru;
43 struct regmap *tvemap;
44 struct rk630 *parent;
45
46 int mode;
47 int is_4x;
48 struct rockchip_drm_sub_dev sub_dev;
49 };
50
51 enum {
52 CVBS_NTSC = 0,
53 CVBS_PAL,
54 };
55
56 struct env_config {
57 u32 offset;
58 u32 value;
59 };
60
61 static struct env_config ntsc_bt656_config[] = {
62 { BT656_DECODER_CTRL, 0x00000001 },
63 { BT656_DECODER_CROP, 0x00000000 },
64 { BT656_DECODER_SIZE, 0x01e002d0 },
65 { BT656_DECODER_HTOTAL_HS_END, 0x035a003e },
66 { BT656_DECODER_VACT_ST_HACT_ST, 0x00150069 },
67 { BT656_DECODER_VTOTAL_VS_END, 0x020d0003 },
68 { BT656_DECODER_VS_ST_END_F1, 0x01060109 },
69 { BT656_DECODER_DBG_REG, 0x024002d0 },
70 };
71
72 static struct env_config ntsc_tve_config[] = {
73 { TVE_MODE_CTRL, 0x000af906 },
74 { TVE_HOR_TIMING1, 0x00c07a81 },
75 { TVE_HOR_TIMING2, 0x169810fc },
76 { TVE_HOR_TIMING3, 0x96b40000 },
77 { TVE_SUB_CAR_FRQ, 0x21f07bd7 },
78 { TVE_LUMA_FILTER1, 0x000a0ffa },
79 { TVE_LUMA_FILTER2, 0x0ff4001a },
80 { TVE_LUMA_FILTER3, 0x00110fd2 },
81 { TVE_LUMA_FILTER4, 0x0fe80051 },
82 { TVE_LUMA_FILTER5, 0x001a0f74 },
83 { TVE_LUMA_FILTER6, 0x0fe600ec },
84 { TVE_LUMA_FILTER7, 0x0ffa0e43 },
85 { TVE_LUMA_FILTER8, 0x08200527 },
86 { TVE_IMAGE_POSITION, 0x001500d6 },
87 { TVE_ROUTING, 0x10088880 },
88 { TVE_SYNC_ADJUST, 0x00000000 },
89 { TVE_STATUS, 0x00000000 },
90 { TVE_CTRL, 0x00000000 },
91 { TVE_INTR_STATUS, 0x00000000 },
92 { TVE_INTR_EN, 0x00000000 },
93 { TVE_INTR_CLR, 0x00000000 },
94 { TVE_COLOR_BUSRT_SAT, 0x0052543c },
95 { TVE_CHROMA_BANDWIDTH, 0x00000002 },
96 { TVE_BRIGHTNESS_CONTRAST, 0x00008300 },
97 { TVE_ID, 0x0a010000 },
98 { TVE_REVISION, 0x00010108 },
99 { TVE_CLAMP, 0x00000000 },
100 };
101
102 static struct env_config pal_bt656_config[] = {
103 { BT656_DECODER_CTRL, 0x00000001 },
104 { BT656_DECODER_CROP, 0x00000000 },
105 { BT656_DECODER_SIZE, 0x024002d0 },
106 { BT656_DECODER_HTOTAL_HS_END, 0x0360003f },
107 { BT656_DECODER_VACT_ST_HACT_ST, 0x0016006f },
108 { BT656_DECODER_VTOTAL_VS_END, 0x02710003 },
109 { BT656_DECODER_VS_ST_END_F1, 0x0138013b },
110 { BT656_DECODER_DBG_REG, 0x024002d0 },
111 };
112
113 static struct env_config pal_tve_config[] = {
114 { TVE_MODE_CTRL, 0x010ab906 },
115 { TVE_HOR_TIMING1, 0x00c28381 },
116 { TVE_HOR_TIMING2, 0x267d111d },
117 { TVE_HOR_TIMING3, 0x76c00880 },
118 { TVE_SUB_CAR_FRQ, 0x2a098acb },
119 { TVE_LUMA_FILTER1, 0x000a0ffa },
120 { TVE_LUMA_FILTER2, 0x0ff4001a },
121 { TVE_LUMA_FILTER3, 0x00110fd2 },
122 { TVE_LUMA_FILTER4, 0x0fe80051 },
123 { TVE_LUMA_FILTER5, 0x001a0f74 },
124 { TVE_LUMA_FILTER6, 0x0fe600ec },
125 { TVE_LUMA_FILTER7, 0x0ffa0e43 },
126 { TVE_LUMA_FILTER8, 0x08200527 },
127 { TVE_IMAGE_POSITION, 0x001500f6 },
128 { TVE_ROUTING, 0x1000088a },
129 { TVE_SYNC_ADJUST, 0x00000000 },
130 { TVE_STATUS, 0x000000b0 },
131 { TVE_CTRL, 0x00000000 },
132 { TVE_INTR_STATUS, 0x00000000 },
133 { TVE_INTR_EN, 0x00000000 },
134 { TVE_INTR_CLR, 0x00000000 },
135 { TVE_COLOR_BUSRT_SAT, 0x002e553c },
136 { TVE_CHROMA_BANDWIDTH, 0x00000022 },
137 { TVE_BRIGHTNESS_CONTRAST, 0x00008900 },
138 { TVE_ID, 0x0a010000 },
139 { TVE_REVISION, 0x00010108 },
140 { TVE_CLAMP, 0x00000000 },
141 };
142
143 static const struct regmap_range rk630_tve_readable_ranges[] = {
144 regmap_reg_range(BT656_DECODER_CTRL, BT656_DECODER_DBG_REG),
145 regmap_reg_range(TVE_MODE_CTRL, TVE_ROUTING),
146 regmap_reg_range(TVE_SYNC_ADJUST, TVE_STATUS),
147 regmap_reg_range(TVE_CTRL, TVE_COLOR_BUSRT_SAT),
148 regmap_reg_range(TVE_CHROMA_BANDWIDTH, TVE_BRIGHTNESS_CONTRAST),
149 regmap_reg_range(TVE_ID, TVE_CLAMP),
150 };
151
152 static const struct regmap_access_table rk630_tve_readable_table = {
153 .yes_ranges = rk630_tve_readable_ranges,
154 .n_yes_ranges = ARRAY_SIZE(rk630_tve_readable_ranges),
155 };
156
157 const struct regmap_config rk630_tve_regmap_config = {
158 .name = "tve",
159 .reg_bits = 32,
160 .val_bits = 32,
161 .reg_stride = 4,
162 .max_register = TVE_MAX_REGISTER,
163 .reg_format_endian = REGMAP_ENDIAN_NATIVE,
164 .val_format_endian = REGMAP_ENDIAN_NATIVE,
165 .rd_table = &rk630_tve_readable_table,
166 };
167 EXPORT_SYMBOL_GPL(rk630_tve_regmap_config);
168
bridge_to_tve(struct drm_bridge * bridge)169 static struct rk630_tve *bridge_to_tve(struct drm_bridge *bridge)
170 {
171 return container_of(bridge, struct rk630_tve, bridge);
172 }
173
connector_to_tve(struct drm_connector * connector)174 static struct rk630_tve *connector_to_tve(struct drm_connector *connector)
175 {
176 return container_of(connector, struct rk630_tve, connector);
177 }
178
rk630_tve_write_block(struct rk630_tve * tve,struct env_config * config,int len)179 static int rk630_tve_write_block(struct rk630_tve *tve,
180 struct env_config *config, int len)
181 {
182 int i, ret = 0;
183
184 for (i = 0; i < len; i++) {
185 ret = regmap_write(tve->tvemap, config[i].offset,
186 config[i].value);
187 if (ret)
188 break;
189 }
190
191 return ret;
192 }
193
rk630_tve_cfg_set(struct rk630_tve * tve)194 static int rk630_tve_cfg_set(struct rk630_tve *tve)
195 {
196 int ret;
197 struct env_config *bt656_cfg, *tve_cfg;
198
199 switch (tve->mode) {
200 case CVBS_PAL:
201 dev_dbg(tve->dev, "rk630 PAL\n");
202 bt656_cfg = pal_bt656_config;
203 tve_cfg = pal_tve_config;
204 break;
205 case CVBS_NTSC:
206 dev_dbg(tve->dev, "rk630 NTSC\n");
207 bt656_cfg = ntsc_bt656_config;
208 tve_cfg = ntsc_tve_config;
209 break;
210 default:
211 dev_dbg(tve->dev, "mode select err\n");
212 return -EINVAL;
213 }
214
215 ret = rk630_tve_write_block(tve, bt656_cfg, 8);
216 if (ret) {
217 dev_err(tve->dev, "rk630 bt656 write err!\n");
218 return ret;
219 }
220
221 if (tve->mode == CVBS_PAL)
222 regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON0,
223 SW_TVE_DCLK_POL_MASK |
224 SW_TVE_DCLK_EN_MASK |
225 SW_DCLK_UPSAMPLE_EN_MASK |
226 SW_TVE_MODE_MASK | SW_TVE_EN_MASK,
227 SW_TVE_DCLK_POL(0) | SW_TVE_DCLK_EN(1) |
228 SW_DCLK_UPSAMPLE_EN(tve->is_4x) |
229 SW_TVE_MODE(1) | SW_TVE_EN(1));
230 else
231 regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON0,
232 SW_TVE_DCLK_POL_MASK |
233 SW_TVE_DCLK_EN_MASK |
234 SW_DCLK_UPSAMPLE_EN_MASK |
235 SW_TVE_MODE_MASK | SW_TVE_EN_MASK,
236 SW_TVE_DCLK_POL(0) | SW_TVE_DCLK_EN(1) |
237 SW_DCLK_UPSAMPLE_EN(tve->is_4x) |
238 SW_TVE_MODE(0) | SW_TVE_EN(1));
239
240 ret = rk630_tve_write_block(tve, tve_cfg, 27);
241 if (ret < 0) {
242 dev_err(tve->dev, "rk630 tve write err\n");
243 return ret;
244 }
245
246 return ret;
247 }
248
rk630_tve_disable(struct rk630_tve * tve)249 static int rk630_tve_disable(struct rk630_tve *tve)
250 {
251 regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON3, VDAC_ENDAC0_MASK,
252 VDAC_ENDAC0(0));
253
254 return 0;
255 }
256
rk630_tve_enable(struct rk630_tve * tve)257 static int rk630_tve_enable(struct rk630_tve *tve)
258 {
259 int ret, i;
260 u32 val = 0;
261
262 dev_dbg(tve->dev, "%s\n", __func__);
263
264 /* config bt656 input gpio*/
265 regmap_write(tve->grf, PLUMAGE_GRF_GPIO0A_IOMUX, 0x55555555);
266
267 regmap_update_bits(tve->grf, PLUMAGE_GRF_GPIO0B_IOMUX, GPIO0B0_SEL_MASK,
268 GPIO0B0_SEL(1));
269
270 regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON3, VDAC_ENDAC0_MASK,
271 VDAC_ENDAC0(0));
272
273 ret = rk630_tve_cfg_set(tve);
274 if (ret)
275 return ret;
276
277 /*config clk*/
278 if (!tve->is_4x) {
279 regmap_update_bits(tve->cru, CRU_MODE_CON, CLK_SPLL_MODE_MASK,
280 CLK_SPLL_MODE(2));
281 } else {
282 regmap_update_bits(tve->cru, CRU_SPLL_CON1, PLLPD0_MASK,
283 PLLPD0(1));
284
285 regmap_update_bits(tve->cru, CRU_MODE_CON, CLK_SPLL_MODE_MASK,
286 CLK_SPLL_MODE(1));
287
288 regmap_update_bits(tve->cru, CRU_SPLL_CON1, PLLPD0_MASK,
289 PLLPD0(0));
290
291 for (i = 0; i < 10; i++) {
292 usleep_range(1000, 2000);
293 regmap_read(tve->cru, CRU_SPLL_CON1, &val);
294 if (val & PLL_LOCK) {
295 dev_dbg(tve->dev, "rk630 pll locked\n");
296 break;
297 }
298 }
299 if (!(val & PLL_LOCK)) {
300 dev_err(tve->dev, "rk630 pll unlock\n");
301 return -EINVAL;
302 }
303 }
304
305 /* enable vdac */
306 regmap_update_bits(tve->grf, PLUMAGE_GRF_SOC_CON3,
307 VDAC_ENVBG_MASK | VDAC_ENDAC0_MASK,
308 VDAC_ENVBG(1) | VDAC_ENDAC0(1));
309
310 return 0;
311 }
312
313 static enum drm_mode_status
rk630_tve_mode_valid(struct drm_connector * connector,struct drm_display_mode * mode)314 rk630_tve_mode_valid(struct drm_connector *connector,
315 struct drm_display_mode *mode)
316 {
317 return MODE_OK;
318 }
319
320 static int
rk630_tve_get_modes(struct drm_connector * connector)321 rk630_tve_get_modes(struct drm_connector *connector)
322 {
323 int count;
324 u32 bus_format = MEDIA_BUS_FMT_UYVY8_2X8;
325 struct rk630_tve *tve = connector_to_tve(connector);
326
327 for (count = 0; count < ARRAY_SIZE(rk630_tve_mode); count++) {
328 struct drm_display_mode *mode_ptr;
329
330 mode_ptr = drm_mode_duplicate(connector->dev,
331 &rk630_tve_mode[count]);
332 if (!mode_ptr) {
333 dev_err(tve->dev, "mode duplicate failed\n");
334 return -ENOMEM;
335 }
336
337 if (!count)
338 mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
339 drm_mode_probed_add(connector, mode_ptr);
340 }
341 drm_display_info_set_bus_formats(&connector->display_info,
342 &bus_format, 1);
343
344 return count;
345 }
346
347 static enum drm_connector_status
rk630_tve_connector_detect(struct drm_connector * connector,bool force)348 rk630_tve_connector_detect(struct drm_connector *connector,
349 bool force)
350 {
351 return connector_status_connected;
352 }
353
rk630_tve_best_encoder(struct drm_connector * connector)354 static struct drm_encoder *rk630_tve_best_encoder(struct drm_connector *connector)
355 {
356 struct rk630_tve *tve = connector_to_tve(connector);
357
358 return tve->encoder;
359 }
360
361 static
362 const struct drm_connector_helper_funcs rk630_tve_connector_helper_funcs = {
363 .get_modes = rk630_tve_get_modes,
364 .mode_valid = rk630_tve_mode_valid,
365 .best_encoder = rk630_tve_best_encoder,
366 };
367
368 static const struct drm_connector_funcs rk630_tve_connector_funcs = {
369 .fill_modes = drm_helper_probe_single_connector_modes,
370 .detect = rk630_tve_connector_detect,
371 .destroy = drm_connector_cleanup,
372 .reset = drm_atomic_helper_connector_reset,
373 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
374 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
375 };
376
377 static void
rk630_tve_bridge_mode_set(struct drm_bridge * bridge,const struct drm_display_mode * mode,const struct drm_display_mode * adjusted_mode)378 rk630_tve_bridge_mode_set(struct drm_bridge *bridge,
379 const struct drm_display_mode *mode,
380 const struct drm_display_mode *adjusted_mode)
381 {
382 struct rk630_tve *tve;
383
384 tve = bridge_to_tve(bridge);
385
386 if (adjusted_mode->vdisplay == 576)
387 tve->mode = CVBS_PAL;
388 else
389 tve->mode = CVBS_NTSC;
390 }
391
rk630_tve_bridge_enable(struct drm_bridge * bridge)392 static void rk630_tve_bridge_enable(struct drm_bridge *bridge)
393 {
394 int ret;
395 struct rk630_tve *tve = bridge_to_tve(bridge);
396
397 dev_dbg(tve->dev, "%s\n", __func__);
398 ret = rk630_tve_enable(tve);
399 if (ret)
400 dev_err(tve->dev, "rk630 enable failed\n");
401 }
402
rk630_tve_bridge_disable(struct drm_bridge * bridge)403 static void rk630_tve_bridge_disable(struct drm_bridge *bridge)
404 {
405 struct rk630_tve *tve = bridge_to_tve(bridge);
406
407 dev_dbg(tve->dev, "%s\n", __func__);
408 rk630_tve_disable(tve);
409 }
410
rk630_tve_bridge_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)411 static int rk630_tve_bridge_attach(struct drm_bridge *bridge,
412 enum drm_bridge_attach_flags flags)
413 {
414 struct rk630_tve *tve = bridge_to_tve(bridge);
415 int ret;
416
417 if (!bridge->encoder) {
418 dev_err(tve->dev, "Parent encoder object not found\n");
419 return -ENODEV;
420 }
421
422 tve->encoder = bridge->encoder;
423 ret = drm_connector_init(bridge->dev, &tve->connector,
424 &rk630_tve_connector_funcs,
425 DRM_MODE_CONNECTOR_TV);
426 if (ret) {
427 dev_err(tve->dev, "Failed to initialize connector\n");
428 return ret;
429 }
430
431 drm_connector_helper_add(&tve->connector,
432 &rk630_tve_connector_helper_funcs);
433 ret = drm_connector_attach_encoder(&tve->connector,
434 bridge->encoder);
435
436 if (ret)
437 dev_err(tve->dev, "rk630 attach failed ret:%d", ret);
438 tve->sub_dev.connector = &tve->connector;
439 tve->sub_dev.of_node = tve->dev->of_node;
440 rockchip_drm_register_sub_dev(&tve->sub_dev);
441 tve->connector.interlace_allowed = 1;
442
443 return ret;
444 }
445
rk1000_bridge_detach(struct drm_bridge * bridge)446 static void rk1000_bridge_detach(struct drm_bridge *bridge)
447 {
448 struct rk630_tve *tve = bridge_to_tve(bridge);
449
450 rockchip_drm_unregister_sub_dev(&tve->sub_dev);
451 }
452
453 static struct drm_bridge_funcs rk630_tve_bridge_funcs = {
454 .enable = rk630_tve_bridge_enable,
455 .disable = rk630_tve_bridge_disable,
456 .mode_set = rk630_tve_bridge_mode_set,
457 .attach = rk630_tve_bridge_attach,
458 .detach = rk1000_bridge_detach,
459 };
460
rk630_tve_probe(struct platform_device * pdev)461 static int rk630_tve_probe(struct platform_device *pdev)
462 {
463 struct rk630 *rk630 = dev_get_drvdata(pdev->dev.parent);
464 struct rk630_tve *tve;
465 struct device *dev = &pdev->dev;
466
467 if (!of_device_is_available(dev->of_node))
468 return -ENODEV;
469
470 tve = devm_kzalloc(dev, sizeof(*tve), GFP_KERNEL);
471 if (!tve)
472 return -ENOMEM;
473
474 tve->dev = dev;
475 tve->parent = rk630;
476 platform_set_drvdata(pdev, tve);
477
478 tve->grf = rk630->grf;
479 tve->cru = rk630->cru;
480 tve->tvemap = rk630->tve;
481 if (!tve->grf | !tve->cru | !tve->tvemap)
482 return -ENODEV;
483
484 tve->mode = CVBS_PAL;
485
486 tve->bridge.funcs = &rk630_tve_bridge_funcs;
487 tve->bridge.of_node = tve->dev->of_node;
488
489 drm_bridge_add(&tve->bridge);
490
491 dev_dbg(tve->dev, "rk630 probe tve ok\n");
492
493 return 0;
494 }
495
rk630_tve_remove(struct platform_device * pdev)496 static int rk630_tve_remove(struct platform_device *pdev)
497 {
498 struct rk630_tve *tve = platform_get_drvdata(pdev);
499
500 drm_bridge_remove(&tve->bridge);
501
502 return 0;
503 }
504
505 static const struct of_device_id rk630_tve_dt_ids[] = {
506 { .compatible = "rockchip,rk630-tve" },
507 { }
508 };
509
510 MODULE_DEVICE_TABLE(of, rk630_tve_dt_ids);
511
512 static struct platform_driver rk630_tve_driver = {
513 .driver = {
514 .name = "rk630-tve",
515 .of_match_table = of_match_ptr(rk630_tve_dt_ids),
516 },
517 .probe = rk630_tve_probe,
518 .remove = rk630_tve_remove,
519 };
520 module_platform_driver(rk630_tve_driver);
521
522 MODULE_AUTHOR("Algea Cao <Algea.cao@rock-chips.com>");
523 MODULE_DESCRIPTION("ROCKCHIP rk630 TVE Driver");
524 MODULE_LICENSE("GPL v2");
525