?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/i915: cleanup: use ARRAY_SIZE()
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / gpu / drm / i915 / intel_tv.c
blobd61ffbc381e52846f4734f0eb3f3acaaf6f53f0e
1 /*
2 * Copyright © 2006-2008 Intel Corporation
3 * Jesse Barnes <jesse.barnes@intel.com>
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
14 * Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Authors:
25 * Eric Anholt <eric@anholt.net>
26 *
27 */
28
29 /** @file
30 * Integrated TV-out support for the 915GM and 945GM.
31 */
32
33 #include "drmP.h"
34 #include "drm.h"
35 #include "drm_crtc.h"
36 #include "drm_edid.h"
37 #include "intel_drv.h"
38 #include "i915_drm.h"
39 #include "i915_drv.h"
40
41 enum tv_margin {
42 TV_MARGIN_LEFT, TV_MARGIN_TOP,
43 TV_MARGIN_RIGHT, TV_MARGIN_BOTTOM
44 };
45
46 /** Private structure for the integrated TV support */
47 struct intel_tv_priv {
48 int type;
49 char *tv_format;
50 int margin[4];
51 u32 save_TV_H_CTL_1;
52 u32 save_TV_H_CTL_2;
53 u32 save_TV_H_CTL_3;
54 u32 save_TV_V_CTL_1;
55 u32 save_TV_V_CTL_2;
56 u32 save_TV_V_CTL_3;
57 u32 save_TV_V_CTL_4;
58 u32 save_TV_V_CTL_5;
59 u32 save_TV_V_CTL_6;
60 u32 save_TV_V_CTL_7;
61 u32 save_TV_SC_CTL_1, save_TV_SC_CTL_2, save_TV_SC_CTL_3;
62
63 u32 save_TV_CSC_Y;
64 u32 save_TV_CSC_Y2;
65 u32 save_TV_CSC_U;
66 u32 save_TV_CSC_U2;
67 u32 save_TV_CSC_V;
68 u32 save_TV_CSC_V2;
69 u32 save_TV_CLR_KNOBS;
70 u32 save_TV_CLR_LEVEL;
71 u32 save_TV_WIN_POS;
72 u32 save_TV_WIN_SIZE;
73 u32 save_TV_FILTER_CTL_1;
74 u32 save_TV_FILTER_CTL_2;
75 u32 save_TV_FILTER_CTL_3;
76
77 u32 save_TV_H_LUMA[60];
78 u32 save_TV_H_CHROMA[60];
79 u32 save_TV_V_LUMA[43];
80 u32 save_TV_V_CHROMA[43];
81
82 u32 save_TV_DAC;
83 u32 save_TV_CTL;
84 };
85
86 struct video_levels {
87 int blank, black, burst;
88 };
89
90 struct color_conversion {
91 u16 ry, gy, by, ay;
92 u16 ru, gu, bu, au;
93 u16 rv, gv, bv, av;
94 };
95
96 static const u32 filter_table[] = {
97 0xB1403000, 0x2E203500, 0x35002E20, 0x3000B140,
98 0x35A0B160, 0x2DC02E80, 0xB1403480, 0xB1603000,
99 0x2EA03640, 0x34002D80, 0x3000B120, 0x36E0B160,
100 0x2D202EF0, 0xB1203380, 0xB1603000, 0x2F303780,
101 0x33002CC0, 0x3000B100, 0x3820B160, 0x2C802F50,
102 0xB10032A0, 0xB1603000, 0x2F9038C0, 0x32202C20,
103 0x3000B0E0, 0x3980B160, 0x2BC02FC0, 0xB0E031C0,
104 0xB1603000, 0x2FF03A20, 0x31602B60, 0xB020B0C0,
105 0x3AE0B160, 0x2B001810, 0xB0C03120, 0xB140B020,
106 0x18283BA0, 0x30C02A80, 0xB020B0A0, 0x3C60B140,
107 0x2A201838, 0xB0A03080, 0xB120B020, 0x18383D20,
108 0x304029C0, 0xB040B080, 0x3DE0B100, 0x29601848,
109 0xB0803000, 0xB100B040, 0x18483EC0, 0xB0402900,
110 0xB040B060, 0x3F80B0C0, 0x28801858, 0xB060B080,
111 0xB0A0B060, 0x18602820, 0xB0A02820, 0x0000B060,
112 0xB1403000, 0x2E203500, 0x35002E20, 0x3000B140,
113 0x35A0B160, 0x2DC02E80, 0xB1403480, 0xB1603000,
114 0x2EA03640, 0x34002D80, 0x3000B120, 0x36E0B160,
115 0x2D202EF0, 0xB1203380, 0xB1603000, 0x2F303780,
116 0x33002CC0, 0x3000B100, 0x3820B160, 0x2C802F50,
117 0xB10032A0, 0xB1603000, 0x2F9038C0, 0x32202C20,
118 0x3000B0E0, 0x3980B160, 0x2BC02FC0, 0xB0E031C0,
119 0xB1603000, 0x2FF03A20, 0x31602B60, 0xB020B0C0,
120 0x3AE0B160, 0x2B001810, 0xB0C03120, 0xB140B020,
121 0x18283BA0, 0x30C02A80, 0xB020B0A0, 0x3C60B140,
122 0x2A201838, 0xB0A03080, 0xB120B020, 0x18383D20,
123 0x304029C0, 0xB040B080, 0x3DE0B100, 0x29601848,
124 0xB0803000, 0xB100B040, 0x18483EC0, 0xB0402900,
125 0xB040B060, 0x3F80B0C0, 0x28801858, 0xB060B080,
126 0xB0A0B060, 0x18602820, 0xB0A02820, 0x0000B060,
127 0x36403000, 0x2D002CC0, 0x30003640, 0x2D0036C0,
128 0x35C02CC0, 0x37403000, 0x2C802D40, 0x30003540,
129 0x2D8037C0, 0x34C02C40, 0x38403000, 0x2BC02E00,
130 0x30003440, 0x2E2038C0, 0x34002B80, 0x39803000,
131 0x2B402E40, 0x30003380, 0x2E603A00, 0x33402B00,
132 0x3A803040, 0x2A802EA0, 0x30403300, 0x2EC03B40,
133 0x32802A40, 0x3C003040, 0x2A002EC0, 0x30803240,
134 0x2EC03C80, 0x320029C0, 0x3D403080, 0x29402F00,
135 0x308031C0, 0x2F203DC0, 0x31802900, 0x3E8030C0,
136 0x28802F40, 0x30C03140, 0x2F203F40, 0x31402840,
137 0x28003100, 0x28002F00, 0x00003100, 0x36403000,
138 0x2D002CC0, 0x30003640, 0x2D0036C0,
139 0x35C02CC0, 0x37403000, 0x2C802D40, 0x30003540,
140 0x2D8037C0, 0x34C02C40, 0x38403000, 0x2BC02E00,
141 0x30003440, 0x2E2038C0, 0x34002B80, 0x39803000,
142 0x2B402E40, 0x30003380, 0x2E603A00, 0x33402B00,
143 0x3A803040, 0x2A802EA0, 0x30403300, 0x2EC03B40,
144 0x32802A40, 0x3C003040, 0x2A002EC0, 0x30803240,
145 0x2EC03C80, 0x320029C0, 0x3D403080, 0x29402F00,
146 0x308031C0, 0x2F203DC0, 0x31802900, 0x3E8030C0,
147 0x28802F40, 0x30C03140, 0x2F203F40, 0x31402840,
148 0x28003100, 0x28002F00, 0x00003100,
149 };
150
151 /*
152 * Color conversion values have 3 separate fixed point formats:
153 *
154 * 10 bit fields (ay, au)
155 * 1.9 fixed point (b.bbbbbbbbb)
156 * 11 bit fields (ry, by, ru, gu, gv)
157 * exp.mantissa (ee.mmmmmmmmm)
158 * ee = 00 = 10^-1 (0.mmmmmmmmm)
159 * ee = 01 = 10^-2 (0.0mmmmmmmmm)
160 * ee = 10 = 10^-3 (0.00mmmmmmmmm)
161 * ee = 11 = 10^-4 (0.000mmmmmmmmm)
162 * 12 bit fields (gy, rv, bu)
163 * exp.mantissa (eee.mmmmmmmmm)
164 * eee = 000 = 10^-1 (0.mmmmmmmmm)
165 * eee = 001 = 10^-2 (0.0mmmmmmmmm)
166 * eee = 010 = 10^-3 (0.00mmmmmmmmm)
167 * eee = 011 = 10^-4 (0.000mmmmmmmmm)
168 * eee = 100 = reserved
169 * eee = 101 = reserved
170 * eee = 110 = reserved
171 * eee = 111 = 10^0 (m.mmmmmmmm) (only usable for 1.0 representation)
172 *
173 * Saturation and contrast are 8 bits, with their own representation:
174 * 8 bit field (saturation, contrast)
175 * exp.mantissa (ee.mmmmmm)
176 * ee = 00 = 10^-1 (0.mmmmmm)
177 * ee = 01 = 10^0 (m.mmmmm)
178 * ee = 10 = 10^1 (mm.mmmm)
179 * ee = 11 = 10^2 (mmm.mmm)
180 *
181 * Simple conversion function:
182 *
183 * static u32
184 * float_to_csc_11(float f)
185 * {
186 * u32 exp;
187 * u32 mant;
188 * u32 ret;
189 *
190 * if (f < 0)
191 * f = -f;
192 *
193 * if (f >= 1) {
194 * exp = 0x7;
195 * mant = 1 << 8;
196 * } else {
197 * for (exp = 0; exp < 3 && f < 0.5; exp++)
198 * f *= 2.0;
199 * mant = (f * (1 << 9) + 0.5);
200 * if (mant >= (1 << 9))
201 * mant = (1 << 9) - 1;
202 * }
203 * ret = (exp << 9) | mant;
204 * return ret;
205 * }
206 */
207
208 /*
209 * Behold, magic numbers! If we plant them they might grow a big
210 * s-video cable to the sky... or something.
211 *
212 * Pre-converted to appropriate hex value.
213 */
214
215 /*
216 * PAL & NTSC values for composite & s-video connections
217 */
218 static const struct color_conversion ntsc_m_csc_composite = {
219 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0104,
220 .ru = 0x0733, .gu = 0x052d, .bu = 0x05c7, .au = 0x0200,
221 .rv = 0x0340, .gv = 0x030c, .bv = 0x06d0, .av = 0x0200,
222 };
223
224 static const struct video_levels ntsc_m_levels_composite = {
225 .blank = 225, .black = 267, .burst = 113,
226 };
227
228 static const struct color_conversion ntsc_m_csc_svideo = {
229 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0133,
230 .ru = 0x076a, .gu = 0x0564, .bu = 0x030d, .au = 0x0200,
231 .rv = 0x037a, .gv = 0x033d, .bv = 0x06f6, .av = 0x0200,
232 };
233
234 static const struct video_levels ntsc_m_levels_svideo = {
235 .blank = 266, .black = 316, .burst = 133,
236 };
237
238 static const struct color_conversion ntsc_j_csc_composite = {
239 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0119,
240 .ru = 0x074c, .gu = 0x0546, .bu = 0x05ec, .au = 0x0200,
241 .rv = 0x035a, .gv = 0x0322, .bv = 0x06e1, .av = 0x0200,
242 };
243
244 static const struct video_levels ntsc_j_levels_composite = {
245 .blank = 225, .black = 225, .burst = 113,
246 };
247
248 static const struct color_conversion ntsc_j_csc_svideo = {
249 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x014c,
250 .ru = 0x0788, .gu = 0x0581, .bu = 0x0322, .au = 0x0200,
251 .rv = 0x0399, .gv = 0x0356, .bv = 0x070a, .av = 0x0200,
252 };
253
254 static const struct video_levels ntsc_j_levels_svideo = {
255 .blank = 266, .black = 266, .burst = 133,
256 };
257
258 static const struct color_conversion pal_csc_composite = {
259 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0113,
260 .ru = 0x0745, .gu = 0x053f, .bu = 0x05e1, .au = 0x0200,
261 .rv = 0x0353, .gv = 0x031c, .bv = 0x06dc, .av = 0x0200,
262 };
263
264 static const struct video_levels pal_levels_composite = {
265 .blank = 237, .black = 237, .burst = 118,
266 };
267
268 static const struct color_conversion pal_csc_svideo = {
269 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0145,
270 .ru = 0x0780, .gu = 0x0579, .bu = 0x031c, .au = 0x0200,
271 .rv = 0x0390, .gv = 0x034f, .bv = 0x0705, .av = 0x0200,
272 };
273
274 static const struct video_levels pal_levels_svideo = {
275 .blank = 280, .black = 280, .burst = 139,
276 };
277
278 static const struct color_conversion pal_m_csc_composite = {
279 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0104,
280 .ru = 0x0733, .gu = 0x052d, .bu = 0x05c7, .au = 0x0200,
281 .rv = 0x0340, .gv = 0x030c, .bv = 0x06d0, .av = 0x0200,
282 };
283
284 static const struct video_levels pal_m_levels_composite = {
285 .blank = 225, .black = 267, .burst = 113,
286 };
287
288 static const struct color_conversion pal_m_csc_svideo = {
289 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0133,
290 .ru = 0x076a, .gu = 0x0564, .bu = 0x030d, .au = 0x0200,
291 .rv = 0x037a, .gv = 0x033d, .bv = 0x06f6, .av = 0x0200,
292 };
293
294 static const struct video_levels pal_m_levels_svideo = {
295 .blank = 266, .black = 316, .burst = 133,
296 };
297
298 static const struct color_conversion pal_n_csc_composite = {
299 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0104,
300 .ru = 0x0733, .gu = 0x052d, .bu = 0x05c7, .au = 0x0200,
301 .rv = 0x0340, .gv = 0x030c, .bv = 0x06d0, .av = 0x0200,
302 };
303
304 static const struct video_levels pal_n_levels_composite = {
305 .blank = 225, .black = 267, .burst = 118,
306 };
307
308 static const struct color_conversion pal_n_csc_svideo = {
309 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0133,
310 .ru = 0x076a, .gu = 0x0564, .bu = 0x030d, .au = 0x0200,
311 .rv = 0x037a, .gv = 0x033d, .bv = 0x06f6, .av = 0x0200,
312 };
313
314 static const struct video_levels pal_n_levels_svideo = {
315 .blank = 266, .black = 316, .burst = 139,
316 };
317
318 /*
319 * Component connections
320 */
321 static const struct color_conversion sdtv_csc_yprpb = {
322 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0145,
323 .ru = 0x0559, .gu = 0x0353, .bu = 0x0100, .au = 0x0200,
324 .rv = 0x0100, .gv = 0x03ad, .bv = 0x074d, .av = 0x0200,
325 };
326
327 static const struct color_conversion sdtv_csc_rgb = {
328 .ry = 0x0000, .gy = 0x0f00, .by = 0x0000, .ay = 0x0166,
329 .ru = 0x0000, .gu = 0x0000, .bu = 0x0f00, .au = 0x0166,
330 .rv = 0x0f00, .gv = 0x0000, .bv = 0x0000, .av = 0x0166,
331 };
332
333 static const struct color_conversion hdtv_csc_yprpb = {
334 .ry = 0x05b3, .gy = 0x016e, .by = 0x0728, .ay = 0x0145,
335 .ru = 0x07d5, .gu = 0x038b, .bu = 0x0100, .au = 0x0200,
336 .rv = 0x0100, .gv = 0x03d1, .bv = 0x06bc, .av = 0x0200,
337 };
338
339 static const struct color_conversion hdtv_csc_rgb = {
340 .ry = 0x0000, .gy = 0x0f00, .by = 0x0000, .ay = 0x0166,
341 .ru = 0x0000, .gu = 0x0000, .bu = 0x0f00, .au = 0x0166,
342 .rv = 0x0f00, .gv = 0x0000, .bv = 0x0000, .av = 0x0166,
343 };
344
345 static const struct video_levels component_levels = {
346 .blank = 279, .black = 279, .burst = 0,
347 };
348
349
350 struct tv_mode {
351 char *name;
352 int clock;
353 int refresh; /* in millihertz (for precision) */
354 u32 oversample;
355 int hsync_end, hblank_start, hblank_end, htotal;
356 bool progressive, trilevel_sync, component_only;
357 int vsync_start_f1, vsync_start_f2, vsync_len;
358 bool veq_ena;
359 int veq_start_f1, veq_start_f2, veq_len;
360 int vi_end_f1, vi_end_f2, nbr_end;
361 bool burst_ena;
362 int hburst_start, hburst_len;
363 int vburst_start_f1, vburst_end_f1;
364 int vburst_start_f2, vburst_end_f2;
365 int vburst_start_f3, vburst_end_f3;
366 int vburst_start_f4, vburst_end_f4;
367 /*
368 * subcarrier programming
369 */
370 int dda2_size, dda3_size, dda1_inc, dda2_inc, dda3_inc;
371 u32 sc_reset;
372 bool pal_burst;
373 /*
374 * blank/black levels
375 */
376 const struct video_levels *composite_levels, *svideo_levels;
377 const struct color_conversion *composite_color, *svideo_color;
378 const u32 *filter_table;
379 int max_srcw;
380 };
381
382
383 /*
384 * Sub carrier DDA
385 *
386 * I think this works as follows:
387 *
388 * subcarrier freq = pixel_clock * (dda1_inc + dda2_inc / dda2_size) / 4096
389 *
390 * Presumably, when dda3 is added in, it gets to adjust the dda2_inc value
391 *
392 * So,
393 * dda1_ideal = subcarrier/pixel * 4096
394 * dda1_inc = floor (dda1_ideal)
395 * dda2 = dda1_ideal - dda1_inc
396 *
397 * then pick a ratio for dda2 that gives the closest approximation. If
398 * you can't get close enough, you can play with dda3 as well. This
399 * seems likely to happen when dda2 is small as the jumps would be larger
400 *
401 * To invert this,
402 *
403 * pixel_clock = subcarrier * 4096 / (dda1_inc + dda2_inc / dda2_size)
404 *
405 * The constants below were all computed using a 107.520MHz clock
406 */
407
408 /**
409 * Register programming values for TV modes.
410 *
411 * These values account for -1s required.
412 */
413
414 static const struct tv_mode tv_modes[] = {
415 {
416 .name = "NTSC-M",
417 .clock = 108000,
418 .refresh = 29970,
419 .oversample = TV_OVERSAMPLE_8X,
420 .component_only = 0,
421 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 3.580MHz */
422
423 .hsync_end = 64, .hblank_end = 124,
424 .hblank_start = 836, .htotal = 857,
425
426 .progressive = false, .trilevel_sync = false,
427
428 .vsync_start_f1 = 6, .vsync_start_f2 = 7,
429 .vsync_len = 6,
430
431 .veq_ena = true, .veq_start_f1 = 0,
432 .veq_start_f2 = 1, .veq_len = 18,
433
434 .vi_end_f1 = 20, .vi_end_f2 = 21,
435 .nbr_end = 240,
436
437 .burst_ena = true,
438 .hburst_start = 72, .hburst_len = 34,
439 .vburst_start_f1 = 9, .vburst_end_f1 = 240,
440 .vburst_start_f2 = 10, .vburst_end_f2 = 240,
441 .vburst_start_f3 = 9, .vburst_end_f3 = 240,
442 .vburst_start_f4 = 10, .vburst_end_f4 = 240,
443
444 /* desired 3.5800000 actual 3.5800000 clock 107.52 */
445 .dda1_inc = 135,
446 .dda2_inc = 20800, .dda2_size = 27456,
447 .dda3_inc = 0, .dda3_size = 0,
448 .sc_reset = TV_SC_RESET_EVERY_4,
449 .pal_burst = false,
450
451 .composite_levels = &ntsc_m_levels_composite,
452 .composite_color = &ntsc_m_csc_composite,
453 .svideo_levels = &ntsc_m_levels_svideo,
454 .svideo_color = &ntsc_m_csc_svideo,
455
456 .filter_table = filter_table,
457 },
458 {
459 .name = "NTSC-443",
460 .clock = 108000,
461 .refresh = 29970,
462 .oversample = TV_OVERSAMPLE_8X,
463 .component_only = 0,
464 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 4.43MHz */
465 .hsync_end = 64, .hblank_end = 124,
466 .hblank_start = 836, .htotal = 857,
467
468 .progressive = false, .trilevel_sync = false,
469
470 .vsync_start_f1 = 6, .vsync_start_f2 = 7,
471 .vsync_len = 6,
472
473 .veq_ena = true, .veq_start_f1 = 0,
474 .veq_start_f2 = 1, .veq_len = 18,
475
476 .vi_end_f1 = 20, .vi_end_f2 = 21,
477 .nbr_end = 240,
478
479 .burst_ena = true,
480 .hburst_start = 72, .hburst_len = 34,
481 .vburst_start_f1 = 9, .vburst_end_f1 = 240,
482 .vburst_start_f2 = 10, .vburst_end_f2 = 240,
483 .vburst_start_f3 = 9, .vburst_end_f3 = 240,
484 .vburst_start_f4 = 10, .vburst_end_f4 = 240,
485
486 /* desired 4.4336180 actual 4.4336180 clock 107.52 */
487 .dda1_inc = 168,
488 .dda2_inc = 4093, .dda2_size = 27456,
489 .dda3_inc = 310, .dda3_size = 525,
490 .sc_reset = TV_SC_RESET_NEVER,
491 .pal_burst = false,
492
493 .composite_levels = &ntsc_m_levels_composite,
494 .composite_color = &ntsc_m_csc_composite,
495 .svideo_levels = &ntsc_m_levels_svideo,
496 .svideo_color = &ntsc_m_csc_svideo,
497
498 .filter_table = filter_table,
499 },
500 {
501 .name = "NTSC-J",
502 .clock = 108000,
503 .refresh = 29970,
504 .oversample = TV_OVERSAMPLE_8X,
505 .component_only = 0,
506
507 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 3.580MHz */
508 .hsync_end = 64, .hblank_end = 124,
509 .hblank_start = 836, .htotal = 857,
510
511 .progressive = false, .trilevel_sync = false,
512
513 .vsync_start_f1 = 6, .vsync_start_f2 = 7,
514 .vsync_len = 6,
515
516 .veq_ena = true, .veq_start_f1 = 0,
517 .veq_start_f2 = 1, .veq_len = 18,
518
519 .vi_end_f1 = 20, .vi_end_f2 = 21,
520 .nbr_end = 240,
521
522 .burst_ena = true,
523 .hburst_start = 72, .hburst_len = 34,
524 .vburst_start_f1 = 9, .vburst_end_f1 = 240,
525 .vburst_start_f2 = 10, .vburst_end_f2 = 240,
526 .vburst_start_f3 = 9, .vburst_end_f3 = 240,
527 .vburst_start_f4 = 10, .vburst_end_f4 = 240,
528
529 /* desired 3.5800000 actual 3.5800000 clock 107.52 */
530 .dda1_inc = 135,
531 .dda2_inc = 20800, .dda2_size = 27456,
532 .dda3_inc = 0, .dda3_size = 0,
533 .sc_reset = TV_SC_RESET_EVERY_4,
534 .pal_burst = false,
535
536 .composite_levels = &ntsc_j_levels_composite,
537 .composite_color = &ntsc_j_csc_composite,
538 .svideo_levels = &ntsc_j_levels_svideo,
539 .svideo_color = &ntsc_j_csc_svideo,
540
541 .filter_table = filter_table,
542 },
543 {
544 .name = "PAL-M",
545 .clock = 108000,
546 .refresh = 29970,
547 .oversample = TV_OVERSAMPLE_8X,
548 .component_only = 0,
549
550 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 3.580MHz */
551 .hsync_end = 64, .hblank_end = 124,
552 .hblank_start = 836, .htotal = 857,
553
554 .progressive = false, .trilevel_sync = false,
555
556 .vsync_start_f1 = 6, .vsync_start_f2 = 7,
557 .vsync_len = 6,
558
559 .veq_ena = true, .veq_start_f1 = 0,
560 .veq_start_f2 = 1, .veq_len = 18,
561
562 .vi_end_f1 = 20, .vi_end_f2 = 21,
563 .nbr_end = 240,
564
565 .burst_ena = true,
566 .hburst_start = 72, .hburst_len = 34,
567 .vburst_start_f1 = 9, .vburst_end_f1 = 240,
568 .vburst_start_f2 = 10, .vburst_end_f2 = 240,
569 .vburst_start_f3 = 9, .vburst_end_f3 = 240,
570 .vburst_start_f4 = 10, .vburst_end_f4 = 240,
571
572 /* desired 3.5800000 actual 3.5800000 clock 107.52 */
573 .dda1_inc = 135,
574 .dda2_inc = 16704, .dda2_size = 27456,
575 .dda3_inc = 0, .dda3_size = 0,
576 .sc_reset = TV_SC_RESET_EVERY_8,
577 .pal_burst = true,
578
579 .composite_levels = &pal_m_levels_composite,
580 .composite_color = &pal_m_csc_composite,
581 .svideo_levels = &pal_m_levels_svideo,
582 .svideo_color = &pal_m_csc_svideo,
583
584 .filter_table = filter_table,
585 },
586 {
587 /* 625 Lines, 50 Fields, 15.625KHz line, Sub-Carrier 4.434MHz */
588 .name = "PAL-N",
589 .clock = 108000,
590 .refresh = 25000,
591 .oversample = TV_OVERSAMPLE_8X,
592 .component_only = 0,
593
594 .hsync_end = 64, .hblank_end = 128,
595 .hblank_start = 844, .htotal = 863,
596
597 .progressive = false, .trilevel_sync = false,
598
599
600 .vsync_start_f1 = 6, .vsync_start_f2 = 7,
601 .vsync_len = 6,
602
603 .veq_ena = true, .veq_start_f1 = 0,
604 .veq_start_f2 = 1, .veq_len = 18,
605
606 .vi_end_f1 = 24, .vi_end_f2 = 25,
607 .nbr_end = 286,
608
609 .burst_ena = true,
610 .hburst_start = 73, .hburst_len = 34,
611 .vburst_start_f1 = 8, .vburst_end_f1 = 285,
612 .vburst_start_f2 = 8, .vburst_end_f2 = 286,
613 .vburst_start_f3 = 9, .vburst_end_f3 = 286,
614 .vburst_start_f4 = 9, .vburst_end_f4 = 285,
615
616
617 /* desired 4.4336180 actual 4.4336180 clock 107.52 */
618 .dda1_inc = 135,
619 .dda2_inc = 23578, .dda2_size = 27648,
620 .dda3_inc = 134, .dda3_size = 625,
621 .sc_reset = TV_SC_RESET_EVERY_8,
622 .pal_burst = true,
623
624 .composite_levels = &pal_n_levels_composite,
625 .composite_color = &pal_n_csc_composite,
626 .svideo_levels = &pal_n_levels_svideo,
627 .svideo_color = &pal_n_csc_svideo,
628
629 .filter_table = filter_table,
630 },
631 {
632 /* 625 Lines, 50 Fields, 15.625KHz line, Sub-Carrier 4.434MHz */
633 .name = "PAL",
634 .clock = 108000,
635 .refresh = 25000,
636 .oversample = TV_OVERSAMPLE_8X,
637 .component_only = 0,
638
639 .hsync_end = 64, .hblank_end = 142,
640 .hblank_start = 844, .htotal = 863,
641
642 .progressive = false, .trilevel_sync = false,
643
644 .vsync_start_f1 = 5, .vsync_start_f2 = 6,
645 .vsync_len = 5,
646
647 .veq_ena = true, .veq_start_f1 = 0,
648 .veq_start_f2 = 1, .veq_len = 15,
649
650 .vi_end_f1 = 24, .vi_end_f2 = 25,
651 .nbr_end = 286,
652
653 .burst_ena = true,
654 .hburst_start = 73, .hburst_len = 32,
655 .vburst_start_f1 = 8, .vburst_end_f1 = 285,
656 .vburst_start_f2 = 8, .vburst_end_f2 = 286,
657 .vburst_start_f3 = 9, .vburst_end_f3 = 286,
658 .vburst_start_f4 = 9, .vburst_end_f4 = 285,
659
660 /* desired 4.4336180 actual 4.4336180 clock 107.52 */
661 .dda1_inc = 168,
662 .dda2_inc = 4122, .dda2_size = 27648,
663 .dda3_inc = 67, .dda3_size = 625,
664 .sc_reset = TV_SC_RESET_EVERY_8,
665 .pal_burst = true,
666
667 .composite_levels = &pal_levels_composite,
668 .composite_color = &pal_csc_composite,
669 .svideo_levels = &pal_levels_svideo,
670 .svideo_color = &pal_csc_svideo,
671
672 .filter_table = filter_table,
673 },
674 {
675 .name = "480p@59.94Hz",
676 .clock = 107520,
677 .refresh = 59940,
678 .oversample = TV_OVERSAMPLE_4X,
679 .component_only = 1,
680
681 .hsync_end = 64, .hblank_end = 122,
682 .hblank_start = 842, .htotal = 857,
683
684 .progressive = true,.trilevel_sync = false,
685
686 .vsync_start_f1 = 12, .vsync_start_f2 = 12,
687 .vsync_len = 12,
688
689 .veq_ena = false,
690
691 .vi_end_f1 = 44, .vi_end_f2 = 44,
692 .nbr_end = 479,
693
694 .burst_ena = false,
695
696 .filter_table = filter_table,
697 },
698 {
699 .name = "480p@60Hz",
700 .clock = 107520,
701 .refresh = 60000,
702 .oversample = TV_OVERSAMPLE_4X,
703 .component_only = 1,
704
705 .hsync_end = 64, .hblank_end = 122,
706 .hblank_start = 842, .htotal = 856,
707
708 .progressive = true,.trilevel_sync = false,
709
710 .vsync_start_f1 = 12, .vsync_start_f2 = 12,
711 .vsync_len = 12,
712
713 .veq_ena = false,
714
715 .vi_end_f1 = 44, .vi_end_f2 = 44,
716 .nbr_end = 479,
717
718 .burst_ena = false,
719
720 .filter_table = filter_table,
721 },
722 {
723 .name = "576p",
724 .clock = 107520,
725 .refresh = 50000,
726 .oversample = TV_OVERSAMPLE_4X,
727 .component_only = 1,
728
729 .hsync_end = 64, .hblank_end = 139,
730 .hblank_start = 859, .htotal = 863,
731
732 .progressive = true, .trilevel_sync = false,
733
734 .vsync_start_f1 = 10, .vsync_start_f2 = 10,
735 .vsync_len = 10,
736
737 .veq_ena = false,
738
739 .vi_end_f1 = 48, .vi_end_f2 = 48,
740 .nbr_end = 575,
741
742 .burst_ena = false,
743
744 .filter_table = filter_table,
745 },
746 {
747 .name = "720p@60Hz",
748 .clock = 148800,
749 .refresh = 60000,
750 .oversample = TV_OVERSAMPLE_2X,
751 .component_only = 1,
752
753 .hsync_end = 80, .hblank_end = 300,
754 .hblank_start = 1580, .htotal = 1649,
755
756 .progressive = true, .trilevel_sync = true,
757
758 .vsync_start_f1 = 10, .vsync_start_f2 = 10,
759 .vsync_len = 10,
760
761 .veq_ena = false,
762
763 .vi_end_f1 = 29, .vi_end_f2 = 29,
764 .nbr_end = 719,
765
766 .burst_ena = false,
767
768 .filter_table = filter_table,
769 },
770 {
771 .name = "720p@59.94Hz",
772 .clock = 148800,
773 .refresh = 59940,
774 .oversample = TV_OVERSAMPLE_2X,
775 .component_only = 1,
776
777 .hsync_end = 80, .hblank_end = 300,
778 .hblank_start = 1580, .htotal = 1651,
779
780 .progressive = true, .trilevel_sync = true,
781
782 .vsync_start_f1 = 10, .vsync_start_f2 = 10,
783 .vsync_len = 10,
784
785 .veq_ena = false,
786
787 .vi_end_f1 = 29, .vi_end_f2 = 29,
788 .nbr_end = 719,
789
790 .burst_ena = false,
791
792 .filter_table = filter_table,
793 },
794 {
795 .name = "720p@50Hz",
796 .clock = 148800,
797 .refresh = 50000,
798 .oversample = TV_OVERSAMPLE_2X,
799 .component_only = 1,
800
801 .hsync_end = 80, .hblank_end = 300,
802 .hblank_start = 1580, .htotal = 1979,
803
804 .progressive = true, .trilevel_sync = true,
805
806 .vsync_start_f1 = 10, .vsync_start_f2 = 10,
807 .vsync_len = 10,
808
809 .veq_ena = false,
810
811 .vi_end_f1 = 29, .vi_end_f2 = 29,
812 .nbr_end = 719,
813
814 .burst_ena = false,
815
816 .filter_table = filter_table,
817 .max_srcw = 800
818 },
819 {
820 .name = "1080i@50Hz",
821 .clock = 148800,
822 .refresh = 25000,
823 .oversample = TV_OVERSAMPLE_2X,
824 .component_only = 1,
825
826 .hsync_end = 88, .hblank_end = 235,
827 .hblank_start = 2155, .htotal = 2639,
828
829 .progressive = false, .trilevel_sync = true,
830
831 .vsync_start_f1 = 4, .vsync_start_f2 = 5,
832 .vsync_len = 10,
833
834 .veq_ena = true, .veq_start_f1 = 4,
835 .veq_start_f2 = 4, .veq_len = 10,
836
837
838 .vi_end_f1 = 21, .vi_end_f2 = 22,
839 .nbr_end = 539,
840
841 .burst_ena = false,
842
843 .filter_table = filter_table,
844 },
845 {
846 .name = "1080i@60Hz",
847 .clock = 148800,
848 .refresh = 30000,
849 .oversample = TV_OVERSAMPLE_2X,
850 .component_only = 1,
851
852 .hsync_end = 88, .hblank_end = 235,
853 .hblank_start = 2155, .htotal = 2199,
854
855 .progressive = false, .trilevel_sync = true,
856
857 .vsync_start_f1 = 4, .vsync_start_f2 = 5,
858 .vsync_len = 10,
859
860 .veq_ena = true, .veq_start_f1 = 4,
861 .veq_start_f2 = 4, .veq_len = 10,
862
863
864 .vi_end_f1 = 21, .vi_end_f2 = 22,
865 .nbr_end = 539,
866
867 .burst_ena = false,
868
869 .filter_table = filter_table,
870 },
871 {
872 .name = "1080i@59.94Hz",
873 .clock = 148800,
874 .refresh = 29970,
875 .oversample = TV_OVERSAMPLE_2X,
876 .component_only = 1,
877
878 .hsync_end = 88, .hblank_end = 235,
879 .hblank_start = 2155, .htotal = 2201,
880
881 .progressive = false, .trilevel_sync = true,
882
883 .vsync_start_f1 = 4, .vsync_start_f2 = 5,
884 .vsync_len = 10,
885
886 .veq_ena = true, .veq_start_f1 = 4,
887 .veq_start_f2 = 4, .veq_len = 10,
888
889
890 .vi_end_f1 = 21, .vi_end_f2 = 22,
891 .nbr_end = 539,
892
893 .burst_ena = false,
894
895 .filter_table = filter_table,
896 },
897 };
898
899 static void
900 intel_tv_dpms(struct drm_encoder *encoder, int mode)
901 {
902 struct drm_device *dev = encoder->dev;
903 struct drm_i915_private *dev_priv = dev->dev_private;
904
905 switch(mode) {
906 case DRM_MODE_DPMS_ON:
907 I915_WRITE(TV_CTL, I915_READ(TV_CTL) | TV_ENC_ENABLE);
908 break;
909 case DRM_MODE_DPMS_STANDBY:
910 case DRM_MODE_DPMS_SUSPEND:
911 case DRM_MODE_DPMS_OFF:
912 I915_WRITE(TV_CTL, I915_READ(TV_CTL) & ~TV_ENC_ENABLE);
913 break;
914 }
915 }
916
917 static const struct tv_mode *
918 intel_tv_mode_lookup (char *tv_format)
919 {
920 int i;
921
922 for (i = 0; i < sizeof(tv_modes) / sizeof (tv_modes[0]); i++) {
923 const struct tv_mode *tv_mode = &tv_modes[i];
924
925 if (!strcmp(tv_format, tv_mode->name))
926 return tv_mode;
927 }
928 return NULL;
929 }
930
931 static const struct tv_mode *
932 intel_tv_mode_find (struct intel_encoder *intel_encoder)
933 {
934 struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
935
936 return intel_tv_mode_lookup(tv_priv->tv_format);
937 }
938
939 static enum drm_mode_status
940 intel_tv_mode_valid(struct drm_connector *connector, struct drm_display_mode *mode)
941 {
942 struct drm_encoder *encoder = intel_attached_encoder(connector);
943 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
944 const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
945
946 /* Ensure TV refresh is close to desired refresh */
947 if (tv_mode && abs(tv_mode->refresh - drm_mode_vrefresh(mode) * 1000)
948 < 1000)
949 return MODE_OK;
950 return MODE_CLOCK_RANGE;
951 }
952
953
954 static bool
955 intel_tv_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode,
956 struct drm_display_mode *adjusted_mode)
957 {
958 struct drm_device *dev = encoder->dev;
959 struct drm_mode_config *drm_config = &dev->mode_config;
960 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
961 const struct tv_mode *tv_mode = intel_tv_mode_find (intel_encoder);
962 struct drm_encoder *other_encoder;
963
964 if (!tv_mode)
965 return false;
966
967 /* FIXME: lock encoder list */
968 list_for_each_entry(other_encoder, &drm_config->encoder_list, head) {
969 if (other_encoder != encoder &&
970 other_encoder->crtc == encoder->crtc)
971 return false;
972 }
973
974 adjusted_mode->clock = tv_mode->clock;
975 return true;
976 }
977
978 static void
979 intel_tv_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
980 struct drm_display_mode *adjusted_mode)
981 {
982 struct drm_device *dev = encoder->dev;
983 struct drm_i915_private *dev_priv = dev->dev_private;
984 struct drm_crtc *crtc = encoder->crtc;
985 struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
986 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
987 struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
988 const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
989 u32 tv_ctl;
990 u32 hctl1, hctl2, hctl3;
991 u32 vctl1, vctl2, vctl3, vctl4, vctl5, vctl6, vctl7;
992 u32 scctl1, scctl2, scctl3;
993 int i, j;
994 const struct video_levels *video_levels;
995 const struct color_conversion *color_conversion;
996 bool burst_ena;
997
998 if (!tv_mode)
999 return; /* can't happen (mode_prepare prevents this) */
1000
1001 tv_ctl = I915_READ(TV_CTL);
1002 tv_ctl &= TV_CTL_SAVE;
1003
1004 switch (tv_priv->type) {
1005 default:
1006 case DRM_MODE_CONNECTOR_Unknown:
1007 case DRM_MODE_CONNECTOR_Composite:
1008 tv_ctl |= TV_ENC_OUTPUT_COMPOSITE;
1009 video_levels = tv_mode->composite_levels;
1010 color_conversion = tv_mode->composite_color;
1011 burst_ena = tv_mode->burst_ena;
1012 break;
1013 case DRM_MODE_CONNECTOR_Component:
1014 tv_ctl |= TV_ENC_OUTPUT_COMPONENT;
1015 video_levels = &component_levels;
1016 if (tv_mode->burst_ena)
1017 color_conversion = &sdtv_csc_yprpb;
1018 else
1019 color_conversion = &hdtv_csc_yprpb;
1020 burst_ena = false;
1021 break;
1022 case DRM_MODE_CONNECTOR_SVIDEO:
1023 tv_ctl |= TV_ENC_OUTPUT_SVIDEO;
1024 video_levels = tv_mode->svideo_levels;
1025 color_conversion = tv_mode->svideo_color;
1026 burst_ena = tv_mode->burst_ena;
1027 break;
1028 }
1029 hctl1 = (tv_mode->hsync_end << TV_HSYNC_END_SHIFT) |
1030 (tv_mode->htotal << TV_HTOTAL_SHIFT);
1031
1032 hctl2 = (tv_mode->hburst_start << 16) |
1033 (tv_mode->hburst_len << TV_HBURST_LEN_SHIFT);
1034
1035 if (burst_ena)
1036 hctl2 |= TV_BURST_ENA;
1037
1038 hctl3 = (tv_mode->hblank_start << TV_HBLANK_START_SHIFT) |
1039 (tv_mode->hblank_end << TV_HBLANK_END_SHIFT);
1040
1041 vctl1 = (tv_mode->nbr_end << TV_NBR_END_SHIFT) |
1042 (tv_mode->vi_end_f1 << TV_VI_END_F1_SHIFT) |
1043 (tv_mode->vi_end_f2 << TV_VI_END_F2_SHIFT);
1044
1045 vctl2 = (tv_mode->vsync_len << TV_VSYNC_LEN_SHIFT) |
1046 (tv_mode->vsync_start_f1 << TV_VSYNC_START_F1_SHIFT) |
1047 (tv_mode->vsync_start_f2 << TV_VSYNC_START_F2_SHIFT);
1048
1049 vctl3 = (tv_mode->veq_len << TV_VEQ_LEN_SHIFT) |
1050 (tv_mode->veq_start_f1 << TV_VEQ_START_F1_SHIFT) |
1051 (tv_mode->veq_start_f2 << TV_VEQ_START_F2_SHIFT);
1052
1053 if (tv_mode->veq_ena)
1054 vctl3 |= TV_EQUAL_ENA;
1055
1056 vctl4 = (tv_mode->vburst_start_f1 << TV_VBURST_START_F1_SHIFT) |
1057 (tv_mode->vburst_end_f1 << TV_VBURST_END_F1_SHIFT);
1058
1059 vctl5 = (tv_mode->vburst_start_f2 << TV_VBURST_START_F2_SHIFT) |
1060 (tv_mode->vburst_end_f2 << TV_VBURST_END_F2_SHIFT);
1061
1062 vctl6 = (tv_mode->vburst_start_f3 << TV_VBURST_START_F3_SHIFT) |
1063 (tv_mode->vburst_end_f3 << TV_VBURST_END_F3_SHIFT);
1064
1065 vctl7 = (tv_mode->vburst_start_f4 << TV_VBURST_START_F4_SHIFT) |
1066 (tv_mode->vburst_end_f4 << TV_VBURST_END_F4_SHIFT);
1067
1068 if (intel_crtc->pipe == 1)
1069 tv_ctl |= TV_ENC_PIPEB_SELECT;
1070 tv_ctl |= tv_mode->oversample;
1071
1072 if (tv_mode->progressive)
1073 tv_ctl |= TV_PROGRESSIVE;
1074 if (tv_mode->trilevel_sync)
1075 tv_ctl |= TV_TRILEVEL_SYNC;
1076 if (tv_mode->pal_burst)
1077 tv_ctl |= TV_PAL_BURST;
1078
1079 scctl1 = 0;
1080 if (tv_mode->dda1_inc)
1081 scctl1 |= TV_SC_DDA1_EN;
1082 if (tv_mode->dda2_inc)
1083 scctl1 |= TV_SC_DDA2_EN;
1084 if (tv_mode->dda3_inc)
1085 scctl1 |= TV_SC_DDA3_EN;
1086 scctl1 |= tv_mode->sc_reset;
1087 if (video_levels)
1088 scctl1 |= video_levels->burst << TV_BURST_LEVEL_SHIFT;
1089 scctl1 |= tv_mode->dda1_inc << TV_SCDDA1_INC_SHIFT;
1090
1091 scctl2 = tv_mode->dda2_size << TV_SCDDA2_SIZE_SHIFT |
1092 tv_mode->dda2_inc << TV_SCDDA2_INC_SHIFT;
1093
1094 scctl3 = tv_mode->dda3_size << TV_SCDDA3_SIZE_SHIFT |
1095 tv_mode->dda3_inc << TV_SCDDA3_INC_SHIFT;
1096
1097 /* Enable two fixes for the chips that need them. */
1098 if (dev->pci_device < 0x2772)
1099 tv_ctl |= TV_ENC_C0_FIX | TV_ENC_SDP_FIX;
1100
1101 I915_WRITE(TV_H_CTL_1, hctl1);
1102 I915_WRITE(TV_H_CTL_2, hctl2);
1103 I915_WRITE(TV_H_CTL_3, hctl3);
1104 I915_WRITE(TV_V_CTL_1, vctl1);
1105 I915_WRITE(TV_V_CTL_2, vctl2);
1106 I915_WRITE(TV_V_CTL_3, vctl3);
1107 I915_WRITE(TV_V_CTL_4, vctl4);
1108 I915_WRITE(TV_V_CTL_5, vctl5);
1109 I915_WRITE(TV_V_CTL_6, vctl6);
1110 I915_WRITE(TV_V_CTL_7, vctl7);
1111 I915_WRITE(TV_SC_CTL_1, scctl1);
1112 I915_WRITE(TV_SC_CTL_2, scctl2);
1113 I915_WRITE(TV_SC_CTL_3, scctl3);
1114
1115 if (color_conversion) {
1116 I915_WRITE(TV_CSC_Y, (color_conversion->ry << 16) |
1117 color_conversion->gy);
1118 I915_WRITE(TV_CSC_Y2,(color_conversion->by << 16) |
1119 color_conversion->ay);
1120 I915_WRITE(TV_CSC_U, (color_conversion->ru << 16) |
1121 color_conversion->gu);
1122 I915_WRITE(TV_CSC_U2, (color_conversion->bu << 16) |
1123 color_conversion->au);
1124 I915_WRITE(TV_CSC_V, (color_conversion->rv << 16) |
1125 color_conversion->gv);
1126 I915_WRITE(TV_CSC_V2, (color_conversion->bv << 16) |
1127 color_conversion->av);
1128 }
1129
1130 if (IS_I965G(dev))
1131 I915_WRITE(TV_CLR_KNOBS, 0x00404000);
1132 else
1133 I915_WRITE(TV_CLR_KNOBS, 0x00606000);
1134
1135 if (video_levels)
1136 I915_WRITE(TV_CLR_LEVEL,
1137 ((video_levels->black << TV_BLACK_LEVEL_SHIFT) |
1138 (video_levels->blank << TV_BLANK_LEVEL_SHIFT)));
1139 {
1140 int pipeconf_reg = (intel_crtc->pipe == 0) ?
1141 PIPEACONF : PIPEBCONF;
1142 int dspcntr_reg = (intel_crtc->plane == 0) ?
1143 DSPACNTR : DSPBCNTR;
1144 int pipeconf = I915_READ(pipeconf_reg);
1145 int dspcntr = I915_READ(dspcntr_reg);
1146 int dspbase_reg = (intel_crtc->plane == 0) ?
1147 DSPAADDR : DSPBADDR;
1148 int xpos = 0x0, ypos = 0x0;
1149 unsigned int xsize, ysize;
1150 /* Pipe must be off here */
1151 I915_WRITE(dspcntr_reg, dspcntr & ~DISPLAY_PLANE_ENABLE);
1152 /* Flush the plane changes */
1153 I915_WRITE(dspbase_reg, I915_READ(dspbase_reg));
1154
1155 /* Wait for vblank for the disable to take effect */
1156 if (!IS_I9XX(dev))
1157 intel_wait_for_vblank(dev);
1158
1159 I915_WRITE(pipeconf_reg, pipeconf & ~PIPEACONF_ENABLE);
1160 /* Wait for vblank for the disable to take effect. */
1161 intel_wait_for_vblank(dev);
1162
1163 /* Filter ctl must be set before TV_WIN_SIZE */
1164 I915_WRITE(TV_FILTER_CTL_1, TV_AUTO_SCALE);
1165 xsize = tv_mode->hblank_start - tv_mode->hblank_end;
1166 if (tv_mode->progressive)
1167 ysize = tv_mode->nbr_end + 1;
1168 else
1169 ysize = 2*tv_mode->nbr_end + 1;
1170
1171 xpos += tv_priv->margin[TV_MARGIN_LEFT];
1172 ypos += tv_priv->margin[TV_MARGIN_TOP];
1173 xsize -= (tv_priv->margin[TV_MARGIN_LEFT] +
1174 tv_priv->margin[TV_MARGIN_RIGHT]);
1175 ysize -= (tv_priv->margin[TV_MARGIN_TOP] +
1176 tv_priv->margin[TV_MARGIN_BOTTOM]);
1177 I915_WRITE(TV_WIN_POS, (xpos<<16)|ypos);
1178 I915_WRITE(TV_WIN_SIZE, (xsize<<16)|ysize);
1179
1180 I915_WRITE(pipeconf_reg, pipeconf);
1181 I915_WRITE(dspcntr_reg, dspcntr);
1182 /* Flush the plane changes */
1183 I915_WRITE(dspbase_reg, I915_READ(dspbase_reg));
1184 }
1185
1186 j = 0;
1187 for (i = 0; i < 60; i++)
1188 I915_WRITE(TV_H_LUMA_0 + (i<<2), tv_mode->filter_table[j++]);
1189 for (i = 0; i < 60; i++)
1190 I915_WRITE(TV_H_CHROMA_0 + (i<<2), tv_mode->filter_table[j++]);
1191 for (i = 0; i < 43; i++)
1192 I915_WRITE(TV_V_LUMA_0 + (i<<2), tv_mode->filter_table[j++]);
1193 for (i = 0; i < 43; i++)
1194 I915_WRITE(TV_V_CHROMA_0 + (i<<2), tv_mode->filter_table[j++]);
1195 I915_WRITE(TV_DAC, 0);
1196 I915_WRITE(TV_CTL, tv_ctl);
1197 }
1198
1199 static const struct drm_display_mode reported_modes[] = {
1200 {
1201 .name = "NTSC 480i",
1202 .clock = 107520,
1203 .hdisplay = 1280,
1204 .hsync_start = 1368,
1205 .hsync_end = 1496,
1206 .htotal = 1712,
1207
1208 .vdisplay = 1024,
1209 .vsync_start = 1027,
1210 .vsync_end = 1034,
1211 .vtotal = 1104,
1212 .type = DRM_MODE_TYPE_DRIVER,
1213 },
1214 };
1215
1216 /**
1217 * Detects TV presence by checking for load.
1218 *
1219 * Requires that the current pipe's DPLL is active.
1220
1221 * \return true if TV is connected.
1222 * \return false if TV is disconnected.
1223 */
1224 static int
1225 intel_tv_detect_type (struct drm_crtc *crtc, struct intel_encoder *intel_encoder)
1226 {
1227 struct drm_encoder *encoder = &intel_encoder->enc;
1228 struct drm_device *dev = encoder->dev;
1229 struct drm_i915_private *dev_priv = dev->dev_private;
1230 unsigned long irqflags;
1231 u32 tv_ctl, save_tv_ctl;
1232 u32 tv_dac, save_tv_dac;
1233 int type = DRM_MODE_CONNECTOR_Unknown;
1234
1235 tv_dac = I915_READ(TV_DAC);
1236
1237 /* Disable TV interrupts around load detect or we'll recurse */
1238 spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
1239 i915_disable_pipestat(dev_priv, 0, PIPE_HOTPLUG_INTERRUPT_ENABLE |
1240 PIPE_HOTPLUG_TV_INTERRUPT_ENABLE);
1241 spin_unlock_irqrestore(&dev_priv->user_irq_lock, irqflags);
1242
1243 /*
1244 * Detect TV by polling)
1245 */
1246 save_tv_dac = tv_dac;
1247 tv_ctl = I915_READ(TV_CTL);
1248 save_tv_ctl = tv_ctl;
1249 tv_ctl &= ~TV_ENC_ENABLE;
1250 tv_ctl &= ~TV_TEST_MODE_MASK;
1251 tv_ctl |= TV_TEST_MODE_MONITOR_DETECT;
1252 tv_dac &= ~TVDAC_SENSE_MASK;
1253 tv_dac &= ~DAC_A_MASK;
1254 tv_dac &= ~DAC_B_MASK;
1255 tv_dac &= ~DAC_C_MASK;
1256 tv_dac |= (TVDAC_STATE_CHG_EN |
1257 TVDAC_A_SENSE_CTL |
1258 TVDAC_B_SENSE_CTL |
1259 TVDAC_C_SENSE_CTL |
1260 DAC_CTL_OVERRIDE |
1261 DAC_A_0_7_V |
1262 DAC_B_0_7_V |
1263 DAC_C_0_7_V);
1264 I915_WRITE(TV_CTL, tv_ctl);
1265 I915_WRITE(TV_DAC, tv_dac);
1266 intel_wait_for_vblank(dev);
1267 tv_dac = I915_READ(TV_DAC);
1268 I915_WRITE(TV_DAC, save_tv_dac);
1269 I915_WRITE(TV_CTL, save_tv_ctl);
1270 intel_wait_for_vblank(dev);
1271 /*
1272 * A B C
1273 * 0 1 1 Composite
1274 * 1 0 X svideo
1275 * 0 0 0 Component
1276 */
1277 if ((tv_dac & TVDAC_SENSE_MASK) == (TVDAC_B_SENSE | TVDAC_C_SENSE)) {
1278 DRM_DEBUG_KMS("Detected Composite TV connection\n");
1279 type = DRM_MODE_CONNECTOR_Composite;
1280 } else if ((tv_dac & (TVDAC_A_SENSE|TVDAC_B_SENSE)) == TVDAC_A_SENSE) {
1281 DRM_DEBUG_KMS("Detected S-Video TV connection\n");
1282 type = DRM_MODE_CONNECTOR_SVIDEO;
1283 } else if ((tv_dac & TVDAC_SENSE_MASK) == 0) {
1284 DRM_DEBUG_KMS("Detected Component TV connection\n");
1285 type = DRM_MODE_CONNECTOR_Component;
1286 } else {
1287 DRM_DEBUG_KMS("No TV connection detected\n");
1288 type = -1;
1289 }
1290
1291 /* Restore interrupt config */
1292 spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
1293 i915_enable_pipestat(dev_priv, 0, PIPE_HOTPLUG_INTERRUPT_ENABLE |
1294 PIPE_HOTPLUG_TV_INTERRUPT_ENABLE);
1295 spin_unlock_irqrestore(&dev_priv->user_irq_lock, irqflags);
1296
1297 return type;
1298 }
1299
1300 /*
1301 * Here we set accurate tv format according to connector type
1302 * i.e Component TV should not be assigned by NTSC or PAL
1303 */
1304 static void intel_tv_find_better_format(struct drm_connector *connector)
1305 {
1306 struct drm_encoder *encoder = intel_attached_encoder(connector);
1307 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1308 struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
1309 const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
1310 int i;
1311
1312 if ((tv_priv->type == DRM_MODE_CONNECTOR_Component) ==
1313 tv_mode->component_only)
1314 return;
1315
1316
1317 for (i = 0; i < sizeof(tv_modes) / sizeof(*tv_modes); i++) {
1318 tv_mode = tv_modes + i;
1319
1320 if ((tv_priv->type == DRM_MODE_CONNECTOR_Component) ==
1321 tv_mode->component_only)
1322 break;
1323 }
1324
1325 tv_priv->tv_format = tv_mode->name;
1326 drm_connector_property_set_value(connector,
1327 connector->dev->mode_config.tv_mode_property, i);
1328 }
1329
1330 /**
1331 * Detect the TV connection.
1332 *
1333 * Currently this always returns CONNECTOR_STATUS_UNKNOWN, as we need to be sure
1334 * we have a pipe programmed in order to probe the TV.
1335 */
1336 static enum drm_connector_status
1337 intel_tv_detect(struct drm_connector *connector)
1338 {
1339 struct drm_crtc *crtc;
1340 struct drm_display_mode mode;
1341 struct drm_encoder *encoder = intel_attached_encoder(connector);
1342 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1343 struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
1344 int dpms_mode;
1345 int type = tv_priv->type;
1346
1347 mode = reported_modes[0];
1348 drm_mode_set_crtcinfo(&mode, CRTC_INTERLACE_HALVE_V);
1349
1350 if (encoder->crtc && encoder->crtc->enabled) {
1351 type = intel_tv_detect_type(encoder->crtc, intel_encoder);
1352 } else {
1353 crtc = intel_get_load_detect_pipe(intel_encoder, connector,
1354 &mode, &dpms_mode);
1355 if (crtc) {
1356 type = intel_tv_detect_type(crtc, intel_encoder);
1357 intel_release_load_detect_pipe(intel_encoder, connector,
1358 dpms_mode);
1359 } else
1360 type = -1;
1361 }
1362
1363 tv_priv->type = type;
1364
1365 if (type < 0)
1366 return connector_status_disconnected;
1367
1368 intel_tv_find_better_format(connector);
1369 return connector_status_connected;
1370 }
1371
1372 static struct input_res {
1373 char *name;
1374 int w, h;
1375 } input_res_table[] =
1376 {
1377 {"640x480", 640, 480},
1378 {"800x600", 800, 600},
1379 {"1024x768", 1024, 768},
1380 {"1280x1024", 1280, 1024},
1381 {"848x480", 848, 480},
1382 {"1280x720", 1280, 720},
1383 {"1920x1080", 1920, 1080},
1384 };
1385
1386 /*
1387 * Chose preferred mode according to line number of TV format
1388 */
1389 static void
1390 intel_tv_chose_preferred_modes(struct drm_connector *connector,
1391 struct drm_display_mode *mode_ptr)
1392 {
1393 struct drm_encoder *encoder = intel_attached_encoder(connector);
1394 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1395 const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
1396
1397 if (tv_mode->nbr_end < 480 && mode_ptr->vdisplay == 480)
1398 mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
1399 else if (tv_mode->nbr_end > 480) {
1400 if (tv_mode->progressive == true && tv_mode->nbr_end < 720) {
1401 if (mode_ptr->vdisplay == 720)
1402 mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
1403 } else if (mode_ptr->vdisplay == 1080)
1404 mode_ptr->type |= DRM_MODE_TYPE_PREFERRED;
1405 }
1406 }
1407
1408 /**
1409 * Stub get_modes function.
1410 *
1411 * This should probably return a set of fixed modes, unless we can figure out
1412 * how to probe modes off of TV connections.
1413 */
1414
1415 static int
1416 intel_tv_get_modes(struct drm_connector *connector)
1417 {
1418 struct drm_display_mode *mode_ptr;
1419 struct drm_encoder *encoder = intel_attached_encoder(connector);
1420 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1421 const struct tv_mode *tv_mode = intel_tv_mode_find(intel_encoder);
1422 int j, count = 0;
1423 u64 tmp;
1424
1425 for (j = 0; j < sizeof(input_res_table) / sizeof(input_res_table[0]);
1426 j++) {
1427 struct input_res *input = &input_res_table[j];
1428 unsigned int hactive_s = input->w;
1429 unsigned int vactive_s = input->h;
1430
1431 if (tv_mode->max_srcw && input->w > tv_mode->max_srcw)
1432 continue;
1433
1434 if (input->w > 1024 && (!tv_mode->progressive
1435 && !tv_mode->component_only))
1436 continue;
1437
1438 mode_ptr = drm_mode_create(connector->dev);
1439 if (!mode_ptr)
1440 continue;
1441 strncpy(mode_ptr->name, input->name, DRM_DISPLAY_MODE_LEN);
1442
1443 mode_ptr->hdisplay = hactive_s;
1444 mode_ptr->hsync_start = hactive_s + 1;
1445 mode_ptr->hsync_end = hactive_s + 64;
1446 if (mode_ptr->hsync_end <= mode_ptr->hsync_start)
1447 mode_ptr->hsync_end = mode_ptr->hsync_start + 1;
1448 mode_ptr->htotal = hactive_s + 96;
1449
1450 mode_ptr->vdisplay = vactive_s;
1451 mode_ptr->vsync_start = vactive_s + 1;
1452 mode_ptr->vsync_end = vactive_s + 32;
1453 if (mode_ptr->vsync_end <= mode_ptr->vsync_start)
1454 mode_ptr->vsync_end = mode_ptr->vsync_start + 1;
1455 mode_ptr->vtotal = vactive_s + 33;
1456
1457 tmp = (u64) tv_mode->refresh * mode_ptr->vtotal;
1458 tmp *= mode_ptr->htotal;
1459 tmp = div_u64(tmp, 1000000);
1460 mode_ptr->clock = (int) tmp;
1461
1462 mode_ptr->type = DRM_MODE_TYPE_DRIVER;
1463 intel_tv_chose_preferred_modes(connector, mode_ptr);
1464 drm_mode_probed_add(connector, mode_ptr);
1465 count++;
1466 }
1467
1468 return count;
1469 }
1470
1471 static void
1472 intel_tv_destroy (struct drm_connector *connector)
1473 {
1474 drm_sysfs_connector_remove(connector);
1475 drm_connector_cleanup(connector);
1476 kfree(connector);
1477 }
1478
1479
1480 static int
1481 intel_tv_set_property(struct drm_connector *connector, struct drm_property *property,
1482 uint64_t val)
1483 {
1484 struct drm_device *dev = connector->dev;
1485 struct drm_encoder *encoder = intel_attached_encoder(connector);
1486 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1487 struct intel_tv_priv *tv_priv = intel_encoder->dev_priv;
1488 struct drm_crtc *crtc = encoder->crtc;
1489 int ret = 0;
1490 bool changed = false;
1491
1492 ret = drm_connector_property_set_value(connector, property, val);
1493 if (ret < 0)
1494 goto out;
1495
1496 if (property == dev->mode_config.tv_left_margin_property &&
1497 tv_priv->margin[TV_MARGIN_LEFT] != val) {
1498 tv_priv->margin[TV_MARGIN_LEFT] = val;
1499 changed = true;
1500 } else if (property == dev->mode_config.tv_right_margin_property &&
1501 tv_priv->margin[TV_MARGIN_RIGHT] != val) {
1502 tv_priv->margin[TV_MARGIN_RIGHT] = val;
1503 changed = true;
1504 } else if (property == dev->mode_config.tv_top_margin_property &&
1505 tv_priv->margin[TV_MARGIN_TOP] != val) {
1506 tv_priv->margin[TV_MARGIN_TOP] = val;
1507 changed = true;
1508 } else if (property == dev->mode_config.tv_bottom_margin_property &&
1509 tv_priv->margin[TV_MARGIN_BOTTOM] != val) {
1510 tv_priv->margin[TV_MARGIN_BOTTOM] = val;
1511 changed = true;
1512 } else if (property == dev->mode_config.tv_mode_property) {
1513 if (val >= ARRAY_SIZE(tv_modes)) {
1514 ret = -EINVAL;
1515 goto out;
1516 }
1517 if (!strcmp(tv_priv->tv_format, tv_modes[val].name))
1518 goto out;
1519
1520 tv_priv->tv_format = tv_modes[val].name;
1521 changed = true;
1522 } else {
1523 ret = -EINVAL;
1524 goto out;
1525 }
1526
1527 if (changed && crtc)
1528 drm_crtc_helper_set_mode(crtc, &crtc->mode, crtc->x,
1529 crtc->y, crtc->fb);
1530 out:
1531 return ret;
1532 }
1533
1534 static const struct drm_encoder_helper_funcs intel_tv_helper_funcs = {
1535 .dpms = intel_tv_dpms,
1536 .mode_fixup = intel_tv_mode_fixup,
1537 .prepare = intel_encoder_prepare,
1538 .mode_set = intel_tv_mode_set,
1539 .commit = intel_encoder_commit,
1540 };
1541
1542 static const struct drm_connector_funcs intel_tv_connector_funcs = {
1543 .dpms = drm_helper_connector_dpms,
1544 .detect = intel_tv_detect,
1545 .destroy = intel_tv_destroy,
1546 .set_property = intel_tv_set_property,
1547 .fill_modes = drm_helper_probe_single_connector_modes,
1548 };
1549
1550 static const struct drm_connector_helper_funcs intel_tv_connector_helper_funcs = {
1551 .mode_valid = intel_tv_mode_valid,
1552 .get_modes = intel_tv_get_modes,
1553 .best_encoder = intel_attached_encoder,
1554 };
1555
1556 static void intel_tv_enc_destroy(struct drm_encoder *encoder)
1557 {
1558 struct intel_encoder *intel_encoder = enc_to_intel_encoder(encoder);
1559
1560 drm_encoder_cleanup(encoder);
1561 kfree(intel_encoder);
1562 }
1563
1564 static const struct drm_encoder_funcs intel_tv_enc_funcs = {
1565 .destroy = intel_tv_enc_destroy,
1566 };
1567
1568 /*
1569 * Enumerate the child dev array parsed from VBT to check whether
1570 * the integrated TV is present.
1571 * If it is present, return 1.
1572 * If it is not present, return false.
1573 * If no child dev is parsed from VBT, it assumes that the TV is present.
1574 */
1575 static int tv_is_present_in_vbt(struct drm_device *dev)
1576 {
1577 struct drm_i915_private *dev_priv = dev->dev_private;
1578 struct child_device_config *p_child;
1579 int i, ret;
1580
1581 if (!dev_priv->child_dev_num)
1582 return 1;
1583
1584 ret = 0;
1585 for (i = 0; i < dev_priv->child_dev_num; i++) {
1586 p_child = dev_priv->child_dev + i;
1587 /*
1588 * If the device type is not TV, continue.
1589 */
1590 if (p_child->device_type != DEVICE_TYPE_INT_TV &&
1591 p_child->device_type != DEVICE_TYPE_TV)
1592 continue;
1593 /* Only when the addin_offset is non-zero, it is regarded
1594 * as present.
1595 */
1596 if (p_child->addin_offset) {
1597 ret = 1;
1598 break;
1599 }
1600 }
1601 return ret;
1602 }
1603
1604 void
1605 intel_tv_init(struct drm_device *dev)
1606 {
1607 struct drm_i915_private *dev_priv = dev->dev_private;
1608 struct drm_connector *connector;
1609 struct intel_encoder *intel_encoder;
1610 struct intel_connector *intel_connector;
1611 struct intel_tv_priv *tv_priv;
1612 u32 tv_dac_on, tv_dac_off, save_tv_dac;
1613 char **tv_format_names;
1614 int i, initial_mode = 0;
1615
1616 if ((I915_READ(TV_CTL) & TV_FUSE_STATE_MASK) == TV_FUSE_STATE_DISABLED)
1617 return;
1618
1619 if (!tv_is_present_in_vbt(dev)) {
1620 DRM_DEBUG_KMS("Integrated TV is not present.\n");
1621 return;
1622 }
1623 /* Even if we have an encoder we may not have a connector */
1624 if (!dev_priv->int_tv_support)
1625 return;
1626
1627 /*
1628 * Sanity check the TV output by checking to see if the
1629 * DAC register holds a value
1630 */
1631 save_tv_dac = I915_READ(TV_DAC);
1632
1633 I915_WRITE(TV_DAC, save_tv_dac | TVDAC_STATE_CHG_EN);
1634 tv_dac_on = I915_READ(TV_DAC);
1635
1636 I915_WRITE(TV_DAC, save_tv_dac & ~TVDAC_STATE_CHG_EN);
1637 tv_dac_off = I915_READ(TV_DAC);
1638
1639 I915_WRITE(TV_DAC, save_tv_dac);
1640
1641 /*
1642 * If the register does not hold the state change enable
1643 * bit, (either as a 0 or a 1), assume it doesn't really
1644 * exist
1645 */
1646 if ((tv_dac_on & TVDAC_STATE_CHG_EN) == 0 ||
1647 (tv_dac_off & TVDAC_STATE_CHG_EN) != 0)
1648 return;
1649
1650 intel_encoder = kzalloc(sizeof(struct intel_encoder) +
1651 sizeof(struct intel_tv_priv), GFP_KERNEL);
1652 if (!intel_encoder) {
1653 return;
1654 }
1655
1656 intel_connector = kzalloc(sizeof(struct intel_connector), GFP_KERNEL);
1657 if (!intel_connector) {
1658 kfree(intel_encoder);
1659 return;
1660 }
1661
1662 connector = &intel_connector->base;
1663
1664 drm_connector_init(dev, connector, &intel_tv_connector_funcs,
1665 DRM_MODE_CONNECTOR_SVIDEO);
1666
1667 drm_encoder_init(dev, &intel_encoder->enc, &intel_tv_enc_funcs,
1668 DRM_MODE_ENCODER_TVDAC);
1669
1670 drm_mode_connector_attach_encoder(&intel_connector->base, &intel_encoder->enc);
1671 tv_priv = (struct intel_tv_priv *)(intel_encoder + 1);
1672 intel_encoder->type = INTEL_OUTPUT_TVOUT;
1673 intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
1674 intel_encoder->clone_mask = (1 << INTEL_TV_CLONE_BIT);
1675 intel_encoder->enc.possible_crtcs = ((1 << 0) | (1 << 1));
1676 intel_encoder->enc.possible_clones = (1 << INTEL_OUTPUT_TVOUT);
1677 intel_encoder->dev_priv = tv_priv;
1678 tv_priv->type = DRM_MODE_CONNECTOR_Unknown;
1679
1680 /* BIOS margin values */
1681 tv_priv->margin[TV_MARGIN_LEFT] = 54;
1682 tv_priv->margin[TV_MARGIN_TOP] = 36;
1683 tv_priv->margin[TV_MARGIN_RIGHT] = 46;
1684 tv_priv->margin[TV_MARGIN_BOTTOM] = 37;
1685
1686 tv_priv->tv_format = kstrdup(tv_modes[initial_mode].name, GFP_KERNEL);
1687
1688 drm_encoder_helper_add(&intel_encoder->enc, &intel_tv_helper_funcs);
1689 drm_connector_helper_add(connector, &intel_tv_connector_helper_funcs);
1690 connector->interlace_allowed = false;
1691 connector->doublescan_allowed = false;
1692
1693 /* Create TV properties then attach current values */
1694 tv_format_names = kmalloc(sizeof(char *) * ARRAY_SIZE(tv_modes),
1695 GFP_KERNEL);
1696 if (!tv_format_names)
1697 goto out;
1698 for (i = 0; i < ARRAY_SIZE(tv_modes); i++)
1699 tv_format_names[i] = tv_modes[i].name;
1700 drm_mode_create_tv_properties(dev, ARRAY_SIZE(tv_modes), tv_format_names);
1701
1702 drm_connector_attach_property(connector, dev->mode_config.tv_mode_property,
1703 initial_mode);
1704 drm_connector_attach_property(connector,
1705 dev->mode_config.tv_left_margin_property,
1706 tv_priv->margin[TV_MARGIN_LEFT]);
1707 drm_connector_attach_property(connector,
1708 dev->mode_config.tv_top_margin_property,
1709 tv_priv->margin[TV_MARGIN_TOP]);
1710 drm_connector_attach_property(connector,
1711 dev->mode_config.tv_right_margin_property,
1712 tv_priv->margin[TV_MARGIN_RIGHT]);
1713 drm_connector_attach_property(connector,
1714 dev->mode_config.tv_bottom_margin_property,
1715 tv_priv->margin[TV_MARGIN_BOTTOM]);
1716 out:
1717 drm_sysfs_connector_add(connector);
1718 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree