1 // SPDX-License-Identifier: MIT
2 
3 #include <drm/drm_device.h>
4 
5 #include "radeon.h"
6 
7 /*
8  * Integrated TV out support based on the GATOS code by
9  * Federico Ulivi <fulivi@lycos.com>
10  */
11 
12 
13 /*
14  * Limits of h/v positions (hPos & vPos)
15  */
16 #define MAX_H_POSITION 5 /* Range: [-5..5], negative is on the left, 0 is default, positive is on the right */
17 #define MAX_V_POSITION 5 /* Range: [-5..5], negative is up, 0 is default, positive is down */
18 
19 /*
20  * Unit for hPos (in TV clock periods)
21  */
22 #define H_POS_UNIT 10
23 
24 /*
25  * Indexes in h. code timing table for horizontal line position adjustment
26  */
27 #define H_TABLE_POS1 6
28 #define H_TABLE_POS2 8
29 
30 /*
31  * Limits of hor. size (hSize)
32  */
33 #define MAX_H_SIZE 5 /* Range: [-5..5], negative is smaller, positive is larger */
34 
35 /* tv standard constants */
36 #define NTSC_TV_CLOCK_T 233
37 #define NTSC_TV_VFTOTAL 1
38 #define NTSC_TV_LINES_PER_FRAME 525
39 #define NTSC_TV_ZERO_H_SIZE 479166
40 #define NTSC_TV_H_SIZE_UNIT 9478
41 
42 #define PAL_TV_CLOCK_T 188
43 #define PAL_TV_VFTOTAL 3
44 #define PAL_TV_LINES_PER_FRAME 625
45 #define PAL_TV_ZERO_H_SIZE 473200
46 #define PAL_TV_H_SIZE_UNIT 9360
47 
48 /* tv pll setting for 27 mhz ref clk */
49 #define NTSC_TV_PLL_M_27 22
50 #define NTSC_TV_PLL_N_27 175
51 #define NTSC_TV_PLL_P_27 5
52 
53 #define PAL_TV_PLL_M_27 113
54 #define PAL_TV_PLL_N_27 668
55 #define PAL_TV_PLL_P_27 3
56 
57 /* tv pll setting for 14 mhz ref clk */
58 #define NTSC_TV_PLL_M_14 33
59 #define NTSC_TV_PLL_N_14 693
60 #define NTSC_TV_PLL_P_14 7
61 
62 #define PAL_TV_PLL_M_14 19
63 #define PAL_TV_PLL_N_14 353
64 #define PAL_TV_PLL_P_14 5
65 
66 #define VERT_LEAD_IN_LINES 2
67 #define FRAC_BITS 0xe
68 #define FRAC_MASK 0x3fff
69 
70 struct radeon_tv_mode_constants {
71 	uint16_t hor_resolution;
72 	uint16_t ver_resolution;
73 	enum radeon_tv_std standard;
74 	uint16_t hor_total;
75 	uint16_t ver_total;
76 	uint16_t hor_start;
77 	uint16_t hor_syncstart;
78 	uint16_t ver_syncstart;
79 	unsigned def_restart;
80 	uint16_t crtcPLL_N;
81 	uint8_t  crtcPLL_M;
82 	uint8_t  crtcPLL_post_div;
83 	unsigned pix_to_tv;
84 };
85 
86 static const uint16_t hor_timing_NTSC[MAX_H_CODE_TIMING_LEN] = {
87 	0x0007,
88 	0x003f,
89 	0x0263,
90 	0x0a24,
91 	0x2a6b,
92 	0x0a36,
93 	0x126d, /* H_TABLE_POS1 */
94 	0x1bfe,
95 	0x1a8f, /* H_TABLE_POS2 */
96 	0x1ec7,
97 	0x3863,
98 	0x1bfe,
99 	0x1bfe,
100 	0x1a2a,
101 	0x1e95,
102 	0x0e31,
103 	0x201b,
104 	0
105 };
106 
107 static const uint16_t vert_timing_NTSC[MAX_V_CODE_TIMING_LEN] = {
108 	0x2001,
109 	0x200d,
110 	0x1006,
111 	0x0c06,
112 	0x1006,
113 	0x1818,
114 	0x21e3,
115 	0x1006,
116 	0x0c06,
117 	0x1006,
118 	0x1817,
119 	0x21d4,
120 	0x0002,
121 	0
122 };
123 
124 static const uint16_t hor_timing_PAL[MAX_H_CODE_TIMING_LEN] = {
125 	0x0007,
126 	0x0058,
127 	0x027c,
128 	0x0a31,
129 	0x2a77,
130 	0x0a95,
131 	0x124f, /* H_TABLE_POS1 */
132 	0x1bfe,
133 	0x1b22, /* H_TABLE_POS2 */
134 	0x1ef9,
135 	0x387c,
136 	0x1bfe,
137 	0x1bfe,
138 	0x1b31,
139 	0x1eb5,
140 	0x0e43,
141 	0x201b,
142 	0
143 };
144 
145 static const uint16_t vert_timing_PAL[MAX_V_CODE_TIMING_LEN] = {
146 	0x2001,
147 	0x200c,
148 	0x1005,
149 	0x0c05,
150 	0x1005,
151 	0x1401,
152 	0x1821,
153 	0x2240,
154 	0x1005,
155 	0x0c05,
156 	0x1005,
157 	0x1401,
158 	0x1822,
159 	0x2230,
160 	0x0002,
161 	0
162 };
163 
164 /**********************************************************************
165  *
166  * availableModes
167  *
168  * Table of all allowed modes for tv output
169  *
170  **********************************************************************/
171 static const struct radeon_tv_mode_constants available_tv_modes[] = {
172 	{   /* NTSC timing for 27 Mhz ref clk */
173 		800,                /* horResolution */
174 		600,                /* verResolution */
175 		TV_STD_NTSC,        /* standard */
176 		990,                /* horTotal */
177 		740,                /* verTotal */
178 		813,                /* horStart */
179 		824,                /* horSyncStart */
180 		632,                /* verSyncStart */
181 		625592,             /* defRestart */
182 		592,                /* crtcPLL_N */
183 		91,                 /* crtcPLL_M */
184 		4,                  /* crtcPLL_postDiv */
185 		1022,               /* pixToTV */
186 	},
187 	{   /* PAL timing for 27 Mhz ref clk */
188 		800,               /* horResolution */
189 		600,               /* verResolution */
190 		TV_STD_PAL,        /* standard */
191 		1144,              /* horTotal */
192 		706,               /* verTotal */
193 		812,               /* horStart */
194 		824,               /* horSyncStart */
195 		669,               /* verSyncStart */
196 		696700,            /* defRestart */
197 		1382,              /* crtcPLL_N */
198 		231,               /* crtcPLL_M */
199 		4,                 /* crtcPLL_postDiv */
200 		759,               /* pixToTV */
201 	},
202 	{   /* NTSC timing for 14 Mhz ref clk */
203 		800,                /* horResolution */
204 		600,                /* verResolution */
205 		TV_STD_NTSC,        /* standard */
206 		1018,               /* horTotal */
207 		727,                /* verTotal */
208 		813,                /* horStart */
209 		840,                /* horSyncStart */
210 		633,                /* verSyncStart */
211 		630627,             /* defRestart */
212 		347,                /* crtcPLL_N */
213 		14,                 /* crtcPLL_M */
214 		8,                  /* crtcPLL_postDiv */
215 		1022,               /* pixToTV */
216 	},
217 	{ /* PAL timing for 14 Mhz ref clk */
218 		800,                /* horResolution */
219 		600,                /* verResolution */
220 		TV_STD_PAL,         /* standard */
221 		1131,               /* horTotal */
222 		742,                /* verTotal */
223 		813,                /* horStart */
224 		840,                /* horSyncStart */
225 		633,                /* verSyncStart */
226 		708369,             /* defRestart */
227 		211,                /* crtcPLL_N */
228 		9,                  /* crtcPLL_M */
229 		8,                  /* crtcPLL_postDiv */
230 		759,                /* pixToTV */
231 	},
232 };
233 
234 #define N_AVAILABLE_MODES ARRAY_SIZE(available_tv_modes)
235 
236 static const struct radeon_tv_mode_constants *radeon_legacy_tv_get_std_mode(struct radeon_encoder *radeon_encoder,
237 									    uint16_t *pll_ref_freq)
238 {
239 	struct drm_device *dev = radeon_encoder->base.dev;
240 	struct radeon_device *rdev = dev->dev_private;
241 	struct radeon_crtc *radeon_crtc;
242 	struct radeon_encoder_tv_dac *tv_dac = radeon_encoder->enc_priv;
243 	const struct radeon_tv_mode_constants *const_ptr;
244 	struct radeon_pll *pll;
245 
246 	radeon_crtc = to_radeon_crtc(radeon_encoder->base.crtc);
247 	if (radeon_crtc->crtc_id == 1)
248 		pll = &rdev->clock.p2pll;
249 	else
250 		pll = &rdev->clock.p1pll;
251 
252 	if (pll_ref_freq)
253 		*pll_ref_freq = pll->reference_freq;
254 
255 	if (tv_dac->tv_std == TV_STD_NTSC ||
256 	    tv_dac->tv_std == TV_STD_NTSC_J ||
257 	    tv_dac->tv_std == TV_STD_PAL_M) {
258 		if (pll->reference_freq == 2700)
259 			const_ptr = &available_tv_modes[0];
260 		else
261 			const_ptr = &available_tv_modes[2];
262 	} else {
263 		if (pll->reference_freq == 2700)
264 			const_ptr = &available_tv_modes[1];
265 		else
266 			const_ptr = &available_tv_modes[3];
267 	}
268 	return const_ptr;
269 }
270 
271 static long YCOEF_value[5] = { 2, 2, 0, 4, 0 };
272 static long YCOEF_EN_value[5] = { 1, 1, 0, 1, 0 };
273 static long SLOPE_value[5] = { 1, 2, 2, 4, 8 };
274 static long SLOPE_limit[5] = { 6, 5, 4, 3, 2 };
275 
276 static void radeon_wait_pll_lock(struct drm_encoder *encoder, unsigned n_tests,
277 				 unsigned n_wait_loops, unsigned cnt_threshold)
278 {
279 	struct drm_device *dev = encoder->dev;
280 	struct radeon_device *rdev = dev->dev_private;
281 	uint32_t save_pll_test;
282 	unsigned int i, j;
283 
284 	WREG32(RADEON_TEST_DEBUG_MUX, (RREG32(RADEON_TEST_DEBUG_MUX) & 0xffff60ff) | 0x100);
285 	save_pll_test = RREG32_PLL(RADEON_PLL_TEST_CNTL);
286 	WREG32_PLL(RADEON_PLL_TEST_CNTL, save_pll_test & ~RADEON_PLL_MASK_READ_B);
287 
288 	WREG8(RADEON_CLOCK_CNTL_INDEX, RADEON_PLL_TEST_CNTL);
289 	for (i = 0; i < n_tests; i++) {
290 		WREG8(RADEON_CLOCK_CNTL_DATA + 3, 0);
291 		for (j = 0; j < n_wait_loops; j++)
292 			if (RREG8(RADEON_CLOCK_CNTL_DATA + 3) >= cnt_threshold)
293 				break;
294 	}
295 	WREG32_PLL(RADEON_PLL_TEST_CNTL, save_pll_test);
296 	WREG32(RADEON_TEST_DEBUG_MUX, RREG32(RADEON_TEST_DEBUG_MUX) & 0xffffe0ff);
297 }
298 
299 
300 static void radeon_legacy_tv_write_fifo(struct radeon_encoder *radeon_encoder,
301 					uint16_t addr, uint32_t value)
302 {
303 	struct drm_device *dev = radeon_encoder->base.dev;
304 	struct radeon_device *rdev = dev->dev_private;
305 	uint32_t tmp;
306 	int i = 0;
307 
308 	WREG32(RADEON_TV_HOST_WRITE_DATA, value);
309 
310 	WREG32(RADEON_TV_HOST_RD_WT_CNTL, addr);
311 	WREG32(RADEON_TV_HOST_RD_WT_CNTL, addr | RADEON_HOST_FIFO_WT);
312 
313 	do {
314 		tmp = RREG32(RADEON_TV_HOST_RD_WT_CNTL);
315 		if ((tmp & RADEON_HOST_FIFO_WT_ACK) == 0)
316 			break;
317 		i++;
318 	} while (i < 10000);
319 	WREG32(RADEON_TV_HOST_RD_WT_CNTL, 0);
320 }
321 
322 #if 0 /* included for completeness */
323 static uint32_t radeon_legacy_tv_read_fifo(struct radeon_encoder *radeon_encoder, uint16_t addr)
324 {
325 	struct drm_device *dev = radeon_encoder->base.dev;
326 	struct radeon_device *rdev = dev->dev_private;
327 	uint32_t tmp;
328 	int i = 0;
329 
330 	WREG32(RADEON_TV_HOST_RD_WT_CNTL, addr);
331 	WREG32(RADEON_TV_HOST_RD_WT_CNTL, addr | RADEON_HOST_FIFO_RD);
332 
333 	do {
334 		tmp = RREG32(RADEON_TV_HOST_RD_WT_CNTL);
335 		if ((tmp & RADEON_HOST_FIFO_RD_ACK) == 0)
336 			break;
337 		i++;
338 	} while (i < 10000);
339 	WREG32(RADEON_TV_HOST_RD_WT_CNTL, 0);
340 	return RREG32(RADEON_TV_HOST_READ_DATA);
341 }
342 #endif
343 
344 static uint16_t radeon_get_htiming_tables_addr(uint32_t tv_uv_adr)
345 {
346 	uint16_t h_table;
347 
348 	switch ((tv_uv_adr & RADEON_HCODE_TABLE_SEL_MASK) >> RADEON_HCODE_TABLE_SEL_SHIFT) {
349 	case 0:
350 		h_table = RADEON_TV_MAX_FIFO_ADDR_INTERNAL;
351 		break;
352 	case 1:
353 		h_table = ((tv_uv_adr & RADEON_TABLE1_BOT_ADR_MASK) >> RADEON_TABLE1_BOT_ADR_SHIFT) * 2;
354 		break;
355 	case 2:
356 		h_table = ((tv_uv_adr & RADEON_TABLE3_TOP_ADR_MASK) >> RADEON_TABLE3_TOP_ADR_SHIFT) * 2;
357 		break;
358 	default:
359 		h_table = 0;
360 		break;
361 	}
362 	return h_table;
363 }
364 
365 static uint16_t radeon_get_vtiming_tables_addr(uint32_t tv_uv_adr)
366 {
367 	uint16_t v_table;
368 
369 	switch ((tv_uv_adr & RADEON_VCODE_TABLE_SEL_MASK) >> RADEON_VCODE_TABLE_SEL_SHIFT) {
370 	case 0:
371 		v_table = ((tv_uv_adr & RADEON_MAX_UV_ADR_MASK) >> RADEON_MAX_UV_ADR_SHIFT) * 2 + 1;
372 		break;
373 	case 1:
374 		v_table = ((tv_uv_adr & RADEON_TABLE1_BOT_ADR_MASK) >> RADEON_TABLE1_BOT_ADR_SHIFT) * 2 + 1;
375 		break;
376 	case 2:
377 		v_table = ((tv_uv_adr & RADEON_TABLE3_TOP_ADR_MASK) >> RADEON_TABLE3_TOP_ADR_SHIFT) * 2 + 1;
378 		break;
379 	default:
380 		v_table = 0;
381 		break;
382 	}
383 	return v_table;
384 }
385 
386 static void radeon_restore_tv_timing_tables(struct radeon_encoder *radeon_encoder)
387 {
388 	struct drm_device *dev = radeon_encoder->base.dev;
389 	struct radeon_device *rdev = dev->dev_private;
390 	struct radeon_encoder_tv_dac *tv_dac = radeon_encoder->enc_priv;
391 	uint16_t h_table, v_table;
392 	uint32_t tmp;
393 	int i;
394 
395 	WREG32(RADEON_TV_UV_ADR, tv_dac->tv.tv_uv_adr);
396 	h_table = radeon_get_htiming_tables_addr(tv_dac->tv.tv_uv_adr);
397 	v_table = radeon_get_vtiming_tables_addr(tv_dac->tv.tv_uv_adr);
398 
399 	for (i = 0; i < MAX_H_CODE_TIMING_LEN; i += 2, h_table--) {
400 		tmp = ((uint32_t)tv_dac->tv.h_code_timing[i] << 14) | ((uint32_t)tv_dac->tv.h_code_timing[i+1]);
401 		radeon_legacy_tv_write_fifo(radeon_encoder, h_table, tmp);
402 		if (tv_dac->tv.h_code_timing[i] == 0 || tv_dac->tv.h_code_timing[i + 1] == 0)
403 			break;
404 	}
405 	for (i = 0; i < MAX_V_CODE_TIMING_LEN; i += 2, v_table++) {
406 		tmp = ((uint32_t)tv_dac->tv.v_code_timing[i+1] << 14) | ((uint32_t)tv_dac->tv.v_code_timing[i]);
407 		radeon_legacy_tv_write_fifo(radeon_encoder, v_table, tmp);
408 		if (tv_dac->tv.v_code_timing[i] == 0 || tv_dac->tv.v_code_timing[i + 1] == 0)
409 			break;
410 	}
411 }
412 
413 static void radeon_legacy_write_tv_restarts(struct radeon_encoder *radeon_encoder)
414 {
415 	struct drm_device *dev = radeon_encoder->base.dev;
416 	struct radeon_device *rdev = dev->dev_private;
417 	struct radeon_encoder_tv_dac *tv_dac = radeon_encoder->enc_priv;
418 	WREG32(RADEON_TV_FRESTART, tv_dac->tv.frestart);
419 	WREG32(RADEON_TV_HRESTART, tv_dac->tv.hrestart);
420 	WREG32(RADEON_TV_VRESTART, tv_dac->tv.vrestart);
421 }
422 
423 static bool radeon_legacy_tv_init_restarts(struct drm_encoder *encoder)
424 {
425 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
426 	struct radeon_encoder_tv_dac *tv_dac = radeon_encoder->enc_priv;
427 	int restart;
428 	unsigned int h_total, v_total, f_total;
429 	int v_offset, h_offset;
430 	u16 p1, p2, h_inc;
431 	bool h_changed;
432 	const struct radeon_tv_mode_constants *const_ptr;
433 
434 	const_ptr = radeon_legacy_tv_get_std_mode(radeon_encoder, NULL);
435 	if (!const_ptr)
436 		return false;
437 
438 	h_total = const_ptr->hor_total;
439 	v_total = const_ptr->ver_total;
440 
441 	if (tv_dac->tv_std == TV_STD_NTSC ||
442 	    tv_dac->tv_std == TV_STD_NTSC_J ||
443 	    tv_dac->tv_std == TV_STD_PAL_M ||
444 	    tv_dac->tv_std == TV_STD_PAL_60)
445 		f_total = NTSC_TV_VFTOTAL + 1;
446 	else
447 		f_total = PAL_TV_VFTOTAL + 1;
448 
449 	/* adjust positions 1&2 in hor. cod timing table */
450 	h_offset = tv_dac->h_pos * H_POS_UNIT;
451 
452 	if (tv_dac->tv_std == TV_STD_NTSC ||
453 	    tv_dac->tv_std == TV_STD_NTSC_J ||
454 	    tv_dac->tv_std == TV_STD_PAL_M) {
455 		h_offset -= 50;
456 		p1 = hor_timing_NTSC[H_TABLE_POS1];
457 		p2 = hor_timing_NTSC[H_TABLE_POS2];
458 	} else {
459 		p1 = hor_timing_PAL[H_TABLE_POS1];
460 		p2 = hor_timing_PAL[H_TABLE_POS2];
461 	}
462 
463 	p1 = (u16)((int)p1 + h_offset);
464 	p2 = (u16)((int)p2 - h_offset);
465 
466 	h_changed = (p1 != tv_dac->tv.h_code_timing[H_TABLE_POS1] ||
467 		     p2 != tv_dac->tv.h_code_timing[H_TABLE_POS2]);
468 
469 	tv_dac->tv.h_code_timing[H_TABLE_POS1] = p1;
470 	tv_dac->tv.h_code_timing[H_TABLE_POS2] = p2;
471 
472 	/* Convert hOffset from n. of TV clock periods to n. of CRTC clock periods (CRTC pixels) */
473 	h_offset = (h_offset * (int)(const_ptr->pix_to_tv)) / 1000;
474 
475 	/* adjust restart */
476 	restart = const_ptr->def_restart;
477 
478 	/*
479 	 * convert v_pos TV lines to n. of CRTC pixels
480 	 */
481 	if (tv_dac->tv_std == TV_STD_NTSC ||
482 	    tv_dac->tv_std == TV_STD_NTSC_J ||
483 	    tv_dac->tv_std == TV_STD_PAL_M ||
484 	    tv_dac->tv_std == TV_STD_PAL_60)
485 		v_offset = ((int)(v_total * h_total) * 2 * tv_dac->v_pos) / (int)(NTSC_TV_LINES_PER_FRAME);
486 	else
487 		v_offset = ((int)(v_total * h_total) * 2 * tv_dac->v_pos) / (int)(PAL_TV_LINES_PER_FRAME);
488 
489 	restart -= v_offset + h_offset;
490 
491 	DRM_DEBUG_KMS("compute_restarts: def = %u h = %d v = %d, p1 = %04x, p2 = %04x, restart = %d\n",
492 		  const_ptr->def_restart, tv_dac->h_pos, tv_dac->v_pos, p1, p2, restart);
493 
494 	tv_dac->tv.hrestart = restart % h_total;
495 	restart /= h_total;
496 	tv_dac->tv.vrestart = restart % v_total;
497 	restart /= v_total;
498 	tv_dac->tv.frestart = restart % f_total;
499 
500 	DRM_DEBUG_KMS("compute_restart: F/H/V=%u,%u,%u\n",
501 		  (unsigned)tv_dac->tv.frestart,
502 		  (unsigned)tv_dac->tv.vrestart,
503 		  (unsigned)tv_dac->tv.hrestart);
504 
505 	/* compute h_inc from hsize */
506 	if (tv_dac->tv_std == TV_STD_NTSC ||
507 	    tv_dac->tv_std == TV_STD_NTSC_J ||
508 	    tv_dac->tv_std == TV_STD_PAL_M)
509 		h_inc = (u16)((int)(const_ptr->hor_resolution * 4096 * NTSC_TV_CLOCK_T) /
510 			      (tv_dac->h_size * (int)(NTSC_TV_H_SIZE_UNIT) + (int)(NTSC_TV_ZERO_H_SIZE)));
511 	else
512 		h_inc = (u16)((int)(const_ptr->hor_resolution * 4096 * PAL_TV_CLOCK_T) /
513 			      (tv_dac->h_size * (int)(PAL_TV_H_SIZE_UNIT) + (int)(PAL_TV_ZERO_H_SIZE)));
514 
515 	tv_dac->tv.timing_cntl = (tv_dac->tv.timing_cntl & ~RADEON_H_INC_MASK) |
516 		((u32)h_inc << RADEON_H_INC_SHIFT);
517 
518 	DRM_DEBUG_KMS("compute_restart: h_size = %d h_inc = %d\n", tv_dac->h_size, h_inc);
519 
520 	return h_changed;
521 }
522 
523 void radeon_legacy_tv_mode_set(struct drm_encoder *encoder,
524 			       struct drm_display_mode *mode,
525 			       struct drm_display_mode *adjusted_mode)
526 {
527 	struct drm_device *dev = encoder->dev;
528 	struct radeon_device *rdev = dev->dev_private;
529 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
530 	struct radeon_encoder_tv_dac *tv_dac = radeon_encoder->enc_priv;
531 	const struct radeon_tv_mode_constants *const_ptr;
532 	struct radeon_crtc *radeon_crtc;
533 	int i;
534 	uint16_t pll_ref_freq;
535 	uint32_t vert_space, flicker_removal, tmp;
536 	uint32_t tv_master_cntl, tv_rgb_cntl, tv_dac_cntl;
537 	uint32_t tv_modulator_cntl1, tv_modulator_cntl2;
538 	uint32_t tv_vscaler_cntl1, tv_vscaler_cntl2;
539 	uint32_t tv_pll_cntl, tv_ftotal;
540 	uint32_t tv_y_fall_cntl, tv_y_rise_cntl, tv_y_saw_tooth_cntl;
541 	uint32_t m, n, p;
542 	const uint16_t *hor_timing;
543 	const uint16_t *vert_timing;
544 
545 	const_ptr = radeon_legacy_tv_get_std_mode(radeon_encoder, &pll_ref_freq);
546 	if (!const_ptr)
547 		return;
548 
549 	radeon_crtc = to_radeon_crtc(encoder->crtc);
550 
551 	tv_master_cntl = (RADEON_VIN_ASYNC_RST |
552 			  RADEON_CRT_FIFO_CE_EN |
553 			  RADEON_TV_FIFO_CE_EN |
554 			  RADEON_TV_ON);
555 
556 	if (!ASIC_IS_R300(rdev))
557 		tv_master_cntl |= RADEON_TVCLK_ALWAYS_ONb;
558 
559 	if (tv_dac->tv_std == TV_STD_NTSC ||
560 	    tv_dac->tv_std == TV_STD_NTSC_J)
561 		tv_master_cntl |= RADEON_RESTART_PHASE_FIX;
562 
563 	tv_modulator_cntl1 = (RADEON_SLEW_RATE_LIMIT |
564 			      RADEON_SYNC_TIP_LEVEL |
565 			      RADEON_YFLT_EN |
566 			      RADEON_UVFLT_EN |
567 			      (6 << RADEON_CY_FILT_BLEND_SHIFT));
568 
569 	if (tv_dac->tv_std == TV_STD_NTSC ||
570 	    tv_dac->tv_std == TV_STD_NTSC_J) {
571 		tv_modulator_cntl1 |= (0x46 << RADEON_SET_UP_LEVEL_SHIFT) |
572 			(0x3b << RADEON_BLANK_LEVEL_SHIFT);
573 		tv_modulator_cntl2 = (-111 & RADEON_TV_U_BURST_LEVEL_MASK) |
574 			((0 & RADEON_TV_V_BURST_LEVEL_MASK) << RADEON_TV_V_BURST_LEVEL_SHIFT);
575 	} else if (tv_dac->tv_std == TV_STD_SCART_PAL) {
576 		tv_modulator_cntl1 |= RADEON_ALT_PHASE_EN;
577 		tv_modulator_cntl2 = (0 & RADEON_TV_U_BURST_LEVEL_MASK) |
578 			((0 & RADEON_TV_V_BURST_LEVEL_MASK) << RADEON_TV_V_BURST_LEVEL_SHIFT);
579 	} else {
580 		tv_modulator_cntl1 |= RADEON_ALT_PHASE_EN |
581 			(0x3b << RADEON_SET_UP_LEVEL_SHIFT) |
582 			(0x3b << RADEON_BLANK_LEVEL_SHIFT);
583 		tv_modulator_cntl2 = (-78 & RADEON_TV_U_BURST_LEVEL_MASK) |
584 			((62 & RADEON_TV_V_BURST_LEVEL_MASK) << RADEON_TV_V_BURST_LEVEL_SHIFT);
585 	}
586 
587 
588 	tv_rgb_cntl = (RADEON_RGB_DITHER_EN
589 		       | RADEON_TVOUT_SCALE_EN
590 		       | (0x0b << RADEON_UVRAM_READ_MARGIN_SHIFT)
591 		       | (0x07 << RADEON_FIFORAM_FFMACRO_READ_MARGIN_SHIFT)
592 		       | RADEON_RGB_ATTEN_SEL(0x3)
593 		       | RADEON_RGB_ATTEN_VAL(0xc));
594 
595 	if (radeon_crtc->crtc_id == 1)
596 		tv_rgb_cntl |= RADEON_RGB_SRC_SEL_CRTC2;
597 	else {
598 		if (radeon_crtc->rmx_type != RMX_OFF)
599 			tv_rgb_cntl |= RADEON_RGB_SRC_SEL_RMX;
600 		else
601 			tv_rgb_cntl |= RADEON_RGB_SRC_SEL_CRTC1;
602 	}
603 
604 	if (tv_dac->tv_std == TV_STD_NTSC ||
605 	    tv_dac->tv_std == TV_STD_NTSC_J ||
606 	    tv_dac->tv_std == TV_STD_PAL_M ||
607 	    tv_dac->tv_std == TV_STD_PAL_60)
608 		vert_space = const_ptr->ver_total * 2 * 10000 / NTSC_TV_LINES_PER_FRAME;
609 	else
610 		vert_space = const_ptr->ver_total * 2 * 10000 / PAL_TV_LINES_PER_FRAME;
611 
612 	tmp = RREG32(RADEON_TV_VSCALER_CNTL1);
613 	tmp &= 0xe3ff0000;
614 	tmp |= (vert_space * (1 << FRAC_BITS) / 10000);
615 	tv_vscaler_cntl1 = tmp;
616 
617 	if (pll_ref_freq == 2700)
618 		tv_vscaler_cntl1 |= RADEON_RESTART_FIELD;
619 
620 	if (const_ptr->hor_resolution == 1024)
621 		tv_vscaler_cntl1 |= (4 << RADEON_Y_DEL_W_SIG_SHIFT);
622 	else
623 		tv_vscaler_cntl1 |= (2 << RADEON_Y_DEL_W_SIG_SHIFT);
624 
625 	/* scale up for int divide */
626 	tmp = const_ptr->ver_total * 2 * 1000;
627 	if (tv_dac->tv_std == TV_STD_NTSC ||
628 	    tv_dac->tv_std == TV_STD_NTSC_J ||
629 	    tv_dac->tv_std == TV_STD_PAL_M ||
630 	    tv_dac->tv_std == TV_STD_PAL_60) {
631 		tmp /= NTSC_TV_LINES_PER_FRAME;
632 	} else {
633 		tmp /= PAL_TV_LINES_PER_FRAME;
634 	}
635 	flicker_removal = (tmp + 500) / 1000;
636 
637 	if (flicker_removal < 3)
638 		flicker_removal = 3;
639 	for (i = 0; i < ARRAY_SIZE(SLOPE_limit); ++i) {
640 		if (flicker_removal == SLOPE_limit[i])
641 			break;
642 	}
643 
644 	tv_y_saw_tooth_cntl = (vert_space * SLOPE_value[i] * (1 << (FRAC_BITS - 1)) +
645 				5001) / 10000 / 8 | ((SLOPE_value[i] *
646 				(1 << (FRAC_BITS - 1)) / 8) << 16);
647 	tv_y_fall_cntl =
648 		(YCOEF_EN_value[i] << 17) | ((YCOEF_value[i] * (1 << 8) / 8) << 24) |
649 		RADEON_Y_FALL_PING_PONG | (272 * SLOPE_value[i] / 8) * (1 << (FRAC_BITS - 1)) /
650 		1024;
651 	tv_y_rise_cntl = RADEON_Y_RISE_PING_PONG|
652 		(flicker_removal * 1024 - 272) * SLOPE_value[i] / 8 * (1 << (FRAC_BITS - 1)) / 1024;
653 
654 	tv_vscaler_cntl2 = RREG32(RADEON_TV_VSCALER_CNTL2) & 0x00fffff0;
655 	tv_vscaler_cntl2 |= (0x10 << 24) |
656 		RADEON_DITHER_MODE |
657 		RADEON_Y_OUTPUT_DITHER_EN |
658 		RADEON_UV_OUTPUT_DITHER_EN |
659 		RADEON_UV_TO_BUF_DITHER_EN;
660 
661 	tmp = (tv_vscaler_cntl1 >> RADEON_UV_INC_SHIFT) & RADEON_UV_INC_MASK;
662 	tmp = ((16384 * 256 * 10) / tmp + 5) / 10;
663 	tmp = (tmp << RADEON_UV_OUTPUT_POST_SCALE_SHIFT) | 0x000b0000;
664 	tv_dac->tv.timing_cntl = tmp;
665 
666 	if (tv_dac->tv_std == TV_STD_NTSC ||
667 	    tv_dac->tv_std == TV_STD_NTSC_J ||
668 	    tv_dac->tv_std == TV_STD_PAL_M ||
669 	    tv_dac->tv_std == TV_STD_PAL_60)
670 		tv_dac_cntl = tv_dac->ntsc_tvdac_adj;
671 	else
672 		tv_dac_cntl = tv_dac->pal_tvdac_adj;
673 
674 	tv_dac_cntl |= RADEON_TV_DAC_NBLANK | RADEON_TV_DAC_NHOLD;
675 
676 	if (tv_dac->tv_std == TV_STD_NTSC ||
677 	    tv_dac->tv_std == TV_STD_NTSC_J)
678 		tv_dac_cntl |= RADEON_TV_DAC_STD_NTSC;
679 	else
680 		tv_dac_cntl |= RADEON_TV_DAC_STD_PAL;
681 
682 	if (tv_dac->tv_std == TV_STD_NTSC ||
683 	    tv_dac->tv_std == TV_STD_NTSC_J) {
684 		if (pll_ref_freq == 2700) {
685 			m = NTSC_TV_PLL_M_27;
686 			n = NTSC_TV_PLL_N_27;
687 			p = NTSC_TV_PLL_P_27;
688 		} else {
689 			m = NTSC_TV_PLL_M_14;
690 			n = NTSC_TV_PLL_N_14;
691 			p = NTSC_TV_PLL_P_14;
692 		}
693 	} else {
694 		if (pll_ref_freq == 2700) {
695 			m = PAL_TV_PLL_M_27;
696 			n = PAL_TV_PLL_N_27;
697 			p = PAL_TV_PLL_P_27;
698 		} else {
699 			m = PAL_TV_PLL_M_14;
700 			n = PAL_TV_PLL_N_14;
701 			p = PAL_TV_PLL_P_14;
702 		}
703 	}
704 
705 	tv_pll_cntl = (m & RADEON_TV_M0LO_MASK) |
706 		(((m >> 8) & RADEON_TV_M0HI_MASK) << RADEON_TV_M0HI_SHIFT) |
707 		((n & RADEON_TV_N0LO_MASK) << RADEON_TV_N0LO_SHIFT) |
708 		(((n >> 9) & RADEON_TV_N0HI_MASK) << RADEON_TV_N0HI_SHIFT) |
709 		((p & RADEON_TV_P_MASK) << RADEON_TV_P_SHIFT);
710 
711 	tv_dac->tv.tv_uv_adr = 0xc8;
712 
713 	if (tv_dac->tv_std == TV_STD_NTSC ||
714 	    tv_dac->tv_std == TV_STD_NTSC_J ||
715 	    tv_dac->tv_std == TV_STD_PAL_M ||
716 	    tv_dac->tv_std == TV_STD_PAL_60) {
717 		tv_ftotal = NTSC_TV_VFTOTAL;
718 		hor_timing = hor_timing_NTSC;
719 		vert_timing = vert_timing_NTSC;
720 	} else {
721 		hor_timing = hor_timing_PAL;
722 		vert_timing = vert_timing_PAL;
723 		tv_ftotal = PAL_TV_VFTOTAL;
724 	}
725 
726 	for (i = 0; i < MAX_H_CODE_TIMING_LEN; i++) {
727 		tv_dac->tv.h_code_timing[i] = hor_timing[i];
728 		if (tv_dac->tv.h_code_timing[i] == 0)
729 			break;
730 	}
731 
732 	for (i = 0; i < MAX_V_CODE_TIMING_LEN; i++) {
733 		tv_dac->tv.v_code_timing[i] = vert_timing[i];
734 		if (tv_dac->tv.v_code_timing[i] == 0)
735 			break;
736 	}
737 
738 	radeon_legacy_tv_init_restarts(encoder);
739 
740 	/* play with DAC_CNTL */
741 	/* play with GPIOPAD_A */
742 	/* DISP_OUTPUT_CNTL */
743 	/* use reference freq */
744 
745 	/* program the TV registers */
746 	WREG32(RADEON_TV_MASTER_CNTL, (tv_master_cntl | RADEON_TV_ASYNC_RST |
747 				       RADEON_CRT_ASYNC_RST | RADEON_TV_FIFO_ASYNC_RST));
748 
749 	tmp = RREG32(RADEON_TV_DAC_CNTL);
750 	tmp &= ~RADEON_TV_DAC_NBLANK;
751 	tmp |= RADEON_TV_DAC_BGSLEEP |
752 		RADEON_TV_DAC_RDACPD |
753 		RADEON_TV_DAC_GDACPD |
754 		RADEON_TV_DAC_BDACPD;
755 	WREG32(RADEON_TV_DAC_CNTL, tmp);
756 
757 	/* TV PLL */
758 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, 0, ~RADEON_TVCLK_SRC_SEL_TVPLL);
759 	WREG32_PLL(RADEON_TV_PLL_CNTL, tv_pll_cntl);
760 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, RADEON_TVPLL_RESET, ~RADEON_TVPLL_RESET);
761 
762 	radeon_wait_pll_lock(encoder, 200, 800, 135);
763 
764 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, 0, ~RADEON_TVPLL_RESET);
765 
766 	radeon_wait_pll_lock(encoder, 300, 160, 27);
767 	radeon_wait_pll_lock(encoder, 200, 800, 135);
768 
769 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, 0, ~0xf);
770 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, RADEON_TVCLK_SRC_SEL_TVPLL, ~RADEON_TVCLK_SRC_SEL_TVPLL);
771 
772 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, (1 << RADEON_TVPDC_SHIFT), ~RADEON_TVPDC_MASK);
773 	WREG32_PLL_P(RADEON_TV_PLL_CNTL1, 0, ~RADEON_TVPLL_SLEEP);
774 
775 	/* TV HV */
776 	WREG32(RADEON_TV_RGB_CNTL, tv_rgb_cntl);
777 	WREG32(RADEON_TV_HTOTAL, const_ptr->hor_total - 1);
778 	WREG32(RADEON_TV_HDISP, const_ptr->hor_resolution - 1);
779 	WREG32(RADEON_TV_HSTART, const_ptr->hor_start);
780 
781 	WREG32(RADEON_TV_VTOTAL, const_ptr->ver_total - 1);
782 	WREG32(RADEON_TV_VDISP, const_ptr->ver_resolution - 1);
783 	WREG32(RADEON_TV_FTOTAL, tv_ftotal);
784 	WREG32(RADEON_TV_VSCALER_CNTL1, tv_vscaler_cntl1);
785 	WREG32(RADEON_TV_VSCALER_CNTL2, tv_vscaler_cntl2);
786 
787 	WREG32(RADEON_TV_Y_FALL_CNTL, tv_y_fall_cntl);
788 	WREG32(RADEON_TV_Y_RISE_CNTL, tv_y_rise_cntl);
789 	WREG32(RADEON_TV_Y_SAW_TOOTH_CNTL, tv_y_saw_tooth_cntl);
790 
791 	WREG32(RADEON_TV_MASTER_CNTL, (tv_master_cntl | RADEON_TV_ASYNC_RST |
792 				       RADEON_CRT_ASYNC_RST));
793 
794 	/* TV restarts */
795 	radeon_legacy_write_tv_restarts(radeon_encoder);
796 
797 	/* tv timings */
798 	radeon_restore_tv_timing_tables(radeon_encoder);
799 
800 	WREG32(RADEON_TV_MASTER_CNTL, (tv_master_cntl | RADEON_TV_ASYNC_RST));
801 
802 	/* tv std */
803 	WREG32(RADEON_TV_SYNC_CNTL, (RADEON_SYNC_PUB | RADEON_TV_SYNC_IO_DRIVE));
804 	WREG32(RADEON_TV_TIMING_CNTL, tv_dac->tv.timing_cntl);
805 	WREG32(RADEON_TV_MODULATOR_CNTL1, tv_modulator_cntl1);
806 	WREG32(RADEON_TV_MODULATOR_CNTL2, tv_modulator_cntl2);
807 	WREG32(RADEON_TV_PRE_DAC_MUX_CNTL, (RADEON_Y_RED_EN |
808 					    RADEON_C_GRN_EN |
809 					    RADEON_CMP_BLU_EN |
810 					    RADEON_DAC_DITHER_EN));
811 
812 	WREG32(RADEON_TV_CRC_CNTL, 0);
813 
814 	WREG32(RADEON_TV_MASTER_CNTL, tv_master_cntl);
815 
816 	WREG32(RADEON_TV_GAIN_LIMIT_SETTINGS, ((0x17f << RADEON_UV_GAIN_LIMIT_SHIFT) |
817 					       (0x5ff << RADEON_Y_GAIN_LIMIT_SHIFT)));
818 	WREG32(RADEON_TV_LINEAR_GAIN_SETTINGS, ((0x100 << RADEON_UV_GAIN_SHIFT) |
819 						(0x100 << RADEON_Y_GAIN_SHIFT)));
820 
821 	WREG32(RADEON_TV_DAC_CNTL, tv_dac_cntl);
822 
823 }
824 
825 void radeon_legacy_tv_adjust_crtc_reg(struct drm_encoder *encoder,
826 				      uint32_t *h_total_disp, uint32_t *h_sync_strt_wid,
827 				      uint32_t *v_total_disp, uint32_t *v_sync_strt_wid)
828 {
829 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
830 	const struct radeon_tv_mode_constants *const_ptr;
831 	uint32_t tmp;
832 
833 	const_ptr = radeon_legacy_tv_get_std_mode(radeon_encoder, NULL);
834 	if (!const_ptr)
835 		return;
836 
837 	*h_total_disp = (((const_ptr->hor_resolution / 8) - 1) << RADEON_CRTC_H_DISP_SHIFT) |
838 		(((const_ptr->hor_total / 8) - 1) << RADEON_CRTC_H_TOTAL_SHIFT);
839 
840 	tmp = *h_sync_strt_wid;
841 	tmp &= ~(RADEON_CRTC_H_SYNC_STRT_PIX | RADEON_CRTC_H_SYNC_STRT_CHAR);
842 	tmp |= (((const_ptr->hor_syncstart / 8) - 1) << RADEON_CRTC_H_SYNC_STRT_CHAR_SHIFT) |
843 		(const_ptr->hor_syncstart & 7);
844 	*h_sync_strt_wid = tmp;
845 
846 	*v_total_disp = ((const_ptr->ver_resolution - 1) << RADEON_CRTC_V_DISP_SHIFT) |
847 		((const_ptr->ver_total - 1) << RADEON_CRTC_V_TOTAL_SHIFT);
848 
849 	tmp = *v_sync_strt_wid;
850 	tmp &= ~RADEON_CRTC_V_SYNC_STRT;
851 	tmp |= ((const_ptr->ver_syncstart - 1) << RADEON_CRTC_V_SYNC_STRT_SHIFT);
852 	*v_sync_strt_wid = tmp;
853 }
854 
855 static int get_post_div(int value)
856 {
857 	int post_div;
858 	switch (value) {
859 	case 1: post_div = 0; break;
860 	case 2: post_div = 1; break;
861 	case 3: post_div = 4; break;
862 	case 4: post_div = 2; break;
863 	case 6: post_div = 6; break;
864 	case 8: post_div = 3; break;
865 	case 12: post_div = 7; break;
866 	case 16:
867 	default: post_div = 5; break;
868 	}
869 	return post_div;
870 }
871 
872 void radeon_legacy_tv_adjust_pll1(struct drm_encoder *encoder,
873 				  uint32_t *htotal_cntl, uint32_t *ppll_ref_div,
874 				  uint32_t *ppll_div_3, uint32_t *pixclks_cntl)
875 {
876 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
877 	const struct radeon_tv_mode_constants *const_ptr;
878 
879 	const_ptr = radeon_legacy_tv_get_std_mode(radeon_encoder, NULL);
880 	if (!const_ptr)
881 		return;
882 
883 	*htotal_cntl = (const_ptr->hor_total & 0x7) | RADEON_HTOT_CNTL_VGA_EN;
884 
885 	*ppll_ref_div = const_ptr->crtcPLL_M;
886 
887 	*ppll_div_3 = (const_ptr->crtcPLL_N & 0x7ff) | (get_post_div(const_ptr->crtcPLL_post_div) << 16);
888 	*pixclks_cntl &= ~(RADEON_PIX2CLK_SRC_SEL_MASK | RADEON_PIXCLK_TV_SRC_SEL);
889 	*pixclks_cntl |= RADEON_PIX2CLK_SRC_SEL_P2PLLCLK;
890 }
891 
892 void radeon_legacy_tv_adjust_pll2(struct drm_encoder *encoder,
893 				  uint32_t *htotal2_cntl, uint32_t *p2pll_ref_div,
894 				  uint32_t *p2pll_div_0, uint32_t *pixclks_cntl)
895 {
896 	struct radeon_encoder *radeon_encoder = to_radeon_encoder(encoder);
897 	const struct radeon_tv_mode_constants *const_ptr;
898 
899 	const_ptr = radeon_legacy_tv_get_std_mode(radeon_encoder, NULL);
900 	if (!const_ptr)
901 		return;
902 
903 	*htotal2_cntl = (const_ptr->hor_total & 0x7);
904 
905 	*p2pll_ref_div = const_ptr->crtcPLL_M;
906 
907 	*p2pll_div_0 = (const_ptr->crtcPLL_N & 0x7ff) | (get_post_div(const_ptr->crtcPLL_post_div) << 16);
908 	*pixclks_cntl &= ~RADEON_PIX2CLK_SRC_SEL_MASK;
909 	*pixclks_cntl |= RADEON_PIX2CLK_SRC_SEL_P2PLLCLK | RADEON_PIXCLK_TV_SRC_SEL;
910 }
911 
912