1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (C) 2023 Loongson Technology Corporation Limited
4  */
5 
6 #include <linux/delay.h>
7 
8 #include <drm/drm_atomic_helper.h>
9 #include <drm/drm_debugfs.h>
10 #include <drm/drm_edid.h>
11 #include <drm/drm_probe_helper.h>
12 
13 #include "lsdc_drv.h"
14 #include "lsdc_output.h"
15 
16 /*
17  * The display controller in LS7A2000 has two display pipes
18  * Display pipe 0 is attached with a built-in transparent VGA encoder and
19  * a built-in HDMI encoder.
20  * Display pipe 1 has only one built-in HDMI encoder connected.
21  *       ______________________                          _____________
22  *      |             +-----+  |                        |             |
23  *      | CRTC0 -+--> | VGA |  ----> VGA Connector ---> | VGA Monitor |<---+
24  *      |        |    +-----+  |                        |_____________|    |
25  *      |        |             |                         ______________    |
26  *      |        |    +------+ |                        |              |   |
27  *      |        +--> | HDMI | ----> HDMI Connector --> | HDMI Monitor |<--+
28  *      |             +------+ |                        |______________|   |
29  *      |            +------+  |                                           |
30  *      |            | i2c6 |  <-------------------------------------------+
31  *      |            +------+  |
32  *      |                      |
33  *      |    DC in LS7A2000    |
34  *      |                      |
35  *      |            +------+  |
36  *      |            | i2c7 |  <--------------------------------+
37  *      |            +------+  |                                |
38  *      |                      |                          ______|_______
39  *      |            +------+  |                         |              |
40  *      | CRTC1 ---> | HDMI |  ----> HDMI Connector ---> | HDMI Monitor |
41  *      |            +------+  |                         |______________|
42  *      |______________________|
43  */
44 
45 static int ls7a2000_connector_get_modes(struct drm_connector *connector)
46 {
47 	unsigned int num = 0;
48 	struct edid *edid;
49 
50 	if (connector->ddc) {
51 		edid = drm_get_edid(connector, connector->ddc);
52 		if (edid) {
53 			drm_connector_update_edid_property(connector, edid);
54 			num = drm_add_edid_modes(connector, edid);
55 			kfree(edid);
56 		}
57 
58 		return num;
59 	}
60 
61 	num = drm_add_modes_noedid(connector, 1920, 1200);
62 
63 	drm_set_preferred_mode(connector, 1024, 768);
64 
65 	return num;
66 }
67 
68 static struct drm_encoder *
69 ls7a2000_connector_get_best_encoder(struct drm_connector *connector,
70 				    struct drm_atomic_state *state)
71 {
72 	struct lsdc_output *output = connector_to_lsdc_output(connector);
73 
74 	return &output->encoder;
75 }
76 
77 static const struct drm_connector_helper_funcs ls7a2000_connector_helpers = {
78 	.atomic_best_encoder = ls7a2000_connector_get_best_encoder,
79 	.get_modes = ls7a2000_connector_get_modes,
80 };
81 
82 /* debugfs */
83 
84 #define LSDC_HDMI_REG(i, reg) {                               \
85 	.name = __stringify_1(LSDC_HDMI##i##_##reg##_REG),    \
86 	.offset = LSDC_HDMI##i##_##reg##_REG,                 \
87 }
88 
89 static const struct lsdc_reg32 ls7a2000_hdmi0_encoder_regs[] = {
90 	LSDC_HDMI_REG(0, ZONE),
91 	LSDC_HDMI_REG(0, INTF_CTRL),
92 	LSDC_HDMI_REG(0, PHY_CTRL),
93 	LSDC_HDMI_REG(0, PHY_PLL),
94 	LSDC_HDMI_REG(0, AVI_INFO_CRTL),
95 	LSDC_HDMI_REG(0, PHY_CAL),
96 	LSDC_HDMI_REG(0, AUDIO_PLL_LO),
97 	LSDC_HDMI_REG(0, AUDIO_PLL_HI),
98 	{NULL, 0},  /* MUST be {NULL, 0} terminated */
99 };
100 
101 static const struct lsdc_reg32 ls7a2000_hdmi1_encoder_regs[] = {
102 	LSDC_HDMI_REG(1, ZONE),
103 	LSDC_HDMI_REG(1, INTF_CTRL),
104 	LSDC_HDMI_REG(1, PHY_CTRL),
105 	LSDC_HDMI_REG(1, PHY_PLL),
106 	LSDC_HDMI_REG(1, AVI_INFO_CRTL),
107 	LSDC_HDMI_REG(1, PHY_CAL),
108 	LSDC_HDMI_REG(1, AUDIO_PLL_LO),
109 	LSDC_HDMI_REG(1, AUDIO_PLL_HI),
110 	{NULL, 0},  /* MUST be {NULL, 0} terminated */
111 };
112 
113 static int ls7a2000_hdmi_encoder_regs_show(struct seq_file *m, void *data)
114 {
115 	struct drm_info_node *node = (struct drm_info_node *)m->private;
116 	struct drm_device *ddev = node->minor->dev;
117 	struct lsdc_device *ldev = to_lsdc(ddev);
118 	const struct lsdc_reg32 *preg;
119 
120 	preg = (const struct lsdc_reg32 *)node->info_ent->data;
121 
122 	while (preg->name) {
123 		u32 offset = preg->offset;
124 
125 		seq_printf(m, "%s (0x%04x): 0x%08x\n",
126 			   preg->name, offset, lsdc_rreg32(ldev, offset));
127 		++preg;
128 	}
129 
130 	return 0;
131 }
132 
133 static const struct drm_info_list ls7a2000_hdmi0_debugfs_files[] = {
134 	{ "regs", ls7a2000_hdmi_encoder_regs_show, 0, (void *)ls7a2000_hdmi0_encoder_regs },
135 };
136 
137 static const struct drm_info_list ls7a2000_hdmi1_debugfs_files[] = {
138 	{ "regs", ls7a2000_hdmi_encoder_regs_show, 0, (void *)ls7a2000_hdmi1_encoder_regs },
139 };
140 
141 static void ls7a2000_hdmi0_late_register(struct drm_connector *connector,
142 					 struct dentry *root)
143 {
144 	struct drm_device *ddev = connector->dev;
145 	struct drm_minor *minor = ddev->primary;
146 
147 	drm_debugfs_create_files(ls7a2000_hdmi0_debugfs_files,
148 				 ARRAY_SIZE(ls7a2000_hdmi0_debugfs_files),
149 				 root, minor);
150 }
151 
152 static void ls7a2000_hdmi1_late_register(struct drm_connector *connector,
153 					 struct dentry *root)
154 {
155 	struct drm_device *ddev = connector->dev;
156 	struct drm_minor *minor = ddev->primary;
157 
158 	drm_debugfs_create_files(ls7a2000_hdmi1_debugfs_files,
159 				 ARRAY_SIZE(ls7a2000_hdmi1_debugfs_files),
160 				 root, minor);
161 }
162 
163 /* monitor present detection */
164 
165 static enum drm_connector_status
166 ls7a2000_hdmi0_vga_connector_detect(struct drm_connector *connector, bool force)
167 {
168 	struct drm_device *ddev = connector->dev;
169 	struct lsdc_device *ldev = to_lsdc(ddev);
170 	u32 val;
171 
172 	val = lsdc_rreg32(ldev, LSDC_HDMI_HPD_STATUS_REG);
173 
174 	if (val & HDMI0_HPD_FLAG)
175 		return connector_status_connected;
176 
177 	if (connector->ddc) {
178 		if (drm_probe_ddc(connector->ddc))
179 			return connector_status_connected;
180 
181 		return connector_status_disconnected;
182 	}
183 
184 	return connector_status_unknown;
185 }
186 
187 static enum drm_connector_status
188 ls7a2000_hdmi1_connector_detect(struct drm_connector *connector, bool force)
189 {
190 	struct lsdc_device *ldev = to_lsdc(connector->dev);
191 	u32 val;
192 
193 	val = lsdc_rreg32(ldev, LSDC_HDMI_HPD_STATUS_REG);
194 
195 	if (val & HDMI1_HPD_FLAG)
196 		return connector_status_connected;
197 
198 	return connector_status_disconnected;
199 }
200 
201 static const struct drm_connector_funcs ls7a2000_hdmi_connector_funcs[2] = {
202 	{
203 		.detect = ls7a2000_hdmi0_vga_connector_detect,
204 		.fill_modes = drm_helper_probe_single_connector_modes,
205 		.destroy = drm_connector_cleanup,
206 		.reset = drm_atomic_helper_connector_reset,
207 		.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
208 		.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
209 		.debugfs_init = ls7a2000_hdmi0_late_register,
210 	},
211 	{
212 		.detect = ls7a2000_hdmi1_connector_detect,
213 		.fill_modes = drm_helper_probe_single_connector_modes,
214 		.destroy = drm_connector_cleanup,
215 		.reset = drm_atomic_helper_connector_reset,
216 		.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
217 		.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
218 		.debugfs_init = ls7a2000_hdmi1_late_register,
219 	},
220 };
221 
222 /* Even though some board has only one hdmi on display pipe 1,
223  * We still need hook lsdc_encoder_funcs up on display pipe 0,
224  * This is because we need its reset() callback get called, to
225  * set the LSDC_HDMIx_CTRL_REG using software gpio emulated i2c.
226  * Otherwise, the firmware may set LSDC_HDMIx_CTRL_REG blindly.
227  */
228 static void ls7a2000_hdmi0_encoder_reset(struct drm_encoder *encoder)
229 {
230 	struct drm_device *ddev = encoder->dev;
231 	struct lsdc_device *ldev = to_lsdc(ddev);
232 	u32 val;
233 
234 	val = PHY_CLOCK_POL | PHY_CLOCK_EN | PHY_DATA_EN;
235 	lsdc_wreg32(ldev, LSDC_CRTC0_DVO_CONF_REG, val);
236 
237 	/* using software gpio emulated i2c */
238 	val = lsdc_rreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG);
239 	val &= ~HW_I2C_EN;
240 	lsdc_wreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, val);
241 
242 	/* help the hdmi phy to get out of reset state */
243 	lsdc_wreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, HDMI_PHY_RESET_N);
244 
245 	mdelay(20);
246 
247 	drm_dbg(ddev, "HDMI-0 Reset\n");
248 }
249 
250 static void ls7a2000_hdmi1_encoder_reset(struct drm_encoder *encoder)
251 {
252 	struct drm_device *ddev = encoder->dev;
253 	struct lsdc_device *ldev = to_lsdc(ddev);
254 	u32 val;
255 
256 	val = PHY_CLOCK_POL | PHY_CLOCK_EN | PHY_DATA_EN;
257 	lsdc_wreg32(ldev, LSDC_CRTC1_DVO_CONF_REG, val);
258 
259 	/* using software gpio emulated i2c */
260 	val = lsdc_rreg32(ldev, LSDC_HDMI1_INTF_CTRL_REG);
261 	val &= ~HW_I2C_EN;
262 	lsdc_wreg32(ldev, LSDC_HDMI1_INTF_CTRL_REG, val);
263 
264 	/*  help the hdmi phy to get out of reset state */
265 	lsdc_wreg32(ldev, LSDC_HDMI1_PHY_CTRL_REG, HDMI_PHY_RESET_N);
266 
267 	mdelay(20);
268 
269 	drm_dbg(ddev, "HDMI-1 Reset\n");
270 }
271 
272 static const struct drm_encoder_funcs ls7a2000_encoder_funcs[2] = {
273 	{
274 		.reset = ls7a2000_hdmi0_encoder_reset,
275 		.destroy = drm_encoder_cleanup,
276 	},
277 	{
278 		.reset = ls7a2000_hdmi1_encoder_reset,
279 		.destroy = drm_encoder_cleanup,
280 	},
281 };
282 
283 static int ls7a2000_hdmi_set_avi_infoframe(struct drm_encoder *encoder,
284 					   struct drm_display_mode *mode)
285 {
286 	struct lsdc_output *output = encoder_to_lsdc_output(encoder);
287 	struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
288 	unsigned int index = dispipe->index;
289 	struct drm_device *ddev = encoder->dev;
290 	struct lsdc_device *ldev = to_lsdc(ddev);
291 	struct hdmi_avi_infoframe infoframe;
292 	u8 buffer[HDMI_INFOFRAME_SIZE(AVI)];
293 	unsigned char *ptr = &buffer[HDMI_INFOFRAME_HEADER_SIZE];
294 	unsigned int content0, content1, content2, content3;
295 	int err;
296 
297 	err = drm_hdmi_avi_infoframe_from_display_mode(&infoframe,
298 						       &output->connector,
299 						       mode);
300 	if (err < 0) {
301 		drm_err(ddev, "failed to setup AVI infoframe: %d\n", err);
302 		return err;
303 	}
304 
305 	/* Fixed infoframe configuration not linked to the mode */
306 	infoframe.colorspace = HDMI_COLORSPACE_RGB;
307 	infoframe.quantization_range = HDMI_QUANTIZATION_RANGE_DEFAULT;
308 	infoframe.colorimetry = HDMI_COLORIMETRY_NONE;
309 
310 	err = hdmi_avi_infoframe_pack(&infoframe, buffer, sizeof(buffer));
311 	if (err < 0) {
312 		drm_err(ddev, "failed to pack AVI infoframe: %d\n", err);
313 			return err;
314 	}
315 
316 	content0 = *(unsigned int *)ptr;
317 	content1 = *(ptr + 4);
318 	content2 = *(unsigned int *)(ptr + 5);
319 	content3 = *(unsigned int *)(ptr + 9);
320 
321 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT0, index, content0);
322 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT1, index, content1);
323 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT2, index, content2);
324 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_CONTENT3, index, content3);
325 
326 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_AVI_INFO_CRTL_REG, index,
327 			 AVI_PKT_ENABLE | AVI_PKT_UPDATE);
328 
329 	drm_dbg(ddev, "Update HDMI-%u avi infoframe\n", index);
330 
331 	return 0;
332 }
333 
334 static void ls7a2000_hdmi_atomic_disable(struct drm_encoder *encoder,
335 					 struct drm_atomic_state *state)
336 {
337 	struct lsdc_output *output = encoder_to_lsdc_output(encoder);
338 	struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
339 	unsigned int index = dispipe->index;
340 	struct drm_device *ddev = encoder->dev;
341 	struct lsdc_device *ldev = to_lsdc(ddev);
342 	u32 val;
343 
344 	/* Disable the hdmi phy */
345 	val = lsdc_pipe_rreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, index);
346 	val &= ~HDMI_PHY_EN;
347 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, index, val);
348 
349 	/* Disable the hdmi interface */
350 	val = lsdc_pipe_rreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, index);
351 	val &= ~HDMI_INTERFACE_EN;
352 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, index, val);
353 
354 	drm_dbg(ddev, "HDMI-%u disabled\n", index);
355 }
356 
357 static void ls7a2000_hdmi_atomic_enable(struct drm_encoder *encoder,
358 					struct drm_atomic_state *state)
359 {
360 	struct drm_device *ddev = encoder->dev;
361 	struct lsdc_device *ldev = to_lsdc(ddev);
362 	struct lsdc_output *output = encoder_to_lsdc_output(encoder);
363 	struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
364 	unsigned int index = dispipe->index;
365 	u32 val;
366 
367 	/* datasheet say it should larger than 48 */
368 	val = 64 << HDMI_H_ZONE_IDLE_SHIFT | 64 << HDMI_V_ZONE_IDLE_SHIFT;
369 
370 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_ZONE_REG, index, val);
371 
372 	val = HDMI_PHY_TERM_STATUS |
373 	      HDMI_PHY_TERM_DET_EN |
374 	      HDMI_PHY_TERM_H_EN |
375 	      HDMI_PHY_TERM_L_EN |
376 	      HDMI_PHY_RESET_N |
377 	      HDMI_PHY_EN;
378 
379 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_CTRL_REG, index, val);
380 
381 	udelay(2);
382 
383 	val = HDMI_CTL_PERIOD_MODE |
384 	      HDMI_AUDIO_EN |
385 	      HDMI_PACKET_EN |
386 	      HDMI_INTERFACE_EN |
387 	      (8 << HDMI_VIDEO_PREAMBLE_SHIFT);
388 
389 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_INTF_CTRL_REG, index, val);
390 
391 	drm_dbg(ddev, "HDMI-%u enabled\n", index);
392 }
393 
394 /*
395  *  Fout = M * Fin
396  *
397  *  M = (4 * LF) / (IDF * ODF)
398  *
399  *  IDF: Input Division Factor
400  *  ODF: Output Division Factor
401  *   LF: Loop Factor
402  *    M: Required Mult
403  *
404  *  +--------------------------------------------------------+
405  *  |     Fin (kHZ)     | M  | IDF | LF | ODF |   Fout(Mhz)  |
406  *  |-------------------+----+-----+----+-----+--------------|
407  *  |  170000 ~ 340000  | 10 | 16  | 40 |  1  | 1700 ~ 3400  |
408  *  |   85000 ~ 170000  | 10 |  8  | 40 |  2  |  850 ~ 1700  |
409  *  |   42500 ~  85000  | 10 |  4  | 40 |  4  |  425 ~ 850   |
410  *  |   21250 ~  42500  | 10 |  2  | 40 |  8  | 212.5 ~ 425  |
411  *  |   20000 ~  21250  | 10 |  1  | 40 | 16  |  200 ~ 212.5 |
412  *  +--------------------------------------------------------+
413  */
414 static void ls7a2000_hdmi_phy_pll_config(struct lsdc_device *ldev,
415 					 int fin,
416 					 unsigned int index)
417 {
418 	struct drm_device *ddev = &ldev->base;
419 	int count = 0;
420 	u32 val;
421 
422 	/* Firstly, disable phy pll */
423 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index, 0x0);
424 
425 	/*
426 	 * Most of time, loongson HDMI require M = 10
427 	 * for example, 10 = (4 * 40) / (8 * 2)
428 	 * here, write "1" to the ODF will get "2"
429 	 */
430 
431 	if (fin >= 170000)
432 		val = (16 << HDMI_PLL_IDF_SHIFT) |
433 		      (40 << HDMI_PLL_LF_SHIFT) |
434 		      (0 << HDMI_PLL_ODF_SHIFT);
435 	else if (fin >= 85000)
436 		val = (8 << HDMI_PLL_IDF_SHIFT) |
437 		      (40 << HDMI_PLL_LF_SHIFT) |
438 		      (1 << HDMI_PLL_ODF_SHIFT);
439 	else if (fin >= 42500)
440 		val = (4 << HDMI_PLL_IDF_SHIFT) |
441 		      (40 << HDMI_PLL_LF_SHIFT) |
442 		      (2 << HDMI_PLL_ODF_SHIFT);
443 	else if  (fin >= 21250)
444 		val = (2 << HDMI_PLL_IDF_SHIFT) |
445 		      (40 << HDMI_PLL_LF_SHIFT) |
446 		      (3 << HDMI_PLL_ODF_SHIFT);
447 	else
448 		val = (1 << HDMI_PLL_IDF_SHIFT) |
449 		      (40 << HDMI_PLL_LF_SHIFT) |
450 		      (4 << HDMI_PLL_ODF_SHIFT);
451 
452 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index, val);
453 
454 	val |= HDMI_PLL_ENABLE;
455 
456 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index, val);
457 
458 	udelay(2);
459 
460 	drm_dbg(ddev, "Fin of HDMI-%u: %d kHz\n", index, fin);
461 
462 	/* Wait hdmi phy pll lock */
463 	do {
464 		val = lsdc_pipe_rreg32(ldev, LSDC_HDMI0_PHY_PLL_REG, index);
465 
466 		if (val & HDMI_PLL_LOCKED) {
467 			drm_dbg(ddev, "Setting HDMI-%u PLL take %d cycles\n",
468 				index, count);
469 			break;
470 		}
471 		++count;
472 	} while (count < 1000);
473 
474 	lsdc_pipe_wreg32(ldev, LSDC_HDMI0_PHY_CAL_REG, index, 0x0f000ff0);
475 
476 	if (count >= 1000)
477 		drm_err(ddev, "Setting HDMI-%u PLL failed\n", index);
478 }
479 
480 static void ls7a2000_hdmi_atomic_mode_set(struct drm_encoder *encoder,
481 					  struct drm_crtc_state *crtc_state,
482 					  struct drm_connector_state *conn_state)
483 {
484 	struct lsdc_output *output = encoder_to_lsdc_output(encoder);
485 	struct lsdc_display_pipe *dispipe = output_to_display_pipe(output);
486 	unsigned int index = dispipe->index;
487 	struct drm_device *ddev = encoder->dev;
488 	struct lsdc_device *ldev = to_lsdc(ddev);
489 	struct drm_display_mode *mode = &crtc_state->mode;
490 
491 	ls7a2000_hdmi_phy_pll_config(ldev, mode->clock, index);
492 
493 	ls7a2000_hdmi_set_avi_infoframe(encoder, mode);
494 
495 	drm_dbg(ddev, "%s modeset finished\n", encoder->name);
496 }
497 
498 static const struct drm_encoder_helper_funcs ls7a2000_encoder_helper_funcs = {
499 	.atomic_disable = ls7a2000_hdmi_atomic_disable,
500 	.atomic_enable = ls7a2000_hdmi_atomic_enable,
501 	.atomic_mode_set = ls7a2000_hdmi_atomic_mode_set,
502 };
503 
504 /*
505  * For LS7A2000:
506  *
507  * 1) Most of board export one vga + hdmi output interface.
508  * 2) Yet, Some boards export double hdmi output interface.
509  * 3) Still have boards export three output(2 hdmi + 1 vga).
510  *
511  * So let's hook hdmi helper funcs to all display pipe, don't miss.
512  * writing hdmi register do no harms.
513  */
514 int ls7a2000_output_init(struct drm_device *ddev,
515 			 struct lsdc_display_pipe *dispipe,
516 			 struct i2c_adapter *ddc,
517 			 unsigned int pipe)
518 {
519 	struct lsdc_output *output = &dispipe->output;
520 	struct drm_encoder *encoder = &output->encoder;
521 	struct drm_connector *connector = &output->connector;
522 	int ret;
523 
524 	ret = drm_encoder_init(ddev, encoder, &ls7a2000_encoder_funcs[pipe],
525 			       DRM_MODE_ENCODER_TMDS, "encoder-%u", pipe);
526 	if (ret)
527 		return ret;
528 
529 	encoder->possible_crtcs = BIT(pipe);
530 
531 	drm_encoder_helper_add(encoder, &ls7a2000_encoder_helper_funcs);
532 
533 	ret = drm_connector_init_with_ddc(ddev, connector,
534 					  &ls7a2000_hdmi_connector_funcs[pipe],
535 					  DRM_MODE_CONNECTOR_HDMIA, ddc);
536 	if (ret)
537 		return ret;
538 
539 	drm_info(ddev, "display pipe-%u has HDMI %s\n", pipe, pipe ? "" : "and/or VGA");
540 
541 	drm_connector_helper_add(connector, &ls7a2000_connector_helpers);
542 
543 	drm_connector_attach_encoder(connector, encoder);
544 
545 	connector->polled = DRM_CONNECTOR_POLL_CONNECT |
546 			    DRM_CONNECTOR_POLL_DISCONNECT;
547 
548 	connector->interlace_allowed = 0;
549 	connector->doublescan_allowed = 0;
550 
551 	return 0;
552 }
553