?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / gpu / drm / nouveau / dispnv04 / tvnv17.c
blobbe28e7bd7490324c42c4551ba4d1ff835e1d0b46
1 /*
2 * Copyright (C) 2009 Francisco Jerez.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining
6 * a copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sublicense, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial
15 * portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
20 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
21 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
22 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
23 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 */
26
27 #include <drm/drm_crtc_helper.h>
28 #include <drm/drm_probe_helper.h>
29 #include "nouveau_drv.h"
30 #include "nouveau_reg.h"
31 #include "nouveau_encoder.h"
32 #include "nouveau_connector.h"
33 #include "nouveau_crtc.h"
34 #include "hw.h"
35 #include "tvnv17.h"
36
37 MODULE_PARM_DESC(tv_norm, "Default TV norm.\n"
38 "\t\tSupported: PAL, PAL-M, PAL-N, PAL-Nc, NTSC-M, NTSC-J,\n"
39 "\t\t\thd480i, hd480p, hd576i, hd576p, hd720p, hd1080i.\n"
40 "\t\tDefault: PAL\n"
41 "\t\t*NOTE* Ignored for cards with external TV encoders.");
42 static char *nouveau_tv_norm;
43 module_param_named(tv_norm, nouveau_tv_norm, charp, 0400);
44
45 static uint32_t nv42_tv_sample_load(struct drm_encoder *encoder)
46 {
47 struct drm_device *dev = encoder->dev;
48 struct nouveau_drm *drm = nouveau_drm(dev);
49 struct nvkm_gpio *gpio = nvxx_gpio(&drm->client.device);
50 uint32_t testval, regoffset = nv04_dac_output_offset(encoder);
51 uint32_t gpio0, gpio1, fp_htotal, fp_hsync_start, fp_hsync_end,
52 fp_control, test_ctrl, dacclk, ctv_14, ctv_1c, ctv_6c;
53 uint32_t sample = 0;
54 int head;
55
56 #define RGB_TEST_DATA(r, g, b) (r << 0 | g << 10 | b << 20)
57 testval = RGB_TEST_DATA(0x82, 0xeb, 0x82);
58 if (drm->vbios.tvdactestval)
59 testval = drm->vbios.tvdactestval;
60
61 dacclk = NVReadRAMDAC(dev, 0, NV_PRAMDAC_DACCLK + regoffset);
62 head = (dacclk & 0x100) >> 8;
63
64 /* Save the previous state. */
65 gpio1 = nvkm_gpio_get(gpio, 0, DCB_GPIO_TVDAC1, 0xff);
66 gpio0 = nvkm_gpio_get(gpio, 0, DCB_GPIO_TVDAC0, 0xff);
67 fp_htotal = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_HTOTAL);
68 fp_hsync_start = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_START);
69 fp_hsync_end = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_END);
70 fp_control = NVReadRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL);
71 test_ctrl = NVReadRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset);
72 ctv_1c = NVReadRAMDAC(dev, head, 0x680c1c);
73 ctv_14 = NVReadRAMDAC(dev, head, 0x680c14);
74 ctv_6c = NVReadRAMDAC(dev, head, 0x680c6c);
75
76 /* Prepare the DAC for load detection. */
77 nvkm_gpio_set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, true);
78 nvkm_gpio_set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, true);
79
80 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HTOTAL, 1343);
81 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_START, 1047);
82 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_END, 1183);
83 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL,
84 NV_PRAMDAC_FP_TG_CONTROL_DISPEN_POS |
85 NV_PRAMDAC_FP_TG_CONTROL_WIDTH_12 |
86 NV_PRAMDAC_FP_TG_CONTROL_READ_PROG |
87 NV_PRAMDAC_FP_TG_CONTROL_HSYNC_POS |
88 NV_PRAMDAC_FP_TG_CONTROL_VSYNC_POS);
89
90 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset, 0);
91
92 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_DACCLK + regoffset,
93 (dacclk & ~0xff) | 0x22);
94 msleep(1);
95 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_DACCLK + regoffset,
96 (dacclk & ~0xff) | 0x21);
97
98 NVWriteRAMDAC(dev, head, 0x680c1c, 1 << 20);
99 NVWriteRAMDAC(dev, head, 0x680c14, 4 << 16);
100
101 /* Sample pin 0x4 (usually S-video luma). */
102 NVWriteRAMDAC(dev, head, 0x680c6c, testval >> 10 & 0x3ff);
103 msleep(20);
104 sample |= NVReadRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset)
105 & 0x4 << 28;
106
107 /* Sample the remaining pins. */
108 NVWriteRAMDAC(dev, head, 0x680c6c, testval & 0x3ff);
109 msleep(20);
110 sample |= NVReadRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset)
111 & 0xa << 28;
112
113 /* Restore the previous state. */
114 NVWriteRAMDAC(dev, head, 0x680c1c, ctv_1c);
115 NVWriteRAMDAC(dev, head, 0x680c14, ctv_14);
116 NVWriteRAMDAC(dev, head, 0x680c6c, ctv_6c);
117 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_DACCLK + regoffset, dacclk);
118 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL + regoffset, test_ctrl);
119 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_TG_CONTROL, fp_control);
120 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_END, fp_hsync_end);
121 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HSYNC_START, fp_hsync_start);
122 NVWriteRAMDAC(dev, head, NV_PRAMDAC_FP_HTOTAL, fp_htotal);
123 nvkm_gpio_set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, gpio1);
124 nvkm_gpio_set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, gpio0);
125
126 return sample;
127 }
128
129 static bool
130 get_tv_detect_quirks(struct drm_device *dev, uint32_t *pin_mask)
131 {
132 struct nouveau_drm *drm = nouveau_drm(dev);
133 struct nvkm_device *device = nvxx_device(&drm->client.device);
134
135 if (device->quirk && device->quirk->tv_pin_mask) {
136 *pin_mask = device->quirk->tv_pin_mask;
137 return false;
138 }
139
140 return true;
141 }
142
143 static enum drm_connector_status
144 nv17_tv_detect(struct drm_encoder *encoder, struct drm_connector *connector)
145 {
146 struct drm_device *dev = encoder->dev;
147 struct nouveau_drm *drm = nouveau_drm(dev);
148 struct drm_mode_config *conf = &dev->mode_config;
149 struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
150 struct dcb_output *dcb = tv_enc->base.dcb;
151 bool reliable = get_tv_detect_quirks(dev, &tv_enc->pin_mask);
152
153 if (nv04_dac_in_use(encoder))
154 return connector_status_disconnected;
155
156 if (reliable) {
157 if (drm->client.device.info.chipset == 0x42 ||
158 drm->client.device.info.chipset == 0x43)
159 tv_enc->pin_mask =
160 nv42_tv_sample_load(encoder) >> 28 & 0xe;
161 else
162 tv_enc->pin_mask =
163 nv17_dac_sample_load(encoder) >> 28 & 0xe;
164 }
165
166 switch (tv_enc->pin_mask) {
167 case 0x2:
168 case 0x4:
169 tv_enc->subconnector = DRM_MODE_SUBCONNECTOR_Composite;
170 break;
171 case 0xc:
172 tv_enc->subconnector = DRM_MODE_SUBCONNECTOR_SVIDEO;
173 break;
174 case 0xe:
175 if (dcb->tvconf.has_component_output)
176 tv_enc->subconnector = DRM_MODE_SUBCONNECTOR_Component;
177 else
178 tv_enc->subconnector = DRM_MODE_SUBCONNECTOR_SCART;
179 break;
180 default:
181 tv_enc->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
182 break;
183 }
184
185 drm_object_property_set_value(&connector->base,
186 conf->tv_subconnector_property,
187 tv_enc->subconnector);
188
189 if (!reliable) {
190 return connector_status_unknown;
191 } else if (tv_enc->subconnector) {
192 NV_INFO(drm, "Load detected on output %c\n",
193 '@' + ffs(dcb->or));
194 return connector_status_connected;
195 } else {
196 return connector_status_disconnected;
197 }
198 }
199
200 static int nv17_tv_get_ld_modes(struct drm_encoder *encoder,
201 struct drm_connector *connector)
202 {
203 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
204 const struct drm_display_mode *tv_mode;
205 int n = 0;
206
207 for (tv_mode = nv17_tv_modes; tv_mode->hdisplay; tv_mode++) {
208 struct drm_display_mode *mode;
209
210 mode = drm_mode_duplicate(encoder->dev, tv_mode);
211
212 mode->clock = tv_norm->tv_enc_mode.vrefresh *
213 mode->htotal / 1000 *
214 mode->vtotal / 1000;
215
216 if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
217 mode->clock *= 2;
218
219 if (mode->hdisplay == tv_norm->tv_enc_mode.hdisplay &&
220 mode->vdisplay == tv_norm->tv_enc_mode.vdisplay)
221 mode->type |= DRM_MODE_TYPE_PREFERRED;
222
223 drm_mode_probed_add(connector, mode);
224 n++;
225 }
226
227 return n;
228 }
229
230 static int nv17_tv_get_hd_modes(struct drm_encoder *encoder,
231 struct drm_connector *connector)
232 {
233 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
234 struct drm_display_mode *output_mode = &tv_norm->ctv_enc_mode.mode;
235 struct drm_display_mode *mode;
236 const struct {
237 int hdisplay;
238 int vdisplay;
239 } modes[] = {
240 { 640, 400 },
241 { 640, 480 },
242 { 720, 480 },
243 { 720, 576 },
244 { 800, 600 },
245 { 1024, 768 },
246 { 1280, 720 },
247 { 1280, 1024 },
248 { 1920, 1080 }
249 };
250 int i, n = 0;
251
252 for (i = 0; i < ARRAY_SIZE(modes); i++) {
253 if (modes[i].hdisplay > output_mode->hdisplay ||
254 modes[i].vdisplay > output_mode->vdisplay)
255 continue;
256
257 if (modes[i].hdisplay == output_mode->hdisplay &&
258 modes[i].vdisplay == output_mode->vdisplay) {
259 mode = drm_mode_duplicate(encoder->dev, output_mode);
260 mode->type |= DRM_MODE_TYPE_PREFERRED;
261
262 } else {
263 mode = drm_cvt_mode(encoder->dev, modes[i].hdisplay,
264 modes[i].vdisplay, 60, false,
265 (output_mode->flags &
266 DRM_MODE_FLAG_INTERLACE), false);
267 }
268
269 /* CVT modes are sometimes unsuitable... */
270 if (output_mode->hdisplay <= 720
271 || output_mode->hdisplay >= 1920) {
272 mode->htotal = output_mode->htotal;
273 mode->hsync_start = (mode->hdisplay + (mode->htotal
274 - mode->hdisplay) * 9 / 10) & ~7;
275 mode->hsync_end = mode->hsync_start + 8;
276 }
277
278 if (output_mode->vdisplay >= 1024) {
279 mode->vtotal = output_mode->vtotal;
280 mode->vsync_start = output_mode->vsync_start;
281 mode->vsync_end = output_mode->vsync_end;
282 }
283
284 mode->type |= DRM_MODE_TYPE_DRIVER;
285 drm_mode_probed_add(connector, mode);
286 n++;
287 }
288
289 return n;
290 }
291
292 static int nv17_tv_get_modes(struct drm_encoder *encoder,
293 struct drm_connector *connector)
294 {
295 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
296
297 if (tv_norm->kind == CTV_ENC_MODE)
298 return nv17_tv_get_hd_modes(encoder, connector);
299 else
300 return nv17_tv_get_ld_modes(encoder, connector);
301 }
302
303 static int nv17_tv_mode_valid(struct drm_encoder *encoder,
304 struct drm_display_mode *mode)
305 {
306 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
307
308 if (tv_norm->kind == CTV_ENC_MODE) {
309 struct drm_display_mode *output_mode =
310 &tv_norm->ctv_enc_mode.mode;
311
312 if (mode->clock > 400000)
313 return MODE_CLOCK_HIGH;
314
315 if (mode->hdisplay > output_mode->hdisplay ||
316 mode->vdisplay > output_mode->vdisplay)
317 return MODE_BAD;
318
319 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) !=
320 (output_mode->flags & DRM_MODE_FLAG_INTERLACE))
321 return MODE_NO_INTERLACE;
322
323 if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
324 return MODE_NO_DBLESCAN;
325
326 } else {
327 const int vsync_tolerance = 600;
328
329 if (mode->clock > 70000)
330 return MODE_CLOCK_HIGH;
331
332 if (abs(drm_mode_vrefresh(mode) * 1000 -
333 tv_norm->tv_enc_mode.vrefresh) > vsync_tolerance)
334 return MODE_VSYNC;
335
336 /* The encoder takes care of the actual interlacing */
337 if (mode->flags & DRM_MODE_FLAG_INTERLACE)
338 return MODE_NO_INTERLACE;
339 }
340
341 return MODE_OK;
342 }
343
344 static bool nv17_tv_mode_fixup(struct drm_encoder *encoder,
345 const struct drm_display_mode *mode,
346 struct drm_display_mode *adjusted_mode)
347 {
348 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
349
350 if (nv04_dac_in_use(encoder))
351 return false;
352
353 if (tv_norm->kind == CTV_ENC_MODE)
354 adjusted_mode->clock = tv_norm->ctv_enc_mode.mode.clock;
355 else
356 adjusted_mode->clock = 90000;
357
358 return true;
359 }
360
361 static void nv17_tv_dpms(struct drm_encoder *encoder, int mode)
362 {
363 struct drm_device *dev = encoder->dev;
364 struct nouveau_drm *drm = nouveau_drm(dev);
365 struct nvkm_gpio *gpio = nvxx_gpio(&drm->client.device);
366 struct nv17_tv_state *regs = &to_tv_enc(encoder)->state;
367 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
368
369 if (nouveau_encoder(encoder)->last_dpms == mode)
370 return;
371 nouveau_encoder(encoder)->last_dpms = mode;
372
373 NV_INFO(drm, "Setting dpms mode %d on TV encoder (output %d)\n",
374 mode, nouveau_encoder(encoder)->dcb->index);
375
376 regs->ptv_200 &= ~1;
377
378 if (tv_norm->kind == CTV_ENC_MODE) {
379 nv04_dfp_update_fp_control(encoder, mode);
380
381 } else {
382 nv04_dfp_update_fp_control(encoder, DRM_MODE_DPMS_OFF);
383
384 if (mode == DRM_MODE_DPMS_ON)
385 regs->ptv_200 |= 1;
386 }
387
388 nv_load_ptv(dev, regs, 200);
389
390 nvkm_gpio_set(gpio, 0, DCB_GPIO_TVDAC1, 0xff, mode == DRM_MODE_DPMS_ON);
391 nvkm_gpio_set(gpio, 0, DCB_GPIO_TVDAC0, 0xff, mode == DRM_MODE_DPMS_ON);
392
393 nv04_dac_update_dacclk(encoder, mode == DRM_MODE_DPMS_ON);
394 }
395
396 static void nv17_tv_prepare(struct drm_encoder *encoder)
397 {
398 struct drm_device *dev = encoder->dev;
399 struct nouveau_drm *drm = nouveau_drm(dev);
400 const struct drm_encoder_helper_funcs *helper = encoder->helper_private;
401 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
402 int head = nouveau_crtc(encoder->crtc)->index;
403 uint8_t *cr_lcd = &nv04_display(dev)->mode_reg.crtc_reg[head].CRTC[
404 NV_CIO_CRE_LCD__INDEX];
405 uint32_t dacclk_off = NV_PRAMDAC_DACCLK +
406 nv04_dac_output_offset(encoder);
407 uint32_t dacclk;
408
409 helper->dpms(encoder, DRM_MODE_DPMS_OFF);
410
411 nv04_dfp_disable(dev, head);
412
413 /* Unbind any FP encoders from this head if we need the FP
414 * stuff enabled. */
415 if (tv_norm->kind == CTV_ENC_MODE) {
416 struct drm_encoder *enc;
417
418 list_for_each_entry(enc, &dev->mode_config.encoder_list, head) {
419 struct dcb_output *dcb = nouveau_encoder(enc)->dcb;
420
421 if ((dcb->type == DCB_OUTPUT_TMDS ||
422 dcb->type == DCB_OUTPUT_LVDS) &&
423 !enc->crtc &&
424 nv04_dfp_get_bound_head(dev, dcb) == head) {
425 nv04_dfp_bind_head(dev, dcb, head ^ 1,
426 drm->vbios.fp.dual_link);
427 }
428 }
429
430 }
431
432 if (tv_norm->kind == CTV_ENC_MODE)
433 *cr_lcd |= 0x1 | (head ? 0x0 : 0x8);
434
435 /* Set the DACCLK register */
436 dacclk = (NVReadRAMDAC(dev, 0, dacclk_off) & ~0x30) | 0x1;
437
438 if (drm->client.device.info.family == NV_DEVICE_INFO_V0_CURIE)
439 dacclk |= 0x1a << 16;
440
441 if (tv_norm->kind == CTV_ENC_MODE) {
442 dacclk |= 0x20;
443
444 if (head)
445 dacclk |= 0x100;
446 else
447 dacclk &= ~0x100;
448
449 } else {
450 dacclk |= 0x10;
451
452 }
453
454 NVWriteRAMDAC(dev, 0, dacclk_off, dacclk);
455 }
456
457 static void nv17_tv_mode_set(struct drm_encoder *encoder,
458 struct drm_display_mode *drm_mode,
459 struct drm_display_mode *adjusted_mode)
460 {
461 struct drm_device *dev = encoder->dev;
462 struct nouveau_drm *drm = nouveau_drm(dev);
463 int head = nouveau_crtc(encoder->crtc)->index;
464 struct nv04_crtc_reg *regs = &nv04_display(dev)->mode_reg.crtc_reg[head];
465 struct nv17_tv_state *tv_regs = &to_tv_enc(encoder)->state;
466 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
467 int i;
468
469 regs->CRTC[NV_CIO_CRE_53] = 0x40; /* FP_HTIMING */
470 regs->CRTC[NV_CIO_CRE_54] = 0; /* FP_VTIMING */
471 regs->ramdac_630 = 0x2; /* turn off green mode (tv test pattern?) */
472 regs->tv_setup = 1;
473 regs->ramdac_8c0 = 0x0;
474
475 if (tv_norm->kind == TV_ENC_MODE) {
476 tv_regs->ptv_200 = 0x13111100;
477 if (head)
478 tv_regs->ptv_200 |= 0x10;
479
480 tv_regs->ptv_20c = 0x808010;
481 tv_regs->ptv_304 = 0x2d00000;
482 tv_regs->ptv_600 = 0x0;
483 tv_regs->ptv_60c = 0x0;
484 tv_regs->ptv_610 = 0x1e00000;
485
486 if (tv_norm->tv_enc_mode.vdisplay == 576) {
487 tv_regs->ptv_508 = 0x1200000;
488 tv_regs->ptv_614 = 0x33;
489
490 } else if (tv_norm->tv_enc_mode.vdisplay == 480) {
491 tv_regs->ptv_508 = 0xf00000;
492 tv_regs->ptv_614 = 0x13;
493 }
494
495 if (drm->client.device.info.family >= NV_DEVICE_INFO_V0_RANKINE) {
496 tv_regs->ptv_500 = 0xe8e0;
497 tv_regs->ptv_504 = 0x1710;
498 tv_regs->ptv_604 = 0x0;
499 tv_regs->ptv_608 = 0x0;
500 } else {
501 if (tv_norm->tv_enc_mode.vdisplay == 576) {
502 tv_regs->ptv_604 = 0x20;
503 tv_regs->ptv_608 = 0x10;
504 tv_regs->ptv_500 = 0x19710;
505 tv_regs->ptv_504 = 0x68f0;
506
507 } else if (tv_norm->tv_enc_mode.vdisplay == 480) {
508 tv_regs->ptv_604 = 0x10;
509 tv_regs->ptv_608 = 0x20;
510 tv_regs->ptv_500 = 0x4b90;
511 tv_regs->ptv_504 = 0x1b480;
512 }
513 }
514
515 for (i = 0; i < 0x40; i++)
516 tv_regs->tv_enc[i] = tv_norm->tv_enc_mode.tv_enc[i];
517
518 } else {
519 struct drm_display_mode *output_mode =
520 &tv_norm->ctv_enc_mode.mode;
521
522 /* The registers in PRAMDAC+0xc00 control some timings and CSC
523 * parameters for the CTV encoder (It's only used for "HD" TV
524 * modes, I don't think I have enough working to guess what
525 * they exactly mean...), it's probably connected at the
526 * output of the FP encoder, but it also needs the analog
527 * encoder in its OR enabled and routed to the head it's
528 * using. It's enabled with the DACCLK register, bits [5:4].
529 */
530 for (i = 0; i < 38; i++)
531 regs->ctv_regs[i] = tv_norm->ctv_enc_mode.ctv_regs[i];
532
533 regs->fp_horiz_regs[FP_DISPLAY_END] = output_mode->hdisplay - 1;
534 regs->fp_horiz_regs[FP_TOTAL] = output_mode->htotal - 1;
535 regs->fp_horiz_regs[FP_SYNC_START] =
536 output_mode->hsync_start - 1;
537 regs->fp_horiz_regs[FP_SYNC_END] = output_mode->hsync_end - 1;
538 regs->fp_horiz_regs[FP_CRTC] = output_mode->hdisplay +
539 max((output_mode->hdisplay-600)/40 - 1, 1);
540
541 regs->fp_vert_regs[FP_DISPLAY_END] = output_mode->vdisplay - 1;
542 regs->fp_vert_regs[FP_TOTAL] = output_mode->vtotal - 1;
543 regs->fp_vert_regs[FP_SYNC_START] =
544 output_mode->vsync_start - 1;
545 regs->fp_vert_regs[FP_SYNC_END] = output_mode->vsync_end - 1;
546 regs->fp_vert_regs[FP_CRTC] = output_mode->vdisplay - 1;
547
548 regs->fp_control = NV_PRAMDAC_FP_TG_CONTROL_DISPEN_POS |
549 NV_PRAMDAC_FP_TG_CONTROL_READ_PROG |
550 NV_PRAMDAC_FP_TG_CONTROL_WIDTH_12;
551
552 if (output_mode->flags & DRM_MODE_FLAG_PVSYNC)
553 regs->fp_control |= NV_PRAMDAC_FP_TG_CONTROL_VSYNC_POS;
554 if (output_mode->flags & DRM_MODE_FLAG_PHSYNC)
555 regs->fp_control |= NV_PRAMDAC_FP_TG_CONTROL_HSYNC_POS;
556
557 regs->fp_debug_0 = NV_PRAMDAC_FP_DEBUG_0_YWEIGHT_ROUND |
558 NV_PRAMDAC_FP_DEBUG_0_XWEIGHT_ROUND |
559 NV_PRAMDAC_FP_DEBUG_0_YINTERP_BILINEAR |
560 NV_PRAMDAC_FP_DEBUG_0_XINTERP_BILINEAR |
561 NV_RAMDAC_FP_DEBUG_0_TMDS_ENABLED |
562 NV_PRAMDAC_FP_DEBUG_0_YSCALE_ENABLE |
563 NV_PRAMDAC_FP_DEBUG_0_XSCALE_ENABLE;
564
565 regs->fp_debug_2 = 0;
566
567 regs->fp_margin_color = 0x801080;
568
569 }
570 }
571
572 static void nv17_tv_commit(struct drm_encoder *encoder)
573 {
574 struct drm_device *dev = encoder->dev;
575 struct nouveau_drm *drm = nouveau_drm(dev);
576 struct nouveau_crtc *nv_crtc = nouveau_crtc(encoder->crtc);
577 struct nouveau_encoder *nv_encoder = nouveau_encoder(encoder);
578 const struct drm_encoder_helper_funcs *helper = encoder->helper_private;
579
580 if (get_tv_norm(encoder)->kind == TV_ENC_MODE) {
581 nv17_tv_update_rescaler(encoder);
582 nv17_tv_update_properties(encoder);
583 } else {
584 nv17_ctv_update_rescaler(encoder);
585 }
586
587 nv17_tv_state_load(dev, &to_tv_enc(encoder)->state);
588
589 /* This could use refinement for flatpanels, but it should work */
590 if (drm->client.device.info.chipset < 0x44)
591 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL +
592 nv04_dac_output_offset(encoder),
593 0xf0000000);
594 else
595 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_TEST_CONTROL +
596 nv04_dac_output_offset(encoder),
597 0x00100000);
598
599 helper->dpms(encoder, DRM_MODE_DPMS_ON);
600
601 NV_INFO(drm, "Output %s is running on CRTC %d using output %c\n",
602 nv04_encoder_get_connector(nv_encoder)->base.name,
603 nv_crtc->index, '@' + ffs(nv_encoder->dcb->or));
604 }
605
606 static void nv17_tv_save(struct drm_encoder *encoder)
607 {
608 struct drm_device *dev = encoder->dev;
609 struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
610
611 nouveau_encoder(encoder)->restore.output =
612 NVReadRAMDAC(dev, 0,
613 NV_PRAMDAC_DACCLK +
614 nv04_dac_output_offset(encoder));
615
616 nv17_tv_state_save(dev, &tv_enc->saved_state);
617
618 tv_enc->state.ptv_200 = tv_enc->saved_state.ptv_200;
619 }
620
621 static void nv17_tv_restore(struct drm_encoder *encoder)
622 {
623 struct drm_device *dev = encoder->dev;
624
625 NVWriteRAMDAC(dev, 0, NV_PRAMDAC_DACCLK +
626 nv04_dac_output_offset(encoder),
627 nouveau_encoder(encoder)->restore.output);
628
629 nv17_tv_state_load(dev, &to_tv_enc(encoder)->saved_state);
630
631 nouveau_encoder(encoder)->last_dpms = NV_DPMS_CLEARED;
632 }
633
634 static int nv17_tv_create_resources(struct drm_encoder *encoder,
635 struct drm_connector *connector)
636 {
637 struct drm_device *dev = encoder->dev;
638 struct nouveau_drm *drm = nouveau_drm(dev);
639 struct drm_mode_config *conf = &dev->mode_config;
640 struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
641 struct dcb_output *dcb = nouveau_encoder(encoder)->dcb;
642 int num_tv_norms = dcb->tvconf.has_component_output ? NUM_TV_NORMS :
643 NUM_LD_TV_NORMS;
644 int i;
645
646 if (nouveau_tv_norm) {
647 i = match_string(nv17_tv_norm_names, num_tv_norms,
648 nouveau_tv_norm);
649 if (i < 0)
650 NV_WARN(drm, "Invalid TV norm setting \"%s\"\n",
651 nouveau_tv_norm);
652 else
653 tv_enc->tv_norm = i;
654 }
655
656 drm_mode_create_tv_properties(dev, num_tv_norms, nv17_tv_norm_names);
657
658 drm_object_attach_property(&connector->base,
659 conf->tv_select_subconnector_property,
660 tv_enc->select_subconnector);
661 drm_object_attach_property(&connector->base,
662 conf->tv_subconnector_property,
663 tv_enc->subconnector);
664 drm_object_attach_property(&connector->base,
665 conf->tv_mode_property,
666 tv_enc->tv_norm);
667 drm_object_attach_property(&connector->base,
668 conf->tv_flicker_reduction_property,
669 tv_enc->flicker);
670 drm_object_attach_property(&connector->base,
671 conf->tv_saturation_property,
672 tv_enc->saturation);
673 drm_object_attach_property(&connector->base,
674 conf->tv_hue_property,
675 tv_enc->hue);
676 drm_object_attach_property(&connector->base,
677 conf->tv_overscan_property,
678 tv_enc->overscan);
679
680 return 0;
681 }
682
683 static int nv17_tv_set_property(struct drm_encoder *encoder,
684 struct drm_connector *connector,
685 struct drm_property *property,
686 uint64_t val)
687 {
688 struct drm_mode_config *conf = &encoder->dev->mode_config;
689 struct drm_crtc *crtc = encoder->crtc;
690 struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
691 struct nv17_tv_norm_params *tv_norm = get_tv_norm(encoder);
692 bool modes_changed = false;
693
694 if (property == conf->tv_overscan_property) {
695 tv_enc->overscan = val;
696 if (encoder->crtc) {
697 if (tv_norm->kind == CTV_ENC_MODE)
698 nv17_ctv_update_rescaler(encoder);
699 else
700 nv17_tv_update_rescaler(encoder);
701 }
702
703 } else if (property == conf->tv_saturation_property) {
704 if (tv_norm->kind != TV_ENC_MODE)
705 return -EINVAL;
706
707 tv_enc->saturation = val;
708 nv17_tv_update_properties(encoder);
709
710 } else if (property == conf->tv_hue_property) {
711 if (tv_norm->kind != TV_ENC_MODE)
712 return -EINVAL;
713
714 tv_enc->hue = val;
715 nv17_tv_update_properties(encoder);
716
717 } else if (property == conf->tv_flicker_reduction_property) {
718 if (tv_norm->kind != TV_ENC_MODE)
719 return -EINVAL;
720
721 tv_enc->flicker = val;
722 if (encoder->crtc)
723 nv17_tv_update_rescaler(encoder);
724
725 } else if (property == conf->tv_mode_property) {
726 if (connector->dpms != DRM_MODE_DPMS_OFF)
727 return -EINVAL;
728
729 tv_enc->tv_norm = val;
730
731 modes_changed = true;
732
733 } else if (property == conf->tv_select_subconnector_property) {
734 if (tv_norm->kind != TV_ENC_MODE)
735 return -EINVAL;
736
737 tv_enc->select_subconnector = val;
738 nv17_tv_update_properties(encoder);
739
740 } else {
741 return -EINVAL;
742 }
743
744 if (modes_changed) {
745 drm_helper_probe_single_connector_modes(connector, 0, 0);
746
747 /* Disable the crtc to ensure a full modeset is
748 * performed whenever it's turned on again. */
749 if (crtc)
750 drm_crtc_helper_set_mode(crtc, &crtc->mode,
751 crtc->x, crtc->y,
752 crtc->primary->fb);
753 }
754
755 return 0;
756 }
757
758 static void nv17_tv_destroy(struct drm_encoder *encoder)
759 {
760 struct nv17_tv_encoder *tv_enc = to_tv_enc(encoder);
761
762 drm_encoder_cleanup(encoder);
763 kfree(tv_enc);
764 }
765
766 static const struct drm_encoder_helper_funcs nv17_tv_helper_funcs = {
767 .dpms = nv17_tv_dpms,
768 .mode_fixup = nv17_tv_mode_fixup,
769 .prepare = nv17_tv_prepare,
770 .commit = nv17_tv_commit,
771 .mode_set = nv17_tv_mode_set,
772 .detect = nv17_tv_detect,
773 };
774
775 static const struct drm_encoder_slave_funcs nv17_tv_slave_funcs = {
776 .get_modes = nv17_tv_get_modes,
777 .mode_valid = nv17_tv_mode_valid,
778 .create_resources = nv17_tv_create_resources,
779 .set_property = nv17_tv_set_property,
780 };
781
782 static const struct drm_encoder_funcs nv17_tv_funcs = {
783 .destroy = nv17_tv_destroy,
784 };
785
786 int
787 nv17_tv_create(struct drm_connector *connector, struct dcb_output *entry)
788 {
789 struct drm_device *dev = connector->dev;
790 struct drm_encoder *encoder;
791 struct nv17_tv_encoder *tv_enc = NULL;
792
793 tv_enc = kzalloc(sizeof(*tv_enc), GFP_KERNEL);
794 if (!tv_enc)
795 return -ENOMEM;
796
797 tv_enc->overscan = 50;
798 tv_enc->flicker = 50;
799 tv_enc->saturation = 50;
800 tv_enc->hue = 0;
801 tv_enc->tv_norm = TV_NORM_PAL;
802 tv_enc->subconnector = DRM_MODE_SUBCONNECTOR_Unknown;
803 tv_enc->select_subconnector = DRM_MODE_SUBCONNECTOR_Automatic;
804 tv_enc->pin_mask = 0;
805
806 encoder = to_drm_encoder(&tv_enc->base);
807
808 tv_enc->base.dcb = entry;
809 tv_enc->base.or = ffs(entry->or) - 1;
810
811 drm_encoder_init(dev, encoder, &nv17_tv_funcs, DRM_MODE_ENCODER_TVDAC,
812 NULL);
813 drm_encoder_helper_add(encoder, &nv17_tv_helper_funcs);
814 to_encoder_slave(encoder)->slave_funcs = &nv17_tv_slave_funcs;
815
816 tv_enc->base.enc_save = nv17_tv_save;
817 tv_enc->base.enc_restore = nv17_tv_restore;
818
819 encoder->possible_crtcs = entry->heads;
820 encoder->possible_clones = 0;
821
822 nv17_tv_create_resources(encoder, connector);
823 drm_connector_attach_encoder(connector, encoder);
824 return 0;
825 }
Linux with added FPC-III support