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 <drm/drm_atomic_helper.h> 34 #include <drm/drm_crtc.h> 35 #include <drm/drm_edid.h> 36 37 #include "i915_drv.h" 38 #include "i915_reg.h" 39 #include "i915_irq.h" 40 #include "intel_connector.h" 41 #include "intel_crtc.h" 42 #include "intel_de.h" 43 #include "intel_display_types.h" 44 #include "intel_dpll.h" 45 #include "intel_hotplug.h" 46 #include "intel_tv.h" 47 48 enum tv_margin { 49 TV_MARGIN_LEFT, TV_MARGIN_TOP, 50 TV_MARGIN_RIGHT, TV_MARGIN_BOTTOM 51 }; 52 53 struct intel_tv { 54 struct intel_encoder base; 55 56 int type; 57 }; 58 59 struct video_levels { 60 u16 blank, black; 61 u8 burst; 62 }; 63 64 struct color_conversion { 65 u16 ry, gy, by, ay; 66 u16 ru, gu, bu, au; 67 u16 rv, gv, bv, av; 68 }; 69 70 static const u32 filter_table[] = { 71 0xB1403000, 0x2E203500, 0x35002E20, 0x3000B140, 72 0x35A0B160, 0x2DC02E80, 0xB1403480, 0xB1603000, 73 0x2EA03640, 0x34002D80, 0x3000B120, 0x36E0B160, 74 0x2D202EF0, 0xB1203380, 0xB1603000, 0x2F303780, 75 0x33002CC0, 0x3000B100, 0x3820B160, 0x2C802F50, 76 0xB10032A0, 0xB1603000, 0x2F9038C0, 0x32202C20, 77 0x3000B0E0, 0x3980B160, 0x2BC02FC0, 0xB0E031C0, 78 0xB1603000, 0x2FF03A20, 0x31602B60, 0xB020B0C0, 79 0x3AE0B160, 0x2B001810, 0xB0C03120, 0xB140B020, 80 0x18283BA0, 0x30C02A80, 0xB020B0A0, 0x3C60B140, 81 0x2A201838, 0xB0A03080, 0xB120B020, 0x18383D20, 82 0x304029C0, 0xB040B080, 0x3DE0B100, 0x29601848, 83 0xB0803000, 0xB100B040, 0x18483EC0, 0xB0402900, 84 0xB040B060, 0x3F80B0C0, 0x28801858, 0xB060B080, 85 0xB0A0B060, 0x18602820, 0xB0A02820, 0x0000B060, 86 0xB1403000, 0x2E203500, 0x35002E20, 0x3000B140, 87 0x35A0B160, 0x2DC02E80, 0xB1403480, 0xB1603000, 88 0x2EA03640, 0x34002D80, 0x3000B120, 0x36E0B160, 89 0x2D202EF0, 0xB1203380, 0xB1603000, 0x2F303780, 90 0x33002CC0, 0x3000B100, 0x3820B160, 0x2C802F50, 91 0xB10032A0, 0xB1603000, 0x2F9038C0, 0x32202C20, 92 0x3000B0E0, 0x3980B160, 0x2BC02FC0, 0xB0E031C0, 93 0xB1603000, 0x2FF03A20, 0x31602B60, 0xB020B0C0, 94 0x3AE0B160, 0x2B001810, 0xB0C03120, 0xB140B020, 95 0x18283BA0, 0x30C02A80, 0xB020B0A0, 0x3C60B140, 96 0x2A201838, 0xB0A03080, 0xB120B020, 0x18383D20, 97 0x304029C0, 0xB040B080, 0x3DE0B100, 0x29601848, 98 0xB0803000, 0xB100B040, 0x18483EC0, 0xB0402900, 99 0xB040B060, 0x3F80B0C0, 0x28801858, 0xB060B080, 100 0xB0A0B060, 0x18602820, 0xB0A02820, 0x0000B060, 101 0x36403000, 0x2D002CC0, 0x30003640, 0x2D0036C0, 102 0x35C02CC0, 0x37403000, 0x2C802D40, 0x30003540, 103 0x2D8037C0, 0x34C02C40, 0x38403000, 0x2BC02E00, 104 0x30003440, 0x2E2038C0, 0x34002B80, 0x39803000, 105 0x2B402E40, 0x30003380, 0x2E603A00, 0x33402B00, 106 0x3A803040, 0x2A802EA0, 0x30403300, 0x2EC03B40, 107 0x32802A40, 0x3C003040, 0x2A002EC0, 0x30803240, 108 0x2EC03C80, 0x320029C0, 0x3D403080, 0x29402F00, 109 0x308031C0, 0x2F203DC0, 0x31802900, 0x3E8030C0, 110 0x28802F40, 0x30C03140, 0x2F203F40, 0x31402840, 111 0x28003100, 0x28002F00, 0x00003100, 0x36403000, 112 0x2D002CC0, 0x30003640, 0x2D0036C0, 113 0x35C02CC0, 0x37403000, 0x2C802D40, 0x30003540, 114 0x2D8037C0, 0x34C02C40, 0x38403000, 0x2BC02E00, 115 0x30003440, 0x2E2038C0, 0x34002B80, 0x39803000, 116 0x2B402E40, 0x30003380, 0x2E603A00, 0x33402B00, 117 0x3A803040, 0x2A802EA0, 0x30403300, 0x2EC03B40, 118 0x32802A40, 0x3C003040, 0x2A002EC0, 0x30803240, 119 0x2EC03C80, 0x320029C0, 0x3D403080, 0x29402F00, 120 0x308031C0, 0x2F203DC0, 0x31802900, 0x3E8030C0, 121 0x28802F40, 0x30C03140, 0x2F203F40, 0x31402840, 122 0x28003100, 0x28002F00, 0x00003100, 123 }; 124 125 /* 126 * Color conversion values have 3 separate fixed point formats: 127 * 128 * 10 bit fields (ay, au) 129 * 1.9 fixed point (b.bbbbbbbbb) 130 * 11 bit fields (ry, by, ru, gu, gv) 131 * exp.mantissa (ee.mmmmmmmmm) 132 * ee = 00 = 10^-1 (0.mmmmmmmmm) 133 * ee = 01 = 10^-2 (0.0mmmmmmmmm) 134 * ee = 10 = 10^-3 (0.00mmmmmmmmm) 135 * ee = 11 = 10^-4 (0.000mmmmmmmmm) 136 * 12 bit fields (gy, rv, bu) 137 * exp.mantissa (eee.mmmmmmmmm) 138 * eee = 000 = 10^-1 (0.mmmmmmmmm) 139 * eee = 001 = 10^-2 (0.0mmmmmmmmm) 140 * eee = 010 = 10^-3 (0.00mmmmmmmmm) 141 * eee = 011 = 10^-4 (0.000mmmmmmmmm) 142 * eee = 100 = reserved 143 * eee = 101 = reserved 144 * eee = 110 = reserved 145 * eee = 111 = 10^0 (m.mmmmmmmm) (only usable for 1.0 representation) 146 * 147 * Saturation and contrast are 8 bits, with their own representation: 148 * 8 bit field (saturation, contrast) 149 * exp.mantissa (ee.mmmmmm) 150 * ee = 00 = 10^-1 (0.mmmmmm) 151 * ee = 01 = 10^0 (m.mmmmm) 152 * ee = 10 = 10^1 (mm.mmmm) 153 * ee = 11 = 10^2 (mmm.mmm) 154 * 155 * Simple conversion function: 156 * 157 * static u32 158 * float_to_csc_11(float f) 159 * { 160 * u32 exp; 161 * u32 mant; 162 * u32 ret; 163 * 164 * if (f < 0) 165 * f = -f; 166 * 167 * if (f >= 1) { 168 * exp = 0x7; 169 * mant = 1 << 8; 170 * } else { 171 * for (exp = 0; exp < 3 && f < 0.5; exp++) 172 * f *= 2.0; 173 * mant = (f * (1 << 9) + 0.5); 174 * if (mant >= (1 << 9)) 175 * mant = (1 << 9) - 1; 176 * } 177 * ret = (exp << 9) | mant; 178 * return ret; 179 * } 180 */ 181 182 /* 183 * Behold, magic numbers! If we plant them they might grow a big 184 * s-video cable to the sky... or something. 185 * 186 * Pre-converted to appropriate hex value. 187 */ 188 189 /* 190 * PAL & NTSC values for composite & s-video connections 191 */ 192 static const struct color_conversion ntsc_m_csc_composite = { 193 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0104, 194 .ru = 0x0733, .gu = 0x052d, .bu = 0x05c7, .au = 0x0200, 195 .rv = 0x0340, .gv = 0x030c, .bv = 0x06d0, .av = 0x0200, 196 }; 197 198 static const struct video_levels ntsc_m_levels_composite = { 199 .blank = 225, .black = 267, .burst = 113, 200 }; 201 202 static const struct color_conversion ntsc_m_csc_svideo = { 203 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0133, 204 .ru = 0x076a, .gu = 0x0564, .bu = 0x030d, .au = 0x0200, 205 .rv = 0x037a, .gv = 0x033d, .bv = 0x06f6, .av = 0x0200, 206 }; 207 208 static const struct video_levels ntsc_m_levels_svideo = { 209 .blank = 266, .black = 316, .burst = 133, 210 }; 211 212 static const struct color_conversion ntsc_j_csc_composite = { 213 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0119, 214 .ru = 0x074c, .gu = 0x0546, .bu = 0x05ec, .au = 0x0200, 215 .rv = 0x035a, .gv = 0x0322, .bv = 0x06e1, .av = 0x0200, 216 }; 217 218 static const struct video_levels ntsc_j_levels_composite = { 219 .blank = 225, .black = 225, .burst = 113, 220 }; 221 222 static const struct color_conversion ntsc_j_csc_svideo = { 223 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x014c, 224 .ru = 0x0788, .gu = 0x0581, .bu = 0x0322, .au = 0x0200, 225 .rv = 0x0399, .gv = 0x0356, .bv = 0x070a, .av = 0x0200, 226 }; 227 228 static const struct video_levels ntsc_j_levels_svideo = { 229 .blank = 266, .black = 266, .burst = 133, 230 }; 231 232 static const struct color_conversion pal_csc_composite = { 233 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0113, 234 .ru = 0x0745, .gu = 0x053f, .bu = 0x05e1, .au = 0x0200, 235 .rv = 0x0353, .gv = 0x031c, .bv = 0x06dc, .av = 0x0200, 236 }; 237 238 static const struct video_levels pal_levels_composite = { 239 .blank = 237, .black = 237, .burst = 118, 240 }; 241 242 static const struct color_conversion pal_csc_svideo = { 243 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0145, 244 .ru = 0x0780, .gu = 0x0579, .bu = 0x031c, .au = 0x0200, 245 .rv = 0x0390, .gv = 0x034f, .bv = 0x0705, .av = 0x0200, 246 }; 247 248 static const struct video_levels pal_levels_svideo = { 249 .blank = 280, .black = 280, .burst = 139, 250 }; 251 252 static const struct color_conversion pal_m_csc_composite = { 253 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0104, 254 .ru = 0x0733, .gu = 0x052d, .bu = 0x05c7, .au = 0x0200, 255 .rv = 0x0340, .gv = 0x030c, .bv = 0x06d0, .av = 0x0200, 256 }; 257 258 static const struct video_levels pal_m_levels_composite = { 259 .blank = 225, .black = 267, .burst = 113, 260 }; 261 262 static const struct color_conversion pal_m_csc_svideo = { 263 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0133, 264 .ru = 0x076a, .gu = 0x0564, .bu = 0x030d, .au = 0x0200, 265 .rv = 0x037a, .gv = 0x033d, .bv = 0x06f6, .av = 0x0200, 266 }; 267 268 static const struct video_levels pal_m_levels_svideo = { 269 .blank = 266, .black = 316, .burst = 133, 270 }; 271 272 static const struct color_conversion pal_n_csc_composite = { 273 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0104, 274 .ru = 0x0733, .gu = 0x052d, .bu = 0x05c7, .au = 0x0200, 275 .rv = 0x0340, .gv = 0x030c, .bv = 0x06d0, .av = 0x0200, 276 }; 277 278 static const struct video_levels pal_n_levels_composite = { 279 .blank = 225, .black = 267, .burst = 118, 280 }; 281 282 static const struct color_conversion pal_n_csc_svideo = { 283 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0133, 284 .ru = 0x076a, .gu = 0x0564, .bu = 0x030d, .au = 0x0200, 285 .rv = 0x037a, .gv = 0x033d, .bv = 0x06f6, .av = 0x0200, 286 }; 287 288 static const struct video_levels pal_n_levels_svideo = { 289 .blank = 266, .black = 316, .burst = 139, 290 }; 291 292 /* 293 * Component connections 294 */ 295 static const struct color_conversion sdtv_csc_yprpb = { 296 .ry = 0x0332, .gy = 0x012d, .by = 0x07d3, .ay = 0x0145, 297 .ru = 0x0559, .gu = 0x0353, .bu = 0x0100, .au = 0x0200, 298 .rv = 0x0100, .gv = 0x03ad, .bv = 0x074d, .av = 0x0200, 299 }; 300 301 static const struct color_conversion hdtv_csc_yprpb = { 302 .ry = 0x05b3, .gy = 0x016e, .by = 0x0728, .ay = 0x0145, 303 .ru = 0x07d5, .gu = 0x038b, .bu = 0x0100, .au = 0x0200, 304 .rv = 0x0100, .gv = 0x03d1, .bv = 0x06bc, .av = 0x0200, 305 }; 306 307 static const struct video_levels component_levels = { 308 .blank = 279, .black = 279, .burst = 0, 309 }; 310 311 312 struct tv_mode { 313 const char *name; 314 315 u32 clock; 316 u16 refresh; /* in millihertz (for precision) */ 317 u8 oversample; 318 u8 hsync_end; 319 u16 hblank_start, hblank_end, htotal; 320 bool progressive : 1, trilevel_sync : 1, component_only : 1; 321 u8 vsync_start_f1, vsync_start_f2, vsync_len; 322 bool veq_ena : 1; 323 u8 veq_start_f1, veq_start_f2, veq_len; 324 u8 vi_end_f1, vi_end_f2; 325 u16 nbr_end; 326 bool burst_ena : 1; 327 u8 hburst_start, hburst_len; 328 u8 vburst_start_f1; 329 u16 vburst_end_f1; 330 u8 vburst_start_f2; 331 u16 vburst_end_f2; 332 u8 vburst_start_f3; 333 u16 vburst_end_f3; 334 u8 vburst_start_f4; 335 u16 vburst_end_f4; 336 /* 337 * subcarrier programming 338 */ 339 u16 dda2_size, dda3_size; 340 u8 dda1_inc; 341 u16 dda2_inc, dda3_inc; 342 u32 sc_reset; 343 bool pal_burst : 1; 344 /* 345 * blank/black levels 346 */ 347 const struct video_levels *composite_levels, *svideo_levels; 348 const struct color_conversion *composite_color, *svideo_color; 349 const u32 *filter_table; 350 }; 351 352 353 /* 354 * Sub carrier DDA 355 * 356 * I think this works as follows: 357 * 358 * subcarrier freq = pixel_clock * (dda1_inc + dda2_inc / dda2_size) / 4096 359 * 360 * Presumably, when dda3 is added in, it gets to adjust the dda2_inc value 361 * 362 * So, 363 * dda1_ideal = subcarrier/pixel * 4096 364 * dda1_inc = floor (dda1_ideal) 365 * dda2 = dda1_ideal - dda1_inc 366 * 367 * then pick a ratio for dda2 that gives the closest approximation. If 368 * you can't get close enough, you can play with dda3 as well. This 369 * seems likely to happen when dda2 is small as the jumps would be larger 370 * 371 * To invert this, 372 * 373 * pixel_clock = subcarrier * 4096 / (dda1_inc + dda2_inc / dda2_size) 374 * 375 * The constants below were all computed using a 107.520MHz clock 376 */ 377 378 /* 379 * Register programming values for TV modes. 380 * 381 * These values account for -1s required. 382 */ 383 static const struct tv_mode tv_modes[] = { 384 { 385 .name = "NTSC-M", 386 .clock = 108000, 387 .refresh = 59940, 388 .oversample = 8, 389 .component_only = false, 390 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 3.580MHz */ 391 392 .hsync_end = 64, .hblank_end = 124, 393 .hblank_start = 836, .htotal = 857, 394 395 .progressive = false, .trilevel_sync = false, 396 397 .vsync_start_f1 = 6, .vsync_start_f2 = 7, 398 .vsync_len = 6, 399 400 .veq_ena = true, .veq_start_f1 = 0, 401 .veq_start_f2 = 1, .veq_len = 18, 402 403 .vi_end_f1 = 20, .vi_end_f2 = 21, 404 .nbr_end = 240, 405 406 .burst_ena = true, 407 .hburst_start = 72, .hburst_len = 34, 408 .vburst_start_f1 = 9, .vburst_end_f1 = 240, 409 .vburst_start_f2 = 10, .vburst_end_f2 = 240, 410 .vburst_start_f3 = 9, .vburst_end_f3 = 240, 411 .vburst_start_f4 = 10, .vburst_end_f4 = 240, 412 413 /* desired 3.5800000 actual 3.5800000 clock 107.52 */ 414 .dda1_inc = 135, 415 .dda2_inc = 20800, .dda2_size = 27456, 416 .dda3_inc = 0, .dda3_size = 0, 417 .sc_reset = TV_SC_RESET_EVERY_4, 418 .pal_burst = false, 419 420 .composite_levels = &ntsc_m_levels_composite, 421 .composite_color = &ntsc_m_csc_composite, 422 .svideo_levels = &ntsc_m_levels_svideo, 423 .svideo_color = &ntsc_m_csc_svideo, 424 425 .filter_table = filter_table, 426 }, 427 { 428 .name = "NTSC-443", 429 .clock = 108000, 430 .refresh = 59940, 431 .oversample = 8, 432 .component_only = false, 433 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 4.43MHz */ 434 .hsync_end = 64, .hblank_end = 124, 435 .hblank_start = 836, .htotal = 857, 436 437 .progressive = false, .trilevel_sync = false, 438 439 .vsync_start_f1 = 6, .vsync_start_f2 = 7, 440 .vsync_len = 6, 441 442 .veq_ena = true, .veq_start_f1 = 0, 443 .veq_start_f2 = 1, .veq_len = 18, 444 445 .vi_end_f1 = 20, .vi_end_f2 = 21, 446 .nbr_end = 240, 447 448 .burst_ena = true, 449 .hburst_start = 72, .hburst_len = 34, 450 .vburst_start_f1 = 9, .vburst_end_f1 = 240, 451 .vburst_start_f2 = 10, .vburst_end_f2 = 240, 452 .vburst_start_f3 = 9, .vburst_end_f3 = 240, 453 .vburst_start_f4 = 10, .vburst_end_f4 = 240, 454 455 /* desired 4.4336180 actual 4.4336180 clock 107.52 */ 456 .dda1_inc = 168, 457 .dda2_inc = 4093, .dda2_size = 27456, 458 .dda3_inc = 310, .dda3_size = 525, 459 .sc_reset = TV_SC_RESET_NEVER, 460 .pal_burst = false, 461 462 .composite_levels = &ntsc_m_levels_composite, 463 .composite_color = &ntsc_m_csc_composite, 464 .svideo_levels = &ntsc_m_levels_svideo, 465 .svideo_color = &ntsc_m_csc_svideo, 466 467 .filter_table = filter_table, 468 }, 469 { 470 .name = "NTSC-J", 471 .clock = 108000, 472 .refresh = 59940, 473 .oversample = 8, 474 .component_only = false, 475 476 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 3.580MHz */ 477 .hsync_end = 64, .hblank_end = 124, 478 .hblank_start = 836, .htotal = 857, 479 480 .progressive = false, .trilevel_sync = false, 481 482 .vsync_start_f1 = 6, .vsync_start_f2 = 7, 483 .vsync_len = 6, 484 485 .veq_ena = true, .veq_start_f1 = 0, 486 .veq_start_f2 = 1, .veq_len = 18, 487 488 .vi_end_f1 = 20, .vi_end_f2 = 21, 489 .nbr_end = 240, 490 491 .burst_ena = true, 492 .hburst_start = 72, .hburst_len = 34, 493 .vburst_start_f1 = 9, .vburst_end_f1 = 240, 494 .vburst_start_f2 = 10, .vburst_end_f2 = 240, 495 .vburst_start_f3 = 9, .vburst_end_f3 = 240, 496 .vburst_start_f4 = 10, .vburst_end_f4 = 240, 497 498 /* desired 3.5800000 actual 3.5800000 clock 107.52 */ 499 .dda1_inc = 135, 500 .dda2_inc = 20800, .dda2_size = 27456, 501 .dda3_inc = 0, .dda3_size = 0, 502 .sc_reset = TV_SC_RESET_EVERY_4, 503 .pal_burst = false, 504 505 .composite_levels = &ntsc_j_levels_composite, 506 .composite_color = &ntsc_j_csc_composite, 507 .svideo_levels = &ntsc_j_levels_svideo, 508 .svideo_color = &ntsc_j_csc_svideo, 509 510 .filter_table = filter_table, 511 }, 512 { 513 .name = "PAL-M", 514 .clock = 108000, 515 .refresh = 59940, 516 .oversample = 8, 517 .component_only = false, 518 519 /* 525 Lines, 60 Fields, 15.734KHz line, Sub-Carrier 3.580MHz */ 520 .hsync_end = 64, .hblank_end = 124, 521 .hblank_start = 836, .htotal = 857, 522 523 .progressive = false, .trilevel_sync = false, 524 525 .vsync_start_f1 = 6, .vsync_start_f2 = 7, 526 .vsync_len = 6, 527 528 .veq_ena = true, .veq_start_f1 = 0, 529 .veq_start_f2 = 1, .veq_len = 18, 530 531 .vi_end_f1 = 20, .vi_end_f2 = 21, 532 .nbr_end = 240, 533 534 .burst_ena = true, 535 .hburst_start = 72, .hburst_len = 34, 536 .vburst_start_f1 = 9, .vburst_end_f1 = 240, 537 .vburst_start_f2 = 10, .vburst_end_f2 = 240, 538 .vburst_start_f3 = 9, .vburst_end_f3 = 240, 539 .vburst_start_f4 = 10, .vburst_end_f4 = 240, 540 541 /* desired 3.5800000 actual 3.5800000 clock 107.52 */ 542 .dda1_inc = 135, 543 .dda2_inc = 16704, .dda2_size = 27456, 544 .dda3_inc = 0, .dda3_size = 0, 545 .sc_reset = TV_SC_RESET_EVERY_8, 546 .pal_burst = true, 547 548 .composite_levels = &pal_m_levels_composite, 549 .composite_color = &pal_m_csc_composite, 550 .svideo_levels = &pal_m_levels_svideo, 551 .svideo_color = &pal_m_csc_svideo, 552 553 .filter_table = filter_table, 554 }, 555 { 556 /* 625 Lines, 50 Fields, 15.625KHz line, Sub-Carrier 4.434MHz */ 557 .name = "PAL-N", 558 .clock = 108000, 559 .refresh = 50000, 560 .oversample = 8, 561 .component_only = false, 562 563 .hsync_end = 64, .hblank_end = 128, 564 .hblank_start = 844, .htotal = 863, 565 566 .progressive = false, .trilevel_sync = false, 567 568 569 .vsync_start_f1 = 6, .vsync_start_f2 = 7, 570 .vsync_len = 6, 571 572 .veq_ena = true, .veq_start_f1 = 0, 573 .veq_start_f2 = 1, .veq_len = 18, 574 575 .vi_end_f1 = 24, .vi_end_f2 = 25, 576 .nbr_end = 286, 577 578 .burst_ena = true, 579 .hburst_start = 73, .hburst_len = 34, 580 .vburst_start_f1 = 8, .vburst_end_f1 = 285, 581 .vburst_start_f2 = 8, .vburst_end_f2 = 286, 582 .vburst_start_f3 = 9, .vburst_end_f3 = 286, 583 .vburst_start_f4 = 9, .vburst_end_f4 = 285, 584 585 586 /* desired 4.4336180 actual 4.4336180 clock 107.52 */ 587 .dda1_inc = 135, 588 .dda2_inc = 23578, .dda2_size = 27648, 589 .dda3_inc = 134, .dda3_size = 625, 590 .sc_reset = TV_SC_RESET_EVERY_8, 591 .pal_burst = true, 592 593 .composite_levels = &pal_n_levels_composite, 594 .composite_color = &pal_n_csc_composite, 595 .svideo_levels = &pal_n_levels_svideo, 596 .svideo_color = &pal_n_csc_svideo, 597 598 .filter_table = filter_table, 599 }, 600 { 601 /* 625 Lines, 50 Fields, 15.625KHz line, Sub-Carrier 4.434MHz */ 602 .name = "PAL", 603 .clock = 108000, 604 .refresh = 50000, 605 .oversample = 8, 606 .component_only = false, 607 608 .hsync_end = 64, .hblank_end = 142, 609 .hblank_start = 844, .htotal = 863, 610 611 .progressive = false, .trilevel_sync = false, 612 613 .vsync_start_f1 = 5, .vsync_start_f2 = 6, 614 .vsync_len = 5, 615 616 .veq_ena = true, .veq_start_f1 = 0, 617 .veq_start_f2 = 1, .veq_len = 15, 618 619 .vi_end_f1 = 24, .vi_end_f2 = 25, 620 .nbr_end = 286, 621 622 .burst_ena = true, 623 .hburst_start = 73, .hburst_len = 32, 624 .vburst_start_f1 = 8, .vburst_end_f1 = 285, 625 .vburst_start_f2 = 8, .vburst_end_f2 = 286, 626 .vburst_start_f3 = 9, .vburst_end_f3 = 286, 627 .vburst_start_f4 = 9, .vburst_end_f4 = 285, 628 629 /* desired 4.4336180 actual 4.4336180 clock 107.52 */ 630 .dda1_inc = 168, 631 .dda2_inc = 4122, .dda2_size = 27648, 632 .dda3_inc = 67, .dda3_size = 625, 633 .sc_reset = TV_SC_RESET_EVERY_8, 634 .pal_burst = true, 635 636 .composite_levels = &pal_levels_composite, 637 .composite_color = &pal_csc_composite, 638 .svideo_levels = &pal_levels_svideo, 639 .svideo_color = &pal_csc_svideo, 640 641 .filter_table = filter_table, 642 }, 643 { 644 .name = "480p", 645 .clock = 108000, 646 .refresh = 59940, 647 .oversample = 4, 648 .component_only = true, 649 650 .hsync_end = 64, .hblank_end = 122, 651 .hblank_start = 842, .htotal = 857, 652 653 .progressive = true, .trilevel_sync = false, 654 655 .vsync_start_f1 = 12, .vsync_start_f2 = 12, 656 .vsync_len = 12, 657 658 .veq_ena = false, 659 660 .vi_end_f1 = 44, .vi_end_f2 = 44, 661 .nbr_end = 479, 662 663 .burst_ena = false, 664 665 .filter_table = filter_table, 666 }, 667 { 668 .name = "576p", 669 .clock = 108000, 670 .refresh = 50000, 671 .oversample = 4, 672 .component_only = true, 673 674 .hsync_end = 64, .hblank_end = 139, 675 .hblank_start = 859, .htotal = 863, 676 677 .progressive = true, .trilevel_sync = false, 678 679 .vsync_start_f1 = 10, .vsync_start_f2 = 10, 680 .vsync_len = 10, 681 682 .veq_ena = false, 683 684 .vi_end_f1 = 48, .vi_end_f2 = 48, 685 .nbr_end = 575, 686 687 .burst_ena = false, 688 689 .filter_table = filter_table, 690 }, 691 { 692 .name = "720p@60Hz", 693 .clock = 148500, 694 .refresh = 60000, 695 .oversample = 2, 696 .component_only = true, 697 698 .hsync_end = 80, .hblank_end = 300, 699 .hblank_start = 1580, .htotal = 1649, 700 701 .progressive = true, .trilevel_sync = true, 702 703 .vsync_start_f1 = 10, .vsync_start_f2 = 10, 704 .vsync_len = 10, 705 706 .veq_ena = false, 707 708 .vi_end_f1 = 29, .vi_end_f2 = 29, 709 .nbr_end = 719, 710 711 .burst_ena = false, 712 713 .filter_table = filter_table, 714 }, 715 { 716 .name = "720p@50Hz", 717 .clock = 148500, 718 .refresh = 50000, 719 .oversample = 2, 720 .component_only = true, 721 722 .hsync_end = 80, .hblank_end = 300, 723 .hblank_start = 1580, .htotal = 1979, 724 725 .progressive = true, .trilevel_sync = true, 726 727 .vsync_start_f1 = 10, .vsync_start_f2 = 10, 728 .vsync_len = 10, 729 730 .veq_ena = false, 731 732 .vi_end_f1 = 29, .vi_end_f2 = 29, 733 .nbr_end = 719, 734 735 .burst_ena = false, 736 737 .filter_table = filter_table, 738 }, 739 { 740 .name = "1080i@50Hz", 741 .clock = 148500, 742 .refresh = 50000, 743 .oversample = 2, 744 .component_only = true, 745 746 .hsync_end = 88, .hblank_end = 235, 747 .hblank_start = 2155, .htotal = 2639, 748 749 .progressive = false, .trilevel_sync = true, 750 751 .vsync_start_f1 = 4, .vsync_start_f2 = 5, 752 .vsync_len = 10, 753 754 .veq_ena = true, .veq_start_f1 = 4, 755 .veq_start_f2 = 4, .veq_len = 10, 756 757 758 .vi_end_f1 = 21, .vi_end_f2 = 22, 759 .nbr_end = 539, 760 761 .burst_ena = false, 762 763 .filter_table = filter_table, 764 }, 765 { 766 .name = "1080i@60Hz", 767 .clock = 148500, 768 .refresh = 60000, 769 .oversample = 2, 770 .component_only = true, 771 772 .hsync_end = 88, .hblank_end = 235, 773 .hblank_start = 2155, .htotal = 2199, 774 775 .progressive = false, .trilevel_sync = true, 776 777 .vsync_start_f1 = 4, .vsync_start_f2 = 5, 778 .vsync_len = 10, 779 780 .veq_ena = true, .veq_start_f1 = 4, 781 .veq_start_f2 = 4, .veq_len = 10, 782 783 784 .vi_end_f1 = 21, .vi_end_f2 = 22, 785 .nbr_end = 539, 786 787 .burst_ena = false, 788 789 .filter_table = filter_table, 790 }, 791 792 { 793 .name = "1080p@30Hz", 794 .clock = 148500, 795 .refresh = 30000, 796 .oversample = 2, 797 .component_only = true, 798 799 .hsync_end = 88, .hblank_end = 235, 800 .hblank_start = 2155, .htotal = 2199, 801 802 .progressive = true, .trilevel_sync = true, 803 804 .vsync_start_f1 = 8, .vsync_start_f2 = 8, 805 .vsync_len = 10, 806 807 .veq_ena = false, .veq_start_f1 = 0, 808 .veq_start_f2 = 0, .veq_len = 0, 809 810 .vi_end_f1 = 44, .vi_end_f2 = 44, 811 .nbr_end = 1079, 812 813 .burst_ena = false, 814 815 .filter_table = filter_table, 816 }, 817 818 { 819 .name = "1080p@50Hz", 820 .clock = 148500, 821 .refresh = 50000, 822 .oversample = 1, 823 .component_only = true, 824 825 .hsync_end = 88, .hblank_end = 235, 826 .hblank_start = 2155, .htotal = 2639, 827 828 .progressive = true, .trilevel_sync = true, 829 830 .vsync_start_f1 = 8, .vsync_start_f2 = 8, 831 .vsync_len = 10, 832 833 .veq_ena = false, .veq_start_f1 = 0, 834 .veq_start_f2 = 0, .veq_len = 0, 835 836 .vi_end_f1 = 44, .vi_end_f2 = 44, 837 .nbr_end = 1079, 838 839 .burst_ena = false, 840 841 .filter_table = filter_table, 842 }, 843 844 { 845 .name = "1080p@60Hz", 846 .clock = 148500, 847 .refresh = 60000, 848 .oversample = 1, 849 .component_only = true, 850 851 .hsync_end = 88, .hblank_end = 235, 852 .hblank_start = 2155, .htotal = 2199, 853 854 .progressive = true, .trilevel_sync = true, 855 856 .vsync_start_f1 = 8, .vsync_start_f2 = 8, 857 .vsync_len = 10, 858 859 .veq_ena = false, .veq_start_f1 = 0, 860 .veq_start_f2 = 0, .veq_len = 0, 861 862 .vi_end_f1 = 44, .vi_end_f2 = 44, 863 .nbr_end = 1079, 864 865 .burst_ena = false, 866 867 .filter_table = filter_table, 868 }, 869 }; 870 871 struct intel_tv_connector_state { 872 struct drm_connector_state base; 873 874 /* 875 * May need to override the user margins for 876 * gen3 >1024 wide source vertical centering. 877 */ 878 struct { 879 u16 top, bottom; 880 } margins; 881 882 bool bypass_vfilter; 883 }; 884 885 #define to_intel_tv_connector_state(x) container_of(x, struct intel_tv_connector_state, base) 886 887 static struct drm_connector_state * 888 intel_tv_connector_duplicate_state(struct drm_connector *connector) 889 { 890 struct intel_tv_connector_state *state; 891 892 state = kmemdup(connector->state, sizeof(*state), GFP_KERNEL); 893 if (!state) 894 return NULL; 895 896 __drm_atomic_helper_connector_duplicate_state(connector, &state->base); 897 return &state->base; 898 } 899 900 static struct intel_tv *enc_to_tv(struct intel_encoder *encoder) 901 { 902 return container_of(encoder, struct intel_tv, base); 903 } 904 905 static struct intel_tv *intel_attached_tv(struct intel_connector *connector) 906 { 907 return enc_to_tv(intel_attached_encoder(connector)); 908 } 909 910 static bool 911 intel_tv_get_hw_state(struct intel_encoder *encoder, enum pipe *pipe) 912 { 913 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); 914 u32 tmp = intel_de_read(dev_priv, TV_CTL); 915 916 *pipe = (tmp & TV_ENC_PIPE_SEL_MASK) >> TV_ENC_PIPE_SEL_SHIFT; 917 918 return tmp & TV_ENC_ENABLE; 919 } 920 921 static void 922 intel_enable_tv(struct intel_atomic_state *state, 923 struct intel_encoder *encoder, 924 const struct intel_crtc_state *pipe_config, 925 const struct drm_connector_state *conn_state) 926 { 927 struct drm_device *dev = encoder->base.dev; 928 struct drm_i915_private *dev_priv = to_i915(dev); 929 930 /* Prevents vblank waits from timing out in intel_tv_detect_type() */ 931 intel_crtc_wait_for_next_vblank(to_intel_crtc(pipe_config->uapi.crtc)); 932 933 intel_de_write(dev_priv, TV_CTL, 934 intel_de_read(dev_priv, TV_CTL) | TV_ENC_ENABLE); 935 } 936 937 static void 938 intel_disable_tv(struct intel_atomic_state *state, 939 struct intel_encoder *encoder, 940 const struct intel_crtc_state *old_crtc_state, 941 const struct drm_connector_state *old_conn_state) 942 { 943 struct drm_device *dev = encoder->base.dev; 944 struct drm_i915_private *dev_priv = to_i915(dev); 945 946 intel_de_write(dev_priv, TV_CTL, 947 intel_de_read(dev_priv, TV_CTL) & ~TV_ENC_ENABLE); 948 } 949 950 static const struct tv_mode *intel_tv_mode_find(const struct drm_connector_state *conn_state) 951 { 952 int format = conn_state->tv.mode; 953 954 return &tv_modes[format]; 955 } 956 957 static enum drm_mode_status 958 intel_tv_mode_valid(struct drm_connector *connector, 959 struct drm_display_mode *mode) 960 { 961 const struct tv_mode *tv_mode = intel_tv_mode_find(connector->state); 962 int max_dotclk = to_i915(connector->dev)->max_dotclk_freq; 963 964 if (mode->flags & DRM_MODE_FLAG_DBLSCAN) 965 return MODE_NO_DBLESCAN; 966 967 if (mode->clock > max_dotclk) 968 return MODE_CLOCK_HIGH; 969 970 /* Ensure TV refresh is close to desired refresh */ 971 if (abs(tv_mode->refresh - drm_mode_vrefresh(mode) * 1000) >= 1000) 972 return MODE_CLOCK_RANGE; 973 974 return MODE_OK; 975 } 976 977 static int 978 intel_tv_mode_vdisplay(const struct tv_mode *tv_mode) 979 { 980 if (tv_mode->progressive) 981 return tv_mode->nbr_end + 1; 982 else 983 return 2 * (tv_mode->nbr_end + 1); 984 } 985 986 static void 987 intel_tv_mode_to_mode(struct drm_display_mode *mode, 988 const struct tv_mode *tv_mode, 989 int clock) 990 { 991 mode->clock = clock / (tv_mode->oversample >> !tv_mode->progressive); 992 993 /* 994 * tv_mode horizontal timings: 995 * 996 * hsync_end 997 * | hblank_end 998 * | | hblank_start 999 * | | | htotal 1000 * | _______ | 1001 * ____/ \___ 1002 * \__/ \ 1003 */ 1004 mode->hdisplay = 1005 tv_mode->hblank_start - tv_mode->hblank_end; 1006 mode->hsync_start = mode->hdisplay + 1007 tv_mode->htotal - tv_mode->hblank_start; 1008 mode->hsync_end = mode->hsync_start + 1009 tv_mode->hsync_end; 1010 mode->htotal = tv_mode->htotal + 1; 1011 1012 /* 1013 * tv_mode vertical timings: 1014 * 1015 * vsync_start 1016 * | vsync_end 1017 * | | vi_end nbr_end 1018 * | | | | 1019 * | | _______ 1020 * \__ ____/ \ 1021 * \__/ 1022 */ 1023 mode->vdisplay = intel_tv_mode_vdisplay(tv_mode); 1024 if (tv_mode->progressive) { 1025 mode->vsync_start = mode->vdisplay + 1026 tv_mode->vsync_start_f1 + 1; 1027 mode->vsync_end = mode->vsync_start + 1028 tv_mode->vsync_len; 1029 mode->vtotal = mode->vdisplay + 1030 tv_mode->vi_end_f1 + 1; 1031 } else { 1032 mode->vsync_start = mode->vdisplay + 1033 tv_mode->vsync_start_f1 + 1 + 1034 tv_mode->vsync_start_f2 + 1; 1035 mode->vsync_end = mode->vsync_start + 1036 2 * tv_mode->vsync_len; 1037 mode->vtotal = mode->vdisplay + 1038 tv_mode->vi_end_f1 + 1 + 1039 tv_mode->vi_end_f2 + 1; 1040 } 1041 1042 /* TV has it's own notion of sync and other mode flags, so clear them. */ 1043 mode->flags = 0; 1044 1045 snprintf(mode->name, sizeof(mode->name), 1046 "%dx%d%c (%s)", 1047 mode->hdisplay, mode->vdisplay, 1048 tv_mode->progressive ? 'p' : 'i', 1049 tv_mode->name); 1050 } 1051 1052 static void intel_tv_scale_mode_horiz(struct drm_display_mode *mode, 1053 int hdisplay, int left_margin, 1054 int right_margin) 1055 { 1056 int hsync_start = mode->hsync_start - mode->hdisplay + right_margin; 1057 int hsync_end = mode->hsync_end - mode->hdisplay + right_margin; 1058 int new_htotal = mode->htotal * hdisplay / 1059 (mode->hdisplay - left_margin - right_margin); 1060 1061 mode->clock = mode->clock * new_htotal / mode->htotal; 1062 1063 mode->hdisplay = hdisplay; 1064 mode->hsync_start = hdisplay + hsync_start * new_htotal / mode->htotal; 1065 mode->hsync_end = hdisplay + hsync_end * new_htotal / mode->htotal; 1066 mode->htotal = new_htotal; 1067 } 1068 1069 static void intel_tv_scale_mode_vert(struct drm_display_mode *mode, 1070 int vdisplay, int top_margin, 1071 int bottom_margin) 1072 { 1073 int vsync_start = mode->vsync_start - mode->vdisplay + bottom_margin; 1074 int vsync_end = mode->vsync_end - mode->vdisplay + bottom_margin; 1075 int new_vtotal = mode->vtotal * vdisplay / 1076 (mode->vdisplay - top_margin - bottom_margin); 1077 1078 mode->clock = mode->clock * new_vtotal / mode->vtotal; 1079 1080 mode->vdisplay = vdisplay; 1081 mode->vsync_start = vdisplay + vsync_start * new_vtotal / mode->vtotal; 1082 mode->vsync_end = vdisplay + vsync_end * new_vtotal / mode->vtotal; 1083 mode->vtotal = new_vtotal; 1084 } 1085 1086 static void 1087 intel_tv_get_config(struct intel_encoder *encoder, 1088 struct intel_crtc_state *pipe_config) 1089 { 1090 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); 1091 struct drm_display_mode *adjusted_mode = 1092 &pipe_config->hw.adjusted_mode; 1093 struct drm_display_mode mode = {}; 1094 u32 tv_ctl, hctl1, hctl3, vctl1, vctl2, tmp; 1095 struct tv_mode tv_mode = {}; 1096 int hdisplay = adjusted_mode->crtc_hdisplay; 1097 int vdisplay = adjusted_mode->crtc_vdisplay; 1098 int xsize, ysize, xpos, ypos; 1099 1100 pipe_config->output_types |= BIT(INTEL_OUTPUT_TVOUT); 1101 1102 tv_ctl = intel_de_read(dev_priv, TV_CTL); 1103 hctl1 = intel_de_read(dev_priv, TV_H_CTL_1); 1104 hctl3 = intel_de_read(dev_priv, TV_H_CTL_3); 1105 vctl1 = intel_de_read(dev_priv, TV_V_CTL_1); 1106 vctl2 = intel_de_read(dev_priv, TV_V_CTL_2); 1107 1108 tv_mode.htotal = (hctl1 & TV_HTOTAL_MASK) >> TV_HTOTAL_SHIFT; 1109 tv_mode.hsync_end = (hctl1 & TV_HSYNC_END_MASK) >> TV_HSYNC_END_SHIFT; 1110 1111 tv_mode.hblank_start = (hctl3 & TV_HBLANK_START_MASK) >> TV_HBLANK_START_SHIFT; 1112 tv_mode.hblank_end = (hctl3 & TV_HSYNC_END_MASK) >> TV_HBLANK_END_SHIFT; 1113 1114 tv_mode.nbr_end = (vctl1 & TV_NBR_END_MASK) >> TV_NBR_END_SHIFT; 1115 tv_mode.vi_end_f1 = (vctl1 & TV_VI_END_F1_MASK) >> TV_VI_END_F1_SHIFT; 1116 tv_mode.vi_end_f2 = (vctl1 & TV_VI_END_F2_MASK) >> TV_VI_END_F2_SHIFT; 1117 1118 tv_mode.vsync_len = (vctl2 & TV_VSYNC_LEN_MASK) >> TV_VSYNC_LEN_SHIFT; 1119 tv_mode.vsync_start_f1 = (vctl2 & TV_VSYNC_START_F1_MASK) >> TV_VSYNC_START_F1_SHIFT; 1120 tv_mode.vsync_start_f2 = (vctl2 & TV_VSYNC_START_F2_MASK) >> TV_VSYNC_START_F2_SHIFT; 1121 1122 tv_mode.clock = pipe_config->port_clock; 1123 1124 tv_mode.progressive = tv_ctl & TV_PROGRESSIVE; 1125 1126 switch (tv_ctl & TV_OVERSAMPLE_MASK) { 1127 case TV_OVERSAMPLE_8X: 1128 tv_mode.oversample = 8; 1129 break; 1130 case TV_OVERSAMPLE_4X: 1131 tv_mode.oversample = 4; 1132 break; 1133 case TV_OVERSAMPLE_2X: 1134 tv_mode.oversample = 2; 1135 break; 1136 default: 1137 tv_mode.oversample = 1; 1138 break; 1139 } 1140 1141 tmp = intel_de_read(dev_priv, TV_WIN_POS); 1142 xpos = tmp >> 16; 1143 ypos = tmp & 0xffff; 1144 1145 tmp = intel_de_read(dev_priv, TV_WIN_SIZE); 1146 xsize = tmp >> 16; 1147 ysize = tmp & 0xffff; 1148 1149 intel_tv_mode_to_mode(&mode, &tv_mode, pipe_config->port_clock); 1150 1151 drm_dbg_kms(&dev_priv->drm, "TV mode: " DRM_MODE_FMT "\n", 1152 DRM_MODE_ARG(&mode)); 1153 1154 intel_tv_scale_mode_horiz(&mode, hdisplay, 1155 xpos, mode.hdisplay - xsize - xpos); 1156 intel_tv_scale_mode_vert(&mode, vdisplay, 1157 ypos, mode.vdisplay - ysize - ypos); 1158 1159 adjusted_mode->crtc_clock = mode.clock; 1160 if (adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE) 1161 adjusted_mode->crtc_clock /= 2; 1162 1163 /* pixel counter doesn't work on i965gm TV output */ 1164 if (IS_I965GM(dev_priv)) 1165 pipe_config->mode_flags |= 1166 I915_MODE_FLAG_USE_SCANLINE_COUNTER; 1167 } 1168 1169 static bool intel_tv_source_too_wide(struct drm_i915_private *dev_priv, 1170 int hdisplay) 1171 { 1172 return DISPLAY_VER(dev_priv) == 3 && hdisplay > 1024; 1173 } 1174 1175 static bool intel_tv_vert_scaling(const struct drm_display_mode *tv_mode, 1176 const struct drm_connector_state *conn_state, 1177 int vdisplay) 1178 { 1179 return tv_mode->crtc_vdisplay - 1180 conn_state->tv.margins.top - 1181 conn_state->tv.margins.bottom != 1182 vdisplay; 1183 } 1184 1185 static int 1186 intel_tv_compute_config(struct intel_encoder *encoder, 1187 struct intel_crtc_state *pipe_config, 1188 struct drm_connector_state *conn_state) 1189 { 1190 struct intel_atomic_state *state = 1191 to_intel_atomic_state(pipe_config->uapi.state); 1192 struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc); 1193 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); 1194 struct intel_tv_connector_state *tv_conn_state = 1195 to_intel_tv_connector_state(conn_state); 1196 const struct tv_mode *tv_mode = intel_tv_mode_find(conn_state); 1197 struct drm_display_mode *adjusted_mode = 1198 &pipe_config->hw.adjusted_mode; 1199 int hdisplay = adjusted_mode->crtc_hdisplay; 1200 int vdisplay = adjusted_mode->crtc_vdisplay; 1201 int ret; 1202 1203 if (!tv_mode) 1204 return -EINVAL; 1205 1206 if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) 1207 return -EINVAL; 1208 1209 pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; 1210 1211 drm_dbg_kms(&dev_priv->drm, "forcing bpc to 8 for TV\n"); 1212 pipe_config->pipe_bpp = 8*3; 1213 1214 pipe_config->port_clock = tv_mode->clock; 1215 1216 ret = intel_dpll_crtc_compute_clock(state, crtc); 1217 if (ret) 1218 return ret; 1219 1220 pipe_config->clock_set = true; 1221 1222 intel_tv_mode_to_mode(adjusted_mode, tv_mode, pipe_config->port_clock); 1223 drm_mode_set_crtcinfo(adjusted_mode, 0); 1224 1225 if (intel_tv_source_too_wide(dev_priv, hdisplay) || 1226 !intel_tv_vert_scaling(adjusted_mode, conn_state, vdisplay)) { 1227 int extra, top, bottom; 1228 1229 extra = adjusted_mode->crtc_vdisplay - vdisplay; 1230 1231 if (extra < 0) { 1232 drm_dbg_kms(&dev_priv->drm, 1233 "No vertical scaling for >1024 pixel wide modes\n"); 1234 return -EINVAL; 1235 } 1236 1237 /* Need to turn off the vertical filter and center the image */ 1238 1239 /* Attempt to maintain the relative sizes of the margins */ 1240 top = conn_state->tv.margins.top; 1241 bottom = conn_state->tv.margins.bottom; 1242 1243 if (top + bottom) 1244 top = extra * top / (top + bottom); 1245 else 1246 top = extra / 2; 1247 bottom = extra - top; 1248 1249 tv_conn_state->margins.top = top; 1250 tv_conn_state->margins.bottom = bottom; 1251 1252 tv_conn_state->bypass_vfilter = true; 1253 1254 if (!tv_mode->progressive) { 1255 adjusted_mode->clock /= 2; 1256 adjusted_mode->crtc_clock /= 2; 1257 adjusted_mode->flags |= DRM_MODE_FLAG_INTERLACE; 1258 } 1259 } else { 1260 tv_conn_state->margins.top = conn_state->tv.margins.top; 1261 tv_conn_state->margins.bottom = conn_state->tv.margins.bottom; 1262 1263 tv_conn_state->bypass_vfilter = false; 1264 } 1265 1266 drm_dbg_kms(&dev_priv->drm, "TV mode: " DRM_MODE_FMT "\n", 1267 DRM_MODE_ARG(adjusted_mode)); 1268 1269 /* 1270 * The pipe scanline counter behaviour looks as follows when 1271 * using the TV encoder: 1272 * 1273 * time -> 1274 * 1275 * dsl=vtotal-1 | | 1276 * || || 1277 * ___| | ___| | 1278 * / | / | 1279 * / | / | 1280 * dsl=0 ___/ |_____/ | 1281 * | | | | | | 1282 * ^ ^ ^ ^ ^ 1283 * | | | | pipe vblank/first part of tv vblank 1284 * | | | bottom margin 1285 * | | active 1286 * | top margin 1287 * remainder of tv vblank 1288 * 1289 * When the TV encoder is used the pipe wants to run faster 1290 * than expected rate. During the active portion the TV 1291 * encoder stalls the pipe every few lines to keep it in 1292 * check. When the TV encoder reaches the bottom margin the 1293 * pipe simply stops. Once we reach the TV vblank the pipe is 1294 * no longer stalled and it runs at the max rate (apparently 1295 * oversample clock on gen3, cdclk on gen4). Once the pipe 1296 * reaches the pipe vtotal the pipe stops for the remainder 1297 * of the TV vblank/top margin. The pipe starts up again when 1298 * the TV encoder exits the top margin. 1299 * 1300 * To avoid huge hassles for vblank timestamping we scale 1301 * the pipe timings as if the pipe always runs at the average 1302 * rate it maintains during the active period. This also 1303 * gives us a reasonable guesstimate as to the pixel rate. 1304 * Due to the variation in the actual pipe speed the scanline 1305 * counter will give us slightly erroneous results during the 1306 * TV vblank/margins. But since vtotal was selected such that 1307 * it matches the average rate of the pipe during the active 1308 * portion the error shouldn't cause any serious grief to 1309 * vblank timestamps. 1310 * 1311 * For posterity here is the empirically derived formula 1312 * that gives us the maximum length of the pipe vblank 1313 * we can use without causing display corruption. Following 1314 * this would allow us to have a ticking scanline counter 1315 * everywhere except during the bottom margin (there the 1316 * pipe always stops). Ie. this would eliminate the second 1317 * flat portion of the above graph. However this would also 1318 * complicate vblank timestamping as the pipe vtotal would 1319 * no longer match the average rate the pipe runs at during 1320 * the active portion. Hence following this formula seems 1321 * more trouble that it's worth. 1322 * 1323 * if (GRAPHICS_VER(dev_priv) == 4) { 1324 * num = cdclk * (tv_mode->oversample >> !tv_mode->progressive); 1325 * den = tv_mode->clock; 1326 * } else { 1327 * num = tv_mode->oversample >> !tv_mode->progressive; 1328 * den = 1; 1329 * } 1330 * max_pipe_vblank_len ~= 1331 * (num * tv_htotal * (tv_vblank_len + top_margin)) / 1332 * (den * pipe_htotal); 1333 */ 1334 intel_tv_scale_mode_horiz(adjusted_mode, hdisplay, 1335 conn_state->tv.margins.left, 1336 conn_state->tv.margins.right); 1337 intel_tv_scale_mode_vert(adjusted_mode, vdisplay, 1338 tv_conn_state->margins.top, 1339 tv_conn_state->margins.bottom); 1340 drm_mode_set_crtcinfo(adjusted_mode, 0); 1341 adjusted_mode->name[0] = '\0'; 1342 1343 /* pixel counter doesn't work on i965gm TV output */ 1344 if (IS_I965GM(dev_priv)) 1345 pipe_config->mode_flags |= 1346 I915_MODE_FLAG_USE_SCANLINE_COUNTER; 1347 1348 return 0; 1349 } 1350 1351 static void 1352 set_tv_mode_timings(struct drm_i915_private *dev_priv, 1353 const struct tv_mode *tv_mode, 1354 bool burst_ena) 1355 { 1356 u32 hctl1, hctl2, hctl3; 1357 u32 vctl1, vctl2, vctl3, vctl4, vctl5, vctl6, vctl7; 1358 1359 hctl1 = (tv_mode->hsync_end << TV_HSYNC_END_SHIFT) | 1360 (tv_mode->htotal << TV_HTOTAL_SHIFT); 1361 1362 hctl2 = (tv_mode->hburst_start << 16) | 1363 (tv_mode->hburst_len << TV_HBURST_LEN_SHIFT); 1364 1365 if (burst_ena) 1366 hctl2 |= TV_BURST_ENA; 1367 1368 hctl3 = (tv_mode->hblank_start << TV_HBLANK_START_SHIFT) | 1369 (tv_mode->hblank_end << TV_HBLANK_END_SHIFT); 1370 1371 vctl1 = (tv_mode->nbr_end << TV_NBR_END_SHIFT) | 1372 (tv_mode->vi_end_f1 << TV_VI_END_F1_SHIFT) | 1373 (tv_mode->vi_end_f2 << TV_VI_END_F2_SHIFT); 1374 1375 vctl2 = (tv_mode->vsync_len << TV_VSYNC_LEN_SHIFT) | 1376 (tv_mode->vsync_start_f1 << TV_VSYNC_START_F1_SHIFT) | 1377 (tv_mode->vsync_start_f2 << TV_VSYNC_START_F2_SHIFT); 1378 1379 vctl3 = (tv_mode->veq_len << TV_VEQ_LEN_SHIFT) | 1380 (tv_mode->veq_start_f1 << TV_VEQ_START_F1_SHIFT) | 1381 (tv_mode->veq_start_f2 << TV_VEQ_START_F2_SHIFT); 1382 1383 if (tv_mode->veq_ena) 1384 vctl3 |= TV_EQUAL_ENA; 1385 1386 vctl4 = (tv_mode->vburst_start_f1 << TV_VBURST_START_F1_SHIFT) | 1387 (tv_mode->vburst_end_f1 << TV_VBURST_END_F1_SHIFT); 1388 1389 vctl5 = (tv_mode->vburst_start_f2 << TV_VBURST_START_F2_SHIFT) | 1390 (tv_mode->vburst_end_f2 << TV_VBURST_END_F2_SHIFT); 1391 1392 vctl6 = (tv_mode->vburst_start_f3 << TV_VBURST_START_F3_SHIFT) | 1393 (tv_mode->vburst_end_f3 << TV_VBURST_END_F3_SHIFT); 1394 1395 vctl7 = (tv_mode->vburst_start_f4 << TV_VBURST_START_F4_SHIFT) | 1396 (tv_mode->vburst_end_f4 << TV_VBURST_END_F4_SHIFT); 1397 1398 intel_de_write(dev_priv, TV_H_CTL_1, hctl1); 1399 intel_de_write(dev_priv, TV_H_CTL_2, hctl2); 1400 intel_de_write(dev_priv, TV_H_CTL_3, hctl3); 1401 intel_de_write(dev_priv, TV_V_CTL_1, vctl1); 1402 intel_de_write(dev_priv, TV_V_CTL_2, vctl2); 1403 intel_de_write(dev_priv, TV_V_CTL_3, vctl3); 1404 intel_de_write(dev_priv, TV_V_CTL_4, vctl4); 1405 intel_de_write(dev_priv, TV_V_CTL_5, vctl5); 1406 intel_de_write(dev_priv, TV_V_CTL_6, vctl6); 1407 intel_de_write(dev_priv, TV_V_CTL_7, vctl7); 1408 } 1409 1410 static void set_color_conversion(struct drm_i915_private *dev_priv, 1411 const struct color_conversion *color_conversion) 1412 { 1413 if (!color_conversion) 1414 return; 1415 1416 intel_de_write(dev_priv, TV_CSC_Y, 1417 (color_conversion->ry << 16) | color_conversion->gy); 1418 intel_de_write(dev_priv, TV_CSC_Y2, 1419 (color_conversion->by << 16) | color_conversion->ay); 1420 intel_de_write(dev_priv, TV_CSC_U, 1421 (color_conversion->ru << 16) | color_conversion->gu); 1422 intel_de_write(dev_priv, TV_CSC_U2, 1423 (color_conversion->bu << 16) | color_conversion->au); 1424 intel_de_write(dev_priv, TV_CSC_V, 1425 (color_conversion->rv << 16) | color_conversion->gv); 1426 intel_de_write(dev_priv, TV_CSC_V2, 1427 (color_conversion->bv << 16) | color_conversion->av); 1428 } 1429 1430 static void intel_tv_pre_enable(struct intel_atomic_state *state, 1431 struct intel_encoder *encoder, 1432 const struct intel_crtc_state *pipe_config, 1433 const struct drm_connector_state *conn_state) 1434 { 1435 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); 1436 struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc); 1437 struct intel_tv *intel_tv = enc_to_tv(encoder); 1438 const struct intel_tv_connector_state *tv_conn_state = 1439 to_intel_tv_connector_state(conn_state); 1440 const struct tv_mode *tv_mode = intel_tv_mode_find(conn_state); 1441 u32 tv_ctl, tv_filter_ctl; 1442 u32 scctl1, scctl2, scctl3; 1443 int i, j; 1444 const struct video_levels *video_levels; 1445 const struct color_conversion *color_conversion; 1446 bool burst_ena; 1447 int xpos, ypos; 1448 unsigned int xsize, ysize; 1449 1450 if (!tv_mode) 1451 return; /* can't happen (mode_prepare prevents this) */ 1452 1453 tv_ctl = intel_de_read(dev_priv, TV_CTL); 1454 tv_ctl &= TV_CTL_SAVE; 1455 1456 switch (intel_tv->type) { 1457 default: 1458 case DRM_MODE_CONNECTOR_Unknown: 1459 case DRM_MODE_CONNECTOR_Composite: 1460 tv_ctl |= TV_ENC_OUTPUT_COMPOSITE; 1461 video_levels = tv_mode->composite_levels; 1462 color_conversion = tv_mode->composite_color; 1463 burst_ena = tv_mode->burst_ena; 1464 break; 1465 case DRM_MODE_CONNECTOR_Component: 1466 tv_ctl |= TV_ENC_OUTPUT_COMPONENT; 1467 video_levels = &component_levels; 1468 if (tv_mode->burst_ena) 1469 color_conversion = &sdtv_csc_yprpb; 1470 else 1471 color_conversion = &hdtv_csc_yprpb; 1472 burst_ena = false; 1473 break; 1474 case DRM_MODE_CONNECTOR_SVIDEO: 1475 tv_ctl |= TV_ENC_OUTPUT_SVIDEO; 1476 video_levels = tv_mode->svideo_levels; 1477 color_conversion = tv_mode->svideo_color; 1478 burst_ena = tv_mode->burst_ena; 1479 break; 1480 } 1481 1482 tv_ctl |= TV_ENC_PIPE_SEL(crtc->pipe); 1483 1484 switch (tv_mode->oversample) { 1485 case 8: 1486 tv_ctl |= TV_OVERSAMPLE_8X; 1487 break; 1488 case 4: 1489 tv_ctl |= TV_OVERSAMPLE_4X; 1490 break; 1491 case 2: 1492 tv_ctl |= TV_OVERSAMPLE_2X; 1493 break; 1494 default: 1495 tv_ctl |= TV_OVERSAMPLE_NONE; 1496 break; 1497 } 1498 1499 if (tv_mode->progressive) 1500 tv_ctl |= TV_PROGRESSIVE; 1501 if (tv_mode->trilevel_sync) 1502 tv_ctl |= TV_TRILEVEL_SYNC; 1503 if (tv_mode->pal_burst) 1504 tv_ctl |= TV_PAL_BURST; 1505 1506 scctl1 = 0; 1507 if (tv_mode->dda1_inc) 1508 scctl1 |= TV_SC_DDA1_EN; 1509 if (tv_mode->dda2_inc) 1510 scctl1 |= TV_SC_DDA2_EN; 1511 if (tv_mode->dda3_inc) 1512 scctl1 |= TV_SC_DDA3_EN; 1513 scctl1 |= tv_mode->sc_reset; 1514 if (video_levels) 1515 scctl1 |= video_levels->burst << TV_BURST_LEVEL_SHIFT; 1516 scctl1 |= tv_mode->dda1_inc << TV_SCDDA1_INC_SHIFT; 1517 1518 scctl2 = tv_mode->dda2_size << TV_SCDDA2_SIZE_SHIFT | 1519 tv_mode->dda2_inc << TV_SCDDA2_INC_SHIFT; 1520 1521 scctl3 = tv_mode->dda3_size << TV_SCDDA3_SIZE_SHIFT | 1522 tv_mode->dda3_inc << TV_SCDDA3_INC_SHIFT; 1523 1524 /* Enable two fixes for the chips that need them. */ 1525 if (IS_I915GM(dev_priv)) 1526 tv_ctl |= TV_ENC_C0_FIX | TV_ENC_SDP_FIX; 1527 1528 set_tv_mode_timings(dev_priv, tv_mode, burst_ena); 1529 1530 intel_de_write(dev_priv, TV_SC_CTL_1, scctl1); 1531 intel_de_write(dev_priv, TV_SC_CTL_2, scctl2); 1532 intel_de_write(dev_priv, TV_SC_CTL_3, scctl3); 1533 1534 set_color_conversion(dev_priv, color_conversion); 1535 1536 if (DISPLAY_VER(dev_priv) >= 4) 1537 intel_de_write(dev_priv, TV_CLR_KNOBS, 0x00404000); 1538 else 1539 intel_de_write(dev_priv, TV_CLR_KNOBS, 0x00606000); 1540 1541 if (video_levels) 1542 intel_de_write(dev_priv, TV_CLR_LEVEL, 1543 ((video_levels->black << TV_BLACK_LEVEL_SHIFT) | (video_levels->blank << TV_BLANK_LEVEL_SHIFT))); 1544 1545 assert_transcoder_disabled(dev_priv, pipe_config->cpu_transcoder); 1546 1547 /* Filter ctl must be set before TV_WIN_SIZE */ 1548 tv_filter_ctl = TV_AUTO_SCALE; 1549 if (tv_conn_state->bypass_vfilter) 1550 tv_filter_ctl |= TV_V_FILTER_BYPASS; 1551 intel_de_write(dev_priv, TV_FILTER_CTL_1, tv_filter_ctl); 1552 1553 xsize = tv_mode->hblank_start - tv_mode->hblank_end; 1554 ysize = intel_tv_mode_vdisplay(tv_mode); 1555 1556 xpos = conn_state->tv.margins.left; 1557 ypos = tv_conn_state->margins.top; 1558 xsize -= (conn_state->tv.margins.left + 1559 conn_state->tv.margins.right); 1560 ysize -= (tv_conn_state->margins.top + 1561 tv_conn_state->margins.bottom); 1562 intel_de_write(dev_priv, TV_WIN_POS, (xpos << 16) | ypos); 1563 intel_de_write(dev_priv, TV_WIN_SIZE, (xsize << 16) | ysize); 1564 1565 j = 0; 1566 for (i = 0; i < 60; i++) 1567 intel_de_write(dev_priv, TV_H_LUMA(i), 1568 tv_mode->filter_table[j++]); 1569 for (i = 0; i < 60; i++) 1570 intel_de_write(dev_priv, TV_H_CHROMA(i), 1571 tv_mode->filter_table[j++]); 1572 for (i = 0; i < 43; i++) 1573 intel_de_write(dev_priv, TV_V_LUMA(i), 1574 tv_mode->filter_table[j++]); 1575 for (i = 0; i < 43; i++) 1576 intel_de_write(dev_priv, TV_V_CHROMA(i), 1577 tv_mode->filter_table[j++]); 1578 intel_de_write(dev_priv, TV_DAC, 1579 intel_de_read(dev_priv, TV_DAC) & TV_DAC_SAVE); 1580 intel_de_write(dev_priv, TV_CTL, tv_ctl); 1581 } 1582 1583 static int 1584 intel_tv_detect_type(struct intel_tv *intel_tv, 1585 struct drm_connector *connector) 1586 { 1587 struct intel_crtc *crtc = to_intel_crtc(connector->state->crtc); 1588 struct drm_device *dev = connector->dev; 1589 struct drm_i915_private *dev_priv = to_i915(dev); 1590 u32 tv_ctl, save_tv_ctl; 1591 u32 tv_dac, save_tv_dac; 1592 int type; 1593 1594 /* Disable TV interrupts around load detect or we'll recurse */ 1595 if (connector->polled & DRM_CONNECTOR_POLL_HPD) { 1596 spin_lock_irq(&dev_priv->irq_lock); 1597 i915_disable_pipestat(dev_priv, 0, 1598 PIPE_HOTPLUG_INTERRUPT_STATUS | 1599 PIPE_HOTPLUG_TV_INTERRUPT_STATUS); 1600 spin_unlock_irq(&dev_priv->irq_lock); 1601 } 1602 1603 save_tv_dac = tv_dac = intel_de_read(dev_priv, TV_DAC); 1604 save_tv_ctl = tv_ctl = intel_de_read(dev_priv, TV_CTL); 1605 1606 /* Poll for TV detection */ 1607 tv_ctl &= ~(TV_ENC_ENABLE | TV_ENC_PIPE_SEL_MASK | TV_TEST_MODE_MASK); 1608 tv_ctl |= TV_TEST_MODE_MONITOR_DETECT; 1609 tv_ctl |= TV_ENC_PIPE_SEL(crtc->pipe); 1610 1611 tv_dac &= ~(TVDAC_SENSE_MASK | DAC_A_MASK | DAC_B_MASK | DAC_C_MASK); 1612 tv_dac |= (TVDAC_STATE_CHG_EN | 1613 TVDAC_A_SENSE_CTL | 1614 TVDAC_B_SENSE_CTL | 1615 TVDAC_C_SENSE_CTL | 1616 DAC_CTL_OVERRIDE | 1617 DAC_A_0_7_V | 1618 DAC_B_0_7_V | 1619 DAC_C_0_7_V); 1620 1621 1622 /* 1623 * The TV sense state should be cleared to zero on cantiga platform. Otherwise 1624 * the TV is misdetected. This is hardware requirement. 1625 */ 1626 if (IS_GM45(dev_priv)) 1627 tv_dac &= ~(TVDAC_STATE_CHG_EN | TVDAC_A_SENSE_CTL | 1628 TVDAC_B_SENSE_CTL | TVDAC_C_SENSE_CTL); 1629 1630 intel_de_write(dev_priv, TV_CTL, tv_ctl); 1631 intel_de_write(dev_priv, TV_DAC, tv_dac); 1632 intel_de_posting_read(dev_priv, TV_DAC); 1633 1634 intel_crtc_wait_for_next_vblank(crtc); 1635 1636 type = -1; 1637 tv_dac = intel_de_read(dev_priv, TV_DAC); 1638 drm_dbg_kms(&dev_priv->drm, "TV detected: %x, %x\n", tv_ctl, tv_dac); 1639 /* 1640 * A B C 1641 * 0 1 1 Composite 1642 * 1 0 X svideo 1643 * 0 0 0 Component 1644 */ 1645 if ((tv_dac & TVDAC_SENSE_MASK) == (TVDAC_B_SENSE | TVDAC_C_SENSE)) { 1646 drm_dbg_kms(&dev_priv->drm, 1647 "Detected Composite TV connection\n"); 1648 type = DRM_MODE_CONNECTOR_Composite; 1649 } else if ((tv_dac & (TVDAC_A_SENSE|TVDAC_B_SENSE)) == TVDAC_A_SENSE) { 1650 drm_dbg_kms(&dev_priv->drm, 1651 "Detected S-Video TV connection\n"); 1652 type = DRM_MODE_CONNECTOR_SVIDEO; 1653 } else if ((tv_dac & TVDAC_SENSE_MASK) == 0) { 1654 drm_dbg_kms(&dev_priv->drm, 1655 "Detected Component TV connection\n"); 1656 type = DRM_MODE_CONNECTOR_Component; 1657 } else { 1658 drm_dbg_kms(&dev_priv->drm, "Unrecognised TV connection\n"); 1659 type = -1; 1660 } 1661 1662 intel_de_write(dev_priv, TV_DAC, save_tv_dac & ~TVDAC_STATE_CHG_EN); 1663 intel_de_write(dev_priv, TV_CTL, save_tv_ctl); 1664 intel_de_posting_read(dev_priv, TV_CTL); 1665 1666 /* For unknown reasons the hw barfs if we don't do this vblank wait. */ 1667 intel_crtc_wait_for_next_vblank(crtc); 1668 1669 /* Restore interrupt config */ 1670 if (connector->polled & DRM_CONNECTOR_POLL_HPD) { 1671 spin_lock_irq(&dev_priv->irq_lock); 1672 i915_enable_pipestat(dev_priv, 0, 1673 PIPE_HOTPLUG_INTERRUPT_STATUS | 1674 PIPE_HOTPLUG_TV_INTERRUPT_STATUS); 1675 spin_unlock_irq(&dev_priv->irq_lock); 1676 } 1677 1678 return type; 1679 } 1680 1681 /* 1682 * Here we set accurate tv format according to connector type 1683 * i.e Component TV should not be assigned by NTSC or PAL 1684 */ 1685 static void intel_tv_find_better_format(struct drm_connector *connector) 1686 { 1687 struct intel_tv *intel_tv = intel_attached_tv(to_intel_connector(connector)); 1688 const struct tv_mode *tv_mode = intel_tv_mode_find(connector->state); 1689 int i; 1690 1691 /* Component supports everything so we can keep the current mode */ 1692 if (intel_tv->type == DRM_MODE_CONNECTOR_Component) 1693 return; 1694 1695 /* If the current mode is fine don't change it */ 1696 if (!tv_mode->component_only) 1697 return; 1698 1699 for (i = 0; i < ARRAY_SIZE(tv_modes); i++) { 1700 tv_mode = &tv_modes[i]; 1701 1702 if (!tv_mode->component_only) 1703 break; 1704 } 1705 1706 connector->state->tv.mode = i; 1707 } 1708 1709 static int 1710 intel_tv_detect(struct drm_connector *connector, 1711 struct drm_modeset_acquire_ctx *ctx, 1712 bool force) 1713 { 1714 struct drm_i915_private *i915 = to_i915(connector->dev); 1715 struct intel_tv *intel_tv = intel_attached_tv(to_intel_connector(connector)); 1716 enum drm_connector_status status; 1717 int type; 1718 1719 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] force=%d\n", 1720 connector->base.id, connector->name, force); 1721 1722 if (!INTEL_DISPLAY_ENABLED(i915)) 1723 return connector_status_disconnected; 1724 1725 if (force) { 1726 struct intel_load_detect_pipe tmp; 1727 int ret; 1728 1729 ret = intel_get_load_detect_pipe(connector, &tmp, ctx); 1730 if (ret < 0) 1731 return ret; 1732 1733 if (ret > 0) { 1734 type = intel_tv_detect_type(intel_tv, connector); 1735 intel_release_load_detect_pipe(connector, &tmp, ctx); 1736 status = type < 0 ? 1737 connector_status_disconnected : 1738 connector_status_connected; 1739 } else 1740 status = connector_status_unknown; 1741 1742 if (status == connector_status_connected) { 1743 intel_tv->type = type; 1744 intel_tv_find_better_format(connector); 1745 } 1746 1747 return status; 1748 } else 1749 return connector->status; 1750 } 1751 1752 static const struct input_res { 1753 u16 w, h; 1754 } input_res_table[] = { 1755 { 640, 480 }, 1756 { 800, 600 }, 1757 { 1024, 768 }, 1758 { 1280, 1024 }, 1759 { 848, 480 }, 1760 { 1280, 720 }, 1761 { 1920, 1080 }, 1762 }; 1763 1764 /* Choose preferred mode according to line number of TV format */ 1765 static bool 1766 intel_tv_is_preferred_mode(const struct drm_display_mode *mode, 1767 const struct tv_mode *tv_mode) 1768 { 1769 int vdisplay = intel_tv_mode_vdisplay(tv_mode); 1770 1771 /* prefer 480 line modes for all SD TV modes */ 1772 if (vdisplay <= 576) 1773 vdisplay = 480; 1774 1775 return vdisplay == mode->vdisplay; 1776 } 1777 1778 static void 1779 intel_tv_set_mode_type(struct drm_display_mode *mode, 1780 const struct tv_mode *tv_mode) 1781 { 1782 mode->type = DRM_MODE_TYPE_DRIVER; 1783 1784 if (intel_tv_is_preferred_mode(mode, tv_mode)) 1785 mode->type |= DRM_MODE_TYPE_PREFERRED; 1786 } 1787 1788 static int 1789 intel_tv_get_modes(struct drm_connector *connector) 1790 { 1791 struct drm_i915_private *dev_priv = to_i915(connector->dev); 1792 const struct tv_mode *tv_mode = intel_tv_mode_find(connector->state); 1793 int i, count = 0; 1794 1795 for (i = 0; i < ARRAY_SIZE(input_res_table); i++) { 1796 const struct input_res *input = &input_res_table[i]; 1797 struct drm_display_mode *mode; 1798 1799 if (input->w > 1024 && 1800 !tv_mode->progressive && 1801 !tv_mode->component_only) 1802 continue; 1803 1804 /* no vertical scaling with wide sources on gen3 */ 1805 if (DISPLAY_VER(dev_priv) == 3 && input->w > 1024 && 1806 input->h > intel_tv_mode_vdisplay(tv_mode)) 1807 continue; 1808 1809 mode = drm_mode_create(connector->dev); 1810 if (!mode) 1811 continue; 1812 1813 /* 1814 * We take the TV mode and scale it to look 1815 * like it had the expected h/vdisplay. This 1816 * provides the most information to userspace 1817 * about the actual timings of the mode. We 1818 * do ignore the margins though. 1819 */ 1820 intel_tv_mode_to_mode(mode, tv_mode, tv_mode->clock); 1821 if (count == 0) { 1822 drm_dbg_kms(&dev_priv->drm, "TV mode: " DRM_MODE_FMT "\n", 1823 DRM_MODE_ARG(mode)); 1824 } 1825 intel_tv_scale_mode_horiz(mode, input->w, 0, 0); 1826 intel_tv_scale_mode_vert(mode, input->h, 0, 0); 1827 intel_tv_set_mode_type(mode, tv_mode); 1828 1829 drm_mode_set_name(mode); 1830 1831 drm_mode_probed_add(connector, mode); 1832 count++; 1833 } 1834 1835 return count; 1836 } 1837 1838 static const struct drm_connector_funcs intel_tv_connector_funcs = { 1839 .late_register = intel_connector_register, 1840 .early_unregister = intel_connector_unregister, 1841 .destroy = intel_connector_destroy, 1842 .fill_modes = drm_helper_probe_single_connector_modes, 1843 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 1844 .atomic_duplicate_state = intel_tv_connector_duplicate_state, 1845 }; 1846 1847 static int intel_tv_atomic_check(struct drm_connector *connector, 1848 struct drm_atomic_state *state) 1849 { 1850 struct drm_connector_state *new_state; 1851 struct drm_crtc_state *new_crtc_state; 1852 struct drm_connector_state *old_state; 1853 1854 new_state = drm_atomic_get_new_connector_state(state, connector); 1855 if (!new_state->crtc) 1856 return 0; 1857 1858 old_state = drm_atomic_get_old_connector_state(state, connector); 1859 new_crtc_state = drm_atomic_get_new_crtc_state(state, new_state->crtc); 1860 1861 if (old_state->tv.mode != new_state->tv.mode || 1862 old_state->tv.margins.left != new_state->tv.margins.left || 1863 old_state->tv.margins.right != new_state->tv.margins.right || 1864 old_state->tv.margins.top != new_state->tv.margins.top || 1865 old_state->tv.margins.bottom != new_state->tv.margins.bottom) { 1866 /* Force a modeset. */ 1867 1868 new_crtc_state->connectors_changed = true; 1869 } 1870 1871 return 0; 1872 } 1873 1874 static const struct drm_connector_helper_funcs intel_tv_connector_helper_funcs = { 1875 .detect_ctx = intel_tv_detect, 1876 .mode_valid = intel_tv_mode_valid, 1877 .get_modes = intel_tv_get_modes, 1878 .atomic_check = intel_tv_atomic_check, 1879 }; 1880 1881 static const struct drm_encoder_funcs intel_tv_enc_funcs = { 1882 .destroy = intel_encoder_destroy, 1883 }; 1884 1885 static void intel_tv_add_properties(struct drm_connector *connector) 1886 { 1887 struct drm_i915_private *i915 = to_i915(connector->dev); 1888 struct drm_connector_state *conn_state = connector->state; 1889 const char *tv_format_names[ARRAY_SIZE(tv_modes)]; 1890 int i; 1891 1892 /* BIOS margin values */ 1893 conn_state->tv.margins.left = 54; 1894 conn_state->tv.margins.top = 36; 1895 conn_state->tv.margins.right = 46; 1896 conn_state->tv.margins.bottom = 37; 1897 1898 conn_state->tv.mode = 0; 1899 1900 /* Create TV properties then attach current values */ 1901 for (i = 0; i < ARRAY_SIZE(tv_modes); i++) { 1902 /* 1080p50/1080p60 not supported on gen3 */ 1903 if (DISPLAY_VER(i915) == 3 && tv_modes[i].oversample == 1) 1904 break; 1905 1906 tv_format_names[i] = tv_modes[i].name; 1907 } 1908 drm_mode_create_tv_properties_legacy(&i915->drm, i, tv_format_names); 1909 1910 drm_object_attach_property(&connector->base, 1911 i915->drm.mode_config.legacy_tv_mode_property, 1912 conn_state->tv.mode); 1913 drm_object_attach_property(&connector->base, 1914 i915->drm.mode_config.tv_left_margin_property, 1915 conn_state->tv.margins.left); 1916 drm_object_attach_property(&connector->base, 1917 i915->drm.mode_config.tv_top_margin_property, 1918 conn_state->tv.margins.top); 1919 drm_object_attach_property(&connector->base, 1920 i915->drm.mode_config.tv_right_margin_property, 1921 conn_state->tv.margins.right); 1922 drm_object_attach_property(&connector->base, 1923 i915->drm.mode_config.tv_bottom_margin_property, 1924 conn_state->tv.margins.bottom); 1925 } 1926 1927 void 1928 intel_tv_init(struct drm_i915_private *dev_priv) 1929 { 1930 struct drm_connector *connector; 1931 struct intel_tv *intel_tv; 1932 struct intel_encoder *intel_encoder; 1933 struct intel_connector *intel_connector; 1934 u32 tv_dac_on, tv_dac_off, save_tv_dac; 1935 1936 if ((intel_de_read(dev_priv, TV_CTL) & TV_FUSE_STATE_MASK) == TV_FUSE_STATE_DISABLED) 1937 return; 1938 1939 if (!intel_bios_is_tv_present(dev_priv)) { 1940 drm_dbg_kms(&dev_priv->drm, "Integrated TV is not present.\n"); 1941 return; 1942 } 1943 1944 /* 1945 * Sanity check the TV output by checking to see if the 1946 * DAC register holds a value 1947 */ 1948 save_tv_dac = intel_de_read(dev_priv, TV_DAC); 1949 1950 intel_de_write(dev_priv, TV_DAC, save_tv_dac | TVDAC_STATE_CHG_EN); 1951 tv_dac_on = intel_de_read(dev_priv, TV_DAC); 1952 1953 intel_de_write(dev_priv, TV_DAC, save_tv_dac & ~TVDAC_STATE_CHG_EN); 1954 tv_dac_off = intel_de_read(dev_priv, TV_DAC); 1955 1956 intel_de_write(dev_priv, TV_DAC, save_tv_dac); 1957 1958 /* 1959 * If the register does not hold the state change enable 1960 * bit, (either as a 0 or a 1), assume it doesn't really 1961 * exist 1962 */ 1963 if ((tv_dac_on & TVDAC_STATE_CHG_EN) == 0 || 1964 (tv_dac_off & TVDAC_STATE_CHG_EN) != 0) 1965 return; 1966 1967 intel_tv = kzalloc(sizeof(*intel_tv), GFP_KERNEL); 1968 if (!intel_tv) { 1969 return; 1970 } 1971 1972 intel_connector = intel_connector_alloc(); 1973 if (!intel_connector) { 1974 kfree(intel_tv); 1975 return; 1976 } 1977 1978 intel_encoder = &intel_tv->base; 1979 connector = &intel_connector->base; 1980 1981 /* 1982 * The documentation, for the older chipsets at least, recommend 1983 * using a polling method rather than hotplug detection for TVs. 1984 * This is because in order to perform the hotplug detection, the PLLs 1985 * for the TV must be kept alive increasing power drain and starving 1986 * bandwidth from other encoders. Notably for instance, it causes 1987 * pipe underruns on Crestline when this encoder is supposedly idle. 1988 * 1989 * More recent chipsets favour HDMI rather than integrated S-Video. 1990 */ 1991 intel_connector->polled = DRM_CONNECTOR_POLL_CONNECT; 1992 1993 drm_connector_init(&dev_priv->drm, connector, &intel_tv_connector_funcs, 1994 DRM_MODE_CONNECTOR_SVIDEO); 1995 1996 drm_encoder_init(&dev_priv->drm, &intel_encoder->base, &intel_tv_enc_funcs, 1997 DRM_MODE_ENCODER_TVDAC, "TV"); 1998 1999 intel_encoder->compute_config = intel_tv_compute_config; 2000 intel_encoder->get_config = intel_tv_get_config; 2001 intel_encoder->pre_enable = intel_tv_pre_enable; 2002 intel_encoder->enable = intel_enable_tv; 2003 intel_encoder->disable = intel_disable_tv; 2004 intel_encoder->get_hw_state = intel_tv_get_hw_state; 2005 intel_connector->get_hw_state = intel_connector_get_hw_state; 2006 2007 intel_connector_attach_encoder(intel_connector, intel_encoder); 2008 2009 intel_encoder->type = INTEL_OUTPUT_TVOUT; 2010 intel_encoder->power_domain = POWER_DOMAIN_PORT_OTHER; 2011 intel_encoder->port = PORT_NONE; 2012 intel_encoder->pipe_mask = ~0; 2013 intel_encoder->cloneable = 0; 2014 intel_tv->type = DRM_MODE_CONNECTOR_Unknown; 2015 2016 drm_connector_helper_add(connector, &intel_tv_connector_helper_funcs); 2017 2018 intel_tv_add_properties(connector); 2019 } 2020