1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd
4 */
5
6 #include <common.h>
7 #include <boot_rkimg.h>
8 #include <dm.h>
9 #include <errno.h>
10 #include <i2c.h>
11 #include <video_bridge.h>
12 #include <asm/io.h>
13 #include <dm/device.h>
14 #include <dm/device-internal.h>
15 #include <linux/media-bus-format.h>
16
17 #include "rockchip_bridge.h"
18 #include "rockchip_display.h"
19 #include "rockchip_panel.h"
20
21 #include "rk1000.h"
22
23 #define TVE_POWCR 0x03
24 #define TVE_OFF 0X07
25 #define TVE_ON 0x03
26
27 struct rk1000_tve {
28 struct udevice *dev;
29 struct rk1000_ctl rk1000_ctl;
30 };
31
32 enum {
33 CVBS_NTSC = 0,
34 CVBS_PAL,
35 };
36
rk1000_tve_i2c_write(struct rk1000_tve * rk1000_tve,u8 reg,u8 val)37 int rk1000_tve_i2c_write(struct rk1000_tve *rk1000_tve, u8 reg, u8 val)
38 {
39 struct dm_i2c_chip *chip = dev_get_parent_platdata(rk1000_tve->dev);
40 struct i2c_msg msg;
41 u8 buf[2];
42 int ret;
43
44 buf[0] = reg;
45 buf[1] = val;
46 msg.addr = chip->chip_addr;
47 msg.flags = 0;
48 msg.len = 2;
49 msg.buf = buf;
50
51 ret = dm_i2c_xfer(rk1000_tve->dev, &msg, 1);
52 if (ret) {
53 dev_err(rk1000_tve->dev,
54 "rk1000 tve i2c write failed: %d\n", ret);
55 return ret;
56 }
57
58 return 0;
59 }
60
rk1000_tve_i2c_read(struct rk1000_tve * rk1000_tve,u8 reg,u8 * val)61 int rk1000_tve_i2c_read(struct rk1000_tve *rk1000_tve, u8 reg, u8 *val)
62 {
63 struct dm_i2c_chip *chip = dev_get_parent_platdata(rk1000_tve->dev);
64 u8 data;
65 struct i2c_msg msg[] = {
66 {
67 .addr = chip->chip_addr,
68 .flags = 0,
69 .buf = (u8 *)®,
70 .len = 1,
71 }, {
72 .addr = chip->chip_addr,
73 .flags = I2C_M_RD,
74 .buf = (u8 *)&data,
75 .len = 1,
76 }
77 };
78 int ret;
79
80 ret = dm_i2c_xfer(rk1000_tve->dev, msg, 2);
81 if (ret) {
82 dev_err(rk1000_tve->dev,
83 "rk1000 tve i2c read failed: %d\n", ret);
84 return ret;
85 }
86
87 *val = data;
88
89 return 0;
90 }
91
rk1000_tv_write_block(struct rk1000_tve * rk1000_tve,u8 reg,const u8 * buf,u8 len)92 static int rk1000_tv_write_block(struct rk1000_tve *rk1000_tve,
93 u8 reg, const u8 *buf, u8 len)
94 {
95 int i, ret;
96
97 for (i = 0; i < len; i++) {
98 ret = rk1000_tve_i2c_write(rk1000_tve, reg + i, buf[i]);
99 if (ret)
100 break;
101 }
102
103 return ret;
104 }
105
rk1000_tve_probe(struct udevice * dev)106 static int rk1000_tve_probe(struct udevice *dev)
107 {
108 struct rk1000_tve *rk1000_tve = dev_get_priv(dev);
109 struct rockchip_bridge *bridge =
110 (struct rockchip_bridge *)dev_get_driver_data(dev);
111 int ret;
112
113 rk1000_tve->dev = dev;
114
115 ret = uclass_get_device_by_name(UCLASS_I2C_GENERIC,
116 "rk1000-ctl@40",
117 &rk1000_tve->rk1000_ctl.dev);
118 if (ret)
119 return ret;
120
121 bridge->dev = dev;
122
123 return 0;
124 }
125
rk1000_tve_bridge_enable(struct rockchip_bridge * bridge)126 static void rk1000_tve_bridge_enable(struct rockchip_bridge *bridge)
127 {
128 u8 tv_encoder_regs_pal[] = {0x06, 0x00, 0x00, 0x03, 0x00, 0x00};
129 u8 tv_encoder_control_regs_pal[] = {0x41, 0x01};
130 u8 tv_encoder_regs_ntsc[] = {0x00, 0x00, 0x00, 0x03, 0x00, 0x00};
131 u8 tv_encoder_control_regs_ntsc[] = {0x43, 0x01};
132 char data[4] = {0x88, 0x00, 0x22, 0x00};
133 struct rk1000_tve *rk1000_tve = dev_get_priv(bridge->dev);
134 struct connector_state *conn_state = &bridge->state->conn_state;
135 struct drm_display_mode *mode = &conn_state->mode;
136 struct rk1000_ctl *rk1000_ctl = &rk1000_tve->rk1000_ctl;
137
138 rk1000_ctl_write_block(rk1000_ctl, 0, (u8 *)data, 4);
139
140 /* rk1000 power down output dac */
141 data[0] = 0x07;
142 rk1000_tv_write_block(rk1000_tve, 0x03, (u8 *)data, 1);
143
144 if (mode->vdisplay == 576) {
145 rk1000_tv_write_block(rk1000_tve, 0, tv_encoder_regs_pal,
146 sizeof(tv_encoder_regs_pal));
147 rk1000_ctl_write_block(rk1000_ctl, 3,
148 tv_encoder_control_regs_pal,
149 sizeof(tv_encoder_control_regs_pal));
150 } else {
151 rk1000_tv_write_block(rk1000_tve, 0, tv_encoder_regs_ntsc,
152 sizeof(tv_encoder_regs_ntsc));
153 rk1000_ctl_write_block(rk1000_ctl, 3,
154 tv_encoder_control_regs_ntsc,
155 sizeof(tv_encoder_control_regs_ntsc));
156 }
157 }
158
rk1000_tve_bridge_disable(struct rockchip_bridge * bridge)159 static void rk1000_tve_bridge_disable(struct rockchip_bridge *bridge)
160 {
161 struct rk1000_tve *rk1000_tve = dev_get_priv(bridge->dev);
162 char data[1] = {0x07};
163
164 /* rk1000 power down output dac */
165 rk1000_tv_write_block(rk1000_tve, 0x03, (u8 *)data, 1);
166 }
167
drm_rk1000_select_output(struct overscan * overscan,struct drm_display_mode * mode)168 static void drm_rk1000_select_output(struct overscan *overscan,
169 struct drm_display_mode *mode)
170 {
171 char baseparameter_buf[8 * RK_BLK_SIZE] __aligned(ARCH_DMA_MINALIGN);
172 struct base_screen_info *screen_info = NULL;
173 struct base_disp_info base_parameter;
174 struct blk_desc *dev_desc;
175 const struct base_overscan *scan;
176 disk_partition_t part_info;
177 int ret, i, screen_size;
178 int max_scan = 100;
179 int min_scan = 51;
180
181 overscan->left_margin = max_scan;
182 overscan->right_margin = max_scan;
183 overscan->top_margin = max_scan;
184 overscan->bottom_margin = max_scan;
185
186 mode->hdisplay = 720;
187 mode->hsync_start = 732;
188 mode->hsync_end = 738;
189 mode->htotal = 864;
190 mode->vdisplay = 576;
191 mode->vsync_start = 582;
192 mode->vsync_end = 588;
193 mode->vtotal = 625;
194 mode->clock = 27000;
195 mode->flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC;
196
197 dev_desc = rockchip_get_bootdev();
198 if (!dev_desc) {
199 printf("%s: Could not find device\n", __func__);
200 return;
201 }
202
203 if (part_get_info_by_name(dev_desc, "baseparameter", &part_info) < 0) {
204 printf("Could not find baseparameter partition\n");
205 return;
206 }
207
208 ret = blk_dread(dev_desc, part_info.start, 1,
209 (void *)baseparameter_buf);
210 if (ret < 0) {
211 printf("read baseparameter failed\n");
212 return;
213 }
214
215 memcpy(&base_parameter, baseparameter_buf, sizeof(base_parameter));
216 scan = &base_parameter.scan;
217
218 screen_size = sizeof(base_parameter.screen_list) /
219 sizeof(base_parameter.screen_list[0]);
220
221 for (i = 0; i < screen_size; i++) {
222 if (base_parameter.screen_list[i].type ==
223 DRM_MODE_CONNECTOR_TV) {
224 screen_info = &base_parameter.screen_list[i];
225 break;
226 }
227 }
228
229 if (scan->leftscale < min_scan && scan->leftscale > 0)
230 overscan->left_margin = min_scan;
231 else if (scan->leftscale < max_scan)
232 overscan->left_margin = scan->leftscale;
233
234 if (scan->rightscale < min_scan && scan->rightscale > 0)
235 overscan->right_margin = min_scan;
236 else if (scan->rightscale < max_scan)
237 overscan->right_margin = scan->rightscale;
238
239 if (scan->topscale < min_scan && scan->topscale > 0)
240 overscan->top_margin = min_scan;
241 else if (scan->topscale < max_scan)
242 overscan->top_margin = scan->topscale;
243
244 if (scan->bottomscale < min_scan && scan->bottomscale > 0)
245 overscan->bottom_margin = min_scan;
246 else if (scan->bottomscale < max_scan)
247 overscan->bottom_margin = scan->bottomscale;
248
249 if (screen_info &&
250 (screen_info->mode.hdisplay == 720 &&
251 screen_info->mode.hsync_end == 742 &&
252 screen_info->mode.vdisplay == 480)) {
253 mode->hdisplay = 720;
254 mode->hsync_start = 736;
255 mode->hsync_end = 742;
256 mode->htotal = 858;
257 mode->vdisplay = 480;
258 mode->vsync_start = 494;
259 mode->vsync_end = 500;
260 mode->vtotal = 525;
261 mode->clock = 27000;
262 } else {
263 mode->hdisplay = 720;
264 mode->hsync_start = 732;
265 mode->hsync_end = 738;
266 mode->htotal = 864;
267 mode->vdisplay = 576;
268 mode->vsync_start = 582;
269 mode->vsync_end = 588;
270 mode->vtotal = 625;
271 mode->clock = 27000;
272 }
273 }
274
rk1000_tve_get_timing(struct udevice * dev)275 static int rk1000_tve_get_timing(struct udevice *dev)
276 {
277 struct rockchip_bridge *bridge =
278 (struct rockchip_bridge *)dev_get_driver_data(dev);
279 struct connector_state *conn_state = &bridge->state->conn_state;
280 struct drm_display_mode *mode = &conn_state->mode;
281 struct overscan *overscan = &conn_state->overscan;
282
283 drm_rk1000_select_output(overscan, mode);
284
285 return 0;
286 }
287
288 static const struct rockchip_bridge_funcs rk1000_tve_bridge_funcs = {
289 .enable = rk1000_tve_bridge_enable,
290 .disable = rk1000_tve_bridge_disable,
291 };
292
293 static struct rockchip_bridge rk1000_tve_driver_data = {
294 .funcs = &rk1000_tve_bridge_funcs,
295 };
296
297 struct video_bridge_ops rk1000_tve_ops = {
298 .get_timing = rk1000_tve_get_timing,
299 };
300
301 static const struct udevice_id rk1000_tve_ids[] = {
302 {
303 .compatible = "rockchip,rk1000-tve",
304 .data = (ulong)&rk1000_tve_driver_data,
305 },
306 { }
307 };
308
309 U_BOOT_DRIVER(rk1000_tve) = {
310 .name = "rk1000_tve",
311 .id = UCLASS_VIDEO_BRIDGE,
312 .of_match = rk1000_tve_ids,
313 .ops = &rk1000_tve_ops,
314 .probe = rk1000_tve_probe,
315 .priv_auto_alloc_size = sizeof(struct rk1000_tve),
316 };
317