drm_edid.c revision 277487
1/* 2 * Copyright (c) 2006 Luc Verhaegen (quirks list) 3 * Copyright (c) 2007-2008 Intel Corporation 4 * Jesse Barnes <jesse.barnes@intel.com> 5 * Copyright 2010 Red Hat, Inc. 6 * 7 * DDC probing routines (drm_ddc_read & drm_do_probe_ddc_edid) originally from 8 * FB layer. 9 * Copyright (C) 2006 Dennis Munsie <dmunsie@cecropia.com> 10 * 11 * Permission is hereby granted, free of charge, to any person obtaining a 12 * copy of this software and associated documentation files (the "Software"), 13 * to deal in the Software without restriction, including without limitation 14 * the rights to use, copy, modify, merge, publish, distribute, sub license, 15 * and/or sell copies of the Software, and to permit persons to whom the 16 * Software is furnished to do so, subject to the following conditions: 17 * 18 * The above copyright notice and this permission notice (including the 19 * next paragraph) shall be included in all copies or substantial portions 20 * of the Software. 21 * 22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 24 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL 25 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 28 * DEALINGS IN THE SOFTWARE. 29 */ 30 31#include <sys/cdefs.h> 32__FBSDID("$FreeBSD: head/sys/dev/drm2/drm_edid.c 277487 2015-01-21 16:10:37Z kib $"); 33 34#include <dev/drm2/drmP.h> 35#include <dev/drm2/drm_edid.h> 36#include <dev/drm2/drm_edid_modes.h> 37#include <dev/iicbus/iic.h> 38#include <dev/iicbus/iiconf.h> 39#include "iicbus_if.h" 40 41#define version_greater(edid, maj, min) \ 42 (((edid)->version > (maj)) || \ 43 ((edid)->version == (maj) && (edid)->revision > (min))) 44 45#define EDID_EST_TIMINGS 16 46#define EDID_STD_TIMINGS 8 47#define EDID_DETAILED_TIMINGS 4 48 49/* 50 * EDID blocks out in the wild have a variety of bugs, try to collect 51 * them here (note that userspace may work around broken monitors first, 52 * but fixes should make their way here so that the kernel "just works" 53 * on as many displays as possible). 54 */ 55 56/* First detailed mode wrong, use largest 60Hz mode */ 57#define EDID_QUIRK_PREFER_LARGE_60 (1 << 0) 58/* Reported 135MHz pixel clock is too high, needs adjustment */ 59#define EDID_QUIRK_135_CLOCK_TOO_HIGH (1 << 1) 60/* Prefer the largest mode at 75 Hz */ 61#define EDID_QUIRK_PREFER_LARGE_75 (1 << 2) 62/* Detail timing is in cm not mm */ 63#define EDID_QUIRK_DETAILED_IN_CM (1 << 3) 64/* Detailed timing descriptors have bogus size values, so just take the 65 * maximum size and use that. 66 */ 67#define EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE (1 << 4) 68/* Monitor forgot to set the first detailed is preferred bit. */ 69#define EDID_QUIRK_FIRST_DETAILED_PREFERRED (1 << 5) 70/* use +hsync +vsync for detailed mode */ 71#define EDID_QUIRK_DETAILED_SYNC_PP (1 << 6) 72 73struct detailed_mode_closure { 74 struct drm_connector *connector; 75 struct edid *edid; 76 bool preferred; 77 u32 quirks; 78 int modes; 79}; 80 81#define LEVEL_DMT 0 82#define LEVEL_GTF 1 83#define LEVEL_GTF2 2 84#define LEVEL_CVT 3 85 86static struct edid_quirk { 87 char vendor[4]; 88 int product_id; 89 u32 quirks; 90} edid_quirk_list[] = { 91 /* Acer AL1706 */ 92 { "ACR", 44358, EDID_QUIRK_PREFER_LARGE_60 }, 93 /* Acer F51 */ 94 { "API", 0x7602, EDID_QUIRK_PREFER_LARGE_60 }, 95 /* Unknown Acer */ 96 { "ACR", 2423, EDID_QUIRK_FIRST_DETAILED_PREFERRED }, 97 98 /* Belinea 10 15 55 */ 99 { "MAX", 1516, EDID_QUIRK_PREFER_LARGE_60 }, 100 { "MAX", 0x77e, EDID_QUIRK_PREFER_LARGE_60 }, 101 102 /* Envision Peripherals, Inc. EN-7100e */ 103 { "EPI", 59264, EDID_QUIRK_135_CLOCK_TOO_HIGH }, 104 /* Envision EN2028 */ 105 { "EPI", 8232, EDID_QUIRK_PREFER_LARGE_60 }, 106 107 /* Funai Electronics PM36B */ 108 { "FCM", 13600, EDID_QUIRK_PREFER_LARGE_75 | 109 EDID_QUIRK_DETAILED_IN_CM }, 110 111 /* LG Philips LCD LP154W01-A5 */ 112 { "LPL", 0, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE }, 113 { "LPL", 0x2a00, EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE }, 114 115 /* Philips 107p5 CRT */ 116 { "PHL", 57364, EDID_QUIRK_FIRST_DETAILED_PREFERRED }, 117 118 /* Proview AY765C */ 119 { "PTS", 765, EDID_QUIRK_FIRST_DETAILED_PREFERRED }, 120 121 /* Samsung SyncMaster 205BW. Note: irony */ 122 { "SAM", 541, EDID_QUIRK_DETAILED_SYNC_PP }, 123 /* Samsung SyncMaster 22[5-6]BW */ 124 { "SAM", 596, EDID_QUIRK_PREFER_LARGE_60 }, 125 { "SAM", 638, EDID_QUIRK_PREFER_LARGE_60 }, 126}; 127 128/*** DDC fetch and block validation ***/ 129 130static const u8 edid_header[] = { 131 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 132}; 133 134 /* 135 * Sanity check the header of the base EDID block. Return 8 if the header 136 * is perfect, down to 0 if it's totally wrong. 137 */ 138int drm_edid_header_is_valid(const u8 *raw_edid) 139{ 140 int i, score = 0; 141 142 for (i = 0; i < sizeof(edid_header); i++) 143 if (raw_edid[i] == edid_header[i]) 144 score++; 145 146 return score; 147} 148 149/* 150 * Sanity check the EDID block (base or extension). Return 0 if the block 151 * doesn't check out, or 1 if it's valid. 152 */ 153static bool 154drm_edid_block_valid(u8 *raw_edid, int block) 155{ 156 int i; 157 u8 csum = 0; 158 struct edid *edid = (struct edid *)raw_edid; 159 160 if (block == 0) { 161 int score = drm_edid_header_is_valid(raw_edid); 162 if (score == 8) ; 163 else if (score >= 6) { 164 DRM_DEBUG("Fixing EDID header, your hardware may be failing\n"); 165 memcpy(raw_edid, edid_header, sizeof(edid_header)); 166 } else { 167 goto bad; 168 } 169 } 170 171 for (i = 0; i < EDID_LENGTH; i++) 172 csum += raw_edid[i]; 173 if (csum) { 174 DRM_DEBUG_KMS("EDID checksum is invalid, remainder is %d\n", csum); 175 176 /* allow CEA to slide through, switches mangle this */ 177 if (raw_edid[0] != 0x02) 178 goto bad; 179 } 180 181 /* per-block-type checks */ 182 switch (raw_edid[0]) { 183 case 0: /* base */ 184 if (edid->version != 1) { 185 DRM_ERROR("EDID has major version %d, instead of 1\n", edid->version); 186 goto bad; 187 } 188 189 if (edid->revision > 4) 190 DRM_DEBUG("EDID minor > 4, assuming backward compatibility\n"); 191 break; 192 193 default: 194 break; 195 } 196 197 return 1; 198 199bad: 200 if (raw_edid) { 201 DRM_DEBUG_KMS("Raw EDID:\n"); 202 if ((drm_debug_flag & DRM_DEBUGBITS_KMS) != 0) { 203 for (i = 0; i < EDID_LENGTH; ) { 204 printf("%02x", raw_edid[i]); 205 i++; 206 if (i % 16 == 0 || i == EDID_LENGTH) 207 printf("\n"); 208 else if (i % 8 == 0) 209 printf(" "); 210 else 211 printf(" "); 212 } 213 } 214 } 215 return 0; 216} 217 218/** 219 * drm_edid_is_valid - sanity check EDID data 220 * @edid: EDID data 221 * 222 * Sanity-check an entire EDID record (including extensions) 223 */ 224bool drm_edid_is_valid(struct edid *edid) 225{ 226 int i; 227 u8 *raw = (u8 *)edid; 228 229 if (!edid) 230 return false; 231 232 for (i = 0; i <= edid->extensions; i++) 233 if (!drm_edid_block_valid(raw + i * EDID_LENGTH, i)) 234 return false; 235 236 return true; 237} 238 239#define DDC_ADDR 0x50 240#define DDC_SEGMENT_ADDR 0x30 241/** 242 * Get EDID information via I2C. 243 * 244 * \param adapter : i2c device adaptor 245 * \param buf : EDID data buffer to be filled 246 * \param len : EDID data buffer length 247 * \return 0 on success or -1 on failure. 248 * 249 * Try to fetch EDID information by calling i2c driver function. 250 */ 251static int 252drm_do_probe_ddc_edid(device_t adapter, unsigned char *buf, 253 int block, int len) 254{ 255 unsigned char start = block * EDID_LENGTH; 256 unsigned char segment = block >> 1; 257 unsigned char xfers = segment ? 3 : 2; 258 int ret, retries = 5; 259 260 /* The core i2c driver will automatically retry the transfer if the 261 * adapter reports EAGAIN. However, we find that bit-banging transfers 262 * are susceptible to errors under a heavily loaded machine and 263 * generate spurious NAKs and timeouts. Retrying the transfer 264 * of the individual block a few times seems to overcome this. 265 */ 266 do { 267 struct iic_msg msgs[] = { 268 { 269 .slave = DDC_SEGMENT_ADDR << 1, 270 .flags = 0, 271 .len = 1, 272 .buf = &segment, 273 }, { 274 .slave = DDC_ADDR << 1, 275 .flags = IIC_M_WR, 276 .len = 1, 277 .buf = &start, 278 }, { 279 .slave = DDC_ADDR << 1, 280 .flags = IIC_M_RD, 281 .len = len, 282 .buf = buf, 283 } 284 }; 285 286 /* 287 * Avoid sending the segment addr to not upset non-compliant ddc 288 * monitors. 289 */ 290 ret = iicbus_transfer(adapter, &msgs[3 - xfers], xfers); 291 292 if (ret != 0) 293 DRM_DEBUG_KMS("iicbus_transfer countdown %d error %d\n", 294 retries, ret); 295 } while (ret != 0 && --retries); 296 297 return (ret == 0 ? 0 : -1); 298} 299 300static bool drm_edid_is_zero(u8 *in_edid, int length) 301{ 302 int i; 303 u32 *raw_edid = (u32 *)in_edid; 304 305 for (i = 0; i < length / 4; i++) 306 if (*(raw_edid + i) != 0) 307 return false; 308 return true; 309} 310 311static u8 * 312drm_do_get_edid(struct drm_connector *connector, device_t adapter) 313{ 314 int i, j = 0, valid_extensions = 0; 315 u8 *block, *new; 316 317 block = malloc(EDID_LENGTH, DRM_MEM_KMS, M_WAITOK | M_ZERO); 318 319 /* base block fetch */ 320 for (i = 0; i < 4; i++) { 321 if (drm_do_probe_ddc_edid(adapter, block, 0, EDID_LENGTH)) 322 goto out; 323 if (drm_edid_block_valid(block, 0)) 324 break; 325 if (i == 0 && drm_edid_is_zero(block, EDID_LENGTH)) { 326 connector->null_edid_counter++; 327 goto carp; 328 } 329 } 330 if (i == 4) 331 goto carp; 332 333 /* if there's no extensions, we're done */ 334 if (block[0x7e] == 0) 335 return block; 336 337 new = reallocf(block, (block[0x7e] + 1) * EDID_LENGTH, DRM_MEM_KMS, 338 M_WAITOK); 339 block = new; 340 341 for (j = 1; j <= block[0x7e]; j++) { 342 for (i = 0; i < 4; i++) { 343 if (drm_do_probe_ddc_edid(adapter, 344 block + (valid_extensions + 1) * EDID_LENGTH, 345 j, EDID_LENGTH)) 346 goto out; 347 if (drm_edid_block_valid(block + (valid_extensions + 1) * EDID_LENGTH, j)) { 348 valid_extensions++; 349 break; 350 } 351 } 352 if (i == 4) 353 DRM_DEBUG_KMS("%s: Ignoring invalid EDID block %d.\n", 354 drm_get_connector_name(connector), j); 355 } 356 357 if (valid_extensions != block[0x7e]) { 358 block[EDID_LENGTH-1] += block[0x7e] - valid_extensions; 359 block[0x7e] = valid_extensions; 360 new = reallocf(block, (valid_extensions + 1) * EDID_LENGTH, 361 DRM_MEM_KMS, M_WAITOK); 362 block = new; 363 } 364 365 DRM_DEBUG_KMS("got EDID from %s\n", drm_get_connector_name(connector)); 366 return block; 367 368carp: 369 DRM_DEBUG_KMS("%s: EDID block %d invalid.\n", 370 drm_get_connector_name(connector), j); 371 372out: 373 free(block, DRM_MEM_KMS); 374 return NULL; 375} 376 377/** 378 * Probe DDC presence. 379 * 380 * \param adapter : i2c device adaptor 381 * \return 1 on success 382 */ 383static bool 384drm_probe_ddc(device_t adapter) 385{ 386 unsigned char out; 387 388 return (drm_do_probe_ddc_edid(adapter, &out, 0, 1) == 0); 389} 390 391/** 392 * drm_get_edid - get EDID data, if available 393 * @connector: connector we're probing 394 * @adapter: i2c adapter to use for DDC 395 * 396 * Poke the given i2c channel to grab EDID data if possible. If found, 397 * attach it to the connector. 398 * 399 * Return edid data or NULL if we couldn't find any. 400 */ 401struct edid *drm_get_edid(struct drm_connector *connector, 402 device_t adapter) 403{ 404 struct edid *edid = NULL; 405 406 if (drm_probe_ddc(adapter)) 407 edid = (struct edid *)drm_do_get_edid(connector, adapter); 408 409 connector->display_info.raw_edid = (char *)edid; 410 411 return edid; 412 413} 414 415/*** EDID parsing ***/ 416 417/** 418 * edid_vendor - match a string against EDID's obfuscated vendor field 419 * @edid: EDID to match 420 * @vendor: vendor string 421 * 422 * Returns true if @vendor is in @edid, false otherwise 423 */ 424static bool edid_vendor(struct edid *edid, char *vendor) 425{ 426 char edid_vendor[3]; 427 428 edid_vendor[0] = ((edid->mfg_id[0] & 0x7c) >> 2) + '@'; 429 edid_vendor[1] = (((edid->mfg_id[0] & 0x3) << 3) | 430 ((edid->mfg_id[1] & 0xe0) >> 5)) + '@'; 431 edid_vendor[2] = (edid->mfg_id[1] & 0x1f) + '@'; 432 433 return !strncmp(edid_vendor, vendor, 3); 434} 435 436/** 437 * edid_get_quirks - return quirk flags for a given EDID 438 * @edid: EDID to process 439 * 440 * This tells subsequent routines what fixes they need to apply. 441 */ 442static u32 edid_get_quirks(struct edid *edid) 443{ 444 struct edid_quirk *quirk; 445 int i; 446 447 for (i = 0; i < DRM_ARRAY_SIZE(edid_quirk_list); i++) { 448 quirk = &edid_quirk_list[i]; 449 450 if (edid_vendor(edid, quirk->vendor) && 451 (EDID_PRODUCT_ID(edid) == quirk->product_id)) 452 return quirk->quirks; 453 } 454 455 return 0; 456} 457 458#define MODE_SIZE(m) ((m)->hdisplay * (m)->vdisplay) 459#define MODE_REFRESH_DIFF(m,r) (abs((m)->vrefresh - target_refresh)) 460 461/** 462 * edid_fixup_preferred - set preferred modes based on quirk list 463 * @connector: has mode list to fix up 464 * @quirks: quirks list 465 * 466 * Walk the mode list for @connector, clearing the preferred status 467 * on existing modes and setting it anew for the right mode ala @quirks. 468 */ 469static void edid_fixup_preferred(struct drm_connector *connector, 470 u32 quirks) 471{ 472 struct drm_display_mode *t, *cur_mode, *preferred_mode; 473 int target_refresh = 0; 474 475 if (list_empty(&connector->probed_modes)) 476 return; 477 478 if (quirks & EDID_QUIRK_PREFER_LARGE_60) 479 target_refresh = 60; 480 if (quirks & EDID_QUIRK_PREFER_LARGE_75) 481 target_refresh = 75; 482 483 preferred_mode = list_first_entry(&connector->probed_modes, 484 struct drm_display_mode, head); 485 486 list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) { 487 cur_mode->type &= ~DRM_MODE_TYPE_PREFERRED; 488 489 if (cur_mode == preferred_mode) 490 continue; 491 492 /* Largest mode is preferred */ 493 if (MODE_SIZE(cur_mode) > MODE_SIZE(preferred_mode)) 494 preferred_mode = cur_mode; 495 496 /* At a given size, try to get closest to target refresh */ 497 if ((MODE_SIZE(cur_mode) == MODE_SIZE(preferred_mode)) && 498 MODE_REFRESH_DIFF(cur_mode, target_refresh) < 499 MODE_REFRESH_DIFF(preferred_mode, target_refresh)) { 500 preferred_mode = cur_mode; 501 } 502 } 503 504 preferred_mode->type |= DRM_MODE_TYPE_PREFERRED; 505} 506 507static bool 508mode_is_rb(const struct drm_display_mode *mode) 509{ 510 return (mode->htotal - mode->hdisplay == 160) && 511 (mode->hsync_end - mode->hdisplay == 80) && 512 (mode->hsync_end - mode->hsync_start == 32) && 513 (mode->vsync_start - mode->vdisplay == 3); 514} 515 516/* 517 * drm_mode_find_dmt - Create a copy of a mode if present in DMT 518 * @dev: Device to duplicate against 519 * @hsize: Mode width 520 * @vsize: Mode height 521 * @fresh: Mode refresh rate 522 * @rb: Mode reduced-blanking-ness 523 * 524 * Walk the DMT mode list looking for a match for the given parameters. 525 * Return a newly allocated copy of the mode, or NULL if not found. 526 */ 527struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev, 528 int hsize, int vsize, int fresh, 529 bool rb) 530{ 531 int i; 532 533 for (i = 0; i < drm_num_dmt_modes; i++) { 534 struct drm_display_mode *ptr = &drm_dmt_modes[i]; 535 if (hsize != ptr->hdisplay) 536 continue; 537 if (vsize != ptr->vdisplay) 538 continue; 539 if (fresh != drm_mode_vrefresh(ptr)) 540 continue; 541 if (rb != mode_is_rb(ptr)) 542 continue; 543 544 return drm_mode_duplicate(dev, ptr); 545 } 546 547 return NULL; 548} 549 550typedef void detailed_cb(struct detailed_timing *timing, void *closure); 551 552static void 553cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure) 554{ 555 int i, n = 0; 556 u8 rev = ext[0x01], d = ext[0x02]; 557 u8 *det_base = ext + d; 558 559 switch (rev) { 560 case 0: 561 /* can't happen */ 562 return; 563 case 1: 564 /* have to infer how many blocks we have, check pixel clock */ 565 for (i = 0; i < 6; i++) 566 if (det_base[18*i] || det_base[18*i+1]) 567 n++; 568 break; 569 default: 570 /* explicit count */ 571 n = min(ext[0x03] & 0x0f, 6); 572 break; 573 } 574 575 for (i = 0; i < n; i++) 576 cb((struct detailed_timing *)(det_base + 18 * i), closure); 577} 578 579static void 580vtb_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure) 581{ 582 unsigned int i, n = min((int)ext[0x02], 6); 583 u8 *det_base = ext + 5; 584 585 if (ext[0x01] != 1) 586 return; /* unknown version */ 587 588 for (i = 0; i < n; i++) 589 cb((struct detailed_timing *)(det_base + 18 * i), closure); 590} 591 592static void 593drm_for_each_detailed_block(u8 *raw_edid, detailed_cb *cb, void *closure) 594{ 595 int i; 596 struct edid *edid = (struct edid *)raw_edid; 597 598 if (edid == NULL) 599 return; 600 601 for (i = 0; i < EDID_DETAILED_TIMINGS; i++) 602 cb(&(edid->detailed_timings[i]), closure); 603 604 for (i = 1; i <= raw_edid[0x7e]; i++) { 605 u8 *ext = raw_edid + (i * EDID_LENGTH); 606 switch (*ext) { 607 case CEA_EXT: 608 cea_for_each_detailed_block(ext, cb, closure); 609 break; 610 case VTB_EXT: 611 vtb_for_each_detailed_block(ext, cb, closure); 612 break; 613 default: 614 break; 615 } 616 } 617} 618 619static void 620is_rb(struct detailed_timing *t, void *data) 621{ 622 u8 *r = (u8 *)t; 623 if (r[3] == EDID_DETAIL_MONITOR_RANGE) 624 if (r[15] & 0x10) 625 *(bool *)data = true; 626} 627 628/* EDID 1.4 defines this explicitly. For EDID 1.3, we guess, badly. */ 629static bool 630drm_monitor_supports_rb(struct edid *edid) 631{ 632 if (edid->revision >= 4) { 633 bool ret; 634 drm_for_each_detailed_block((u8 *)edid, is_rb, &ret); 635 return ret; 636 } 637 638 return ((edid->input & DRM_EDID_INPUT_DIGITAL) != 0); 639} 640 641static void 642find_gtf2(struct detailed_timing *t, void *data) 643{ 644 u8 *r = (u8 *)t; 645 if (r[3] == EDID_DETAIL_MONITOR_RANGE && r[10] == 0x02) 646 *(u8 **)data = r; 647} 648 649/* Secondary GTF curve kicks in above some break frequency */ 650static int 651drm_gtf2_hbreak(struct edid *edid) 652{ 653 u8 *r = NULL; 654 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r); 655 return r ? (r[12] * 2) : 0; 656} 657 658static int 659drm_gtf2_2c(struct edid *edid) 660{ 661 u8 *r = NULL; 662 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r); 663 return r ? r[13] : 0; 664} 665 666static int 667drm_gtf2_m(struct edid *edid) 668{ 669 u8 *r = NULL; 670 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r); 671 return r ? (r[15] << 8) + r[14] : 0; 672} 673 674static int 675drm_gtf2_k(struct edid *edid) 676{ 677 u8 *r = NULL; 678 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r); 679 return r ? r[16] : 0; 680} 681 682static int 683drm_gtf2_2j(struct edid *edid) 684{ 685 u8 *r = NULL; 686 drm_for_each_detailed_block((u8 *)edid, find_gtf2, &r); 687 return r ? r[17] : 0; 688} 689 690/** 691 * standard_timing_level - get std. timing level(CVT/GTF/DMT) 692 * @edid: EDID block to scan 693 */ 694static int standard_timing_level(struct edid *edid) 695{ 696 if (edid->revision >= 2) { 697 if (edid->revision >= 4 && (edid->features & DRM_EDID_FEATURE_DEFAULT_GTF)) 698 return LEVEL_CVT; 699 if (drm_gtf2_hbreak(edid)) 700 return LEVEL_GTF2; 701 return LEVEL_GTF; 702 } 703 return LEVEL_DMT; 704} 705 706/* 707 * 0 is reserved. The spec says 0x01 fill for unused timings. Some old 708 * monitors fill with ascii space (0x20) instead. 709 */ 710static int 711bad_std_timing(u8 a, u8 b) 712{ 713 return (a == 0x00 && b == 0x00) || 714 (a == 0x01 && b == 0x01) || 715 (a == 0x20 && b == 0x20); 716} 717 718/** 719 * drm_mode_std - convert standard mode info (width, height, refresh) into mode 720 * @t: standard timing params 721 * @timing_level: standard timing level 722 * 723 * Take the standard timing params (in this case width, aspect, and refresh) 724 * and convert them into a real mode using CVT/GTF/DMT. 725 */ 726static struct drm_display_mode * 727drm_mode_std(struct drm_connector *connector, struct edid *edid, 728 struct std_timing *t, int revision) 729{ 730 struct drm_device *dev = connector->dev; 731 struct drm_display_mode *m, *mode = NULL; 732 int hsize, vsize; 733 int vrefresh_rate; 734 unsigned aspect_ratio = (t->vfreq_aspect & EDID_TIMING_ASPECT_MASK) 735 >> EDID_TIMING_ASPECT_SHIFT; 736 unsigned vfreq = (t->vfreq_aspect & EDID_TIMING_VFREQ_MASK) 737 >> EDID_TIMING_VFREQ_SHIFT; 738 int timing_level = standard_timing_level(edid); 739 740 if (bad_std_timing(t->hsize, t->vfreq_aspect)) 741 return NULL; 742 743 /* According to the EDID spec, the hdisplay = hsize * 8 + 248 */ 744 hsize = t->hsize * 8 + 248; 745 /* vrefresh_rate = vfreq + 60 */ 746 vrefresh_rate = vfreq + 60; 747 /* the vdisplay is calculated based on the aspect ratio */ 748 if (aspect_ratio == 0) { 749 if (revision < 3) 750 vsize = hsize; 751 else 752 vsize = (hsize * 10) / 16; 753 } else if (aspect_ratio == 1) 754 vsize = (hsize * 3) / 4; 755 else if (aspect_ratio == 2) 756 vsize = (hsize * 4) / 5; 757 else 758 vsize = (hsize * 9) / 16; 759 760 /* HDTV hack, part 1 */ 761 if (vrefresh_rate == 60 && 762 ((hsize == 1360 && vsize == 765) || 763 (hsize == 1368 && vsize == 769))) { 764 hsize = 1366; 765 vsize = 768; 766 } 767 768 /* 769 * If this connector already has a mode for this size and refresh 770 * rate (because it came from detailed or CVT info), use that 771 * instead. This way we don't have to guess at interlace or 772 * reduced blanking. 773 */ 774 list_for_each_entry(m, &connector->probed_modes, head) 775 if (m->hdisplay == hsize && m->vdisplay == vsize && 776 drm_mode_vrefresh(m) == vrefresh_rate) 777 return NULL; 778 779 /* HDTV hack, part 2 */ 780 if (hsize == 1366 && vsize == 768 && vrefresh_rate == 60) { 781 mode = drm_cvt_mode(dev, 1366, 768, vrefresh_rate, 0, 0, 782 false); 783 mode->hdisplay = 1366; 784 mode->hsync_start = mode->hsync_start - 1; 785 mode->hsync_end = mode->hsync_end - 1; 786 return mode; 787 } 788 789 /* check whether it can be found in default mode table */ 790 if (drm_monitor_supports_rb(edid)) { 791 mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate, 792 true); 793 if (mode) 794 return mode; 795 } 796 mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate, false); 797 if (mode) 798 return mode; 799 800 /* okay, generate it */ 801 switch (timing_level) { 802 case LEVEL_DMT: 803 break; 804 case LEVEL_GTF: 805 mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0); 806 break; 807 case LEVEL_GTF2: 808 /* 809 * This is potentially wrong if there's ever a monitor with 810 * more than one ranges section, each claiming a different 811 * secondary GTF curve. Please don't do that. 812 */ 813 mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0); 814 if (!mode) 815 return NULL; 816 if (drm_mode_hsync(mode) > drm_gtf2_hbreak(edid)) { 817 free(mode, DRM_MEM_KMS); 818 mode = drm_gtf_mode_complex(dev, hsize, vsize, 819 vrefresh_rate, 0, 0, 820 drm_gtf2_m(edid), 821 drm_gtf2_2c(edid), 822 drm_gtf2_k(edid), 823 drm_gtf2_2j(edid)); 824 } 825 break; 826 case LEVEL_CVT: 827 mode = drm_cvt_mode(dev, hsize, vsize, vrefresh_rate, 0, 0, 828 false); 829 break; 830 } 831 return mode; 832} 833 834/* 835 * EDID is delightfully ambiguous about how interlaced modes are to be 836 * encoded. Our internal representation is of frame height, but some 837 * HDTV detailed timings are encoded as field height. 838 * 839 * The format list here is from CEA, in frame size. Technically we 840 * should be checking refresh rate too. Whatever. 841 */ 842static void 843drm_mode_do_interlace_quirk(struct drm_display_mode *mode, 844 struct detailed_pixel_timing *pt) 845{ 846 int i; 847 static const struct { 848 int w, h; 849 } cea_interlaced[] = { 850 { 1920, 1080 }, 851 { 720, 480 }, 852 { 1440, 480 }, 853 { 2880, 480 }, 854 { 720, 576 }, 855 { 1440, 576 }, 856 { 2880, 576 }, 857 }; 858 859 if (!(pt->misc & DRM_EDID_PT_INTERLACED)) 860 return; 861 862 for (i = 0; i < DRM_ARRAY_SIZE(cea_interlaced); i++) { 863 if ((mode->hdisplay == cea_interlaced[i].w) && 864 (mode->vdisplay == cea_interlaced[i].h / 2)) { 865 mode->vdisplay *= 2; 866 mode->vsync_start *= 2; 867 mode->vsync_end *= 2; 868 mode->vtotal *= 2; 869 mode->vtotal |= 1; 870 } 871 } 872 873 mode->flags |= DRM_MODE_FLAG_INTERLACE; 874} 875 876/** 877 * drm_mode_detailed - create a new mode from an EDID detailed timing section 878 * @dev: DRM device (needed to create new mode) 879 * @edid: EDID block 880 * @timing: EDID detailed timing info 881 * @quirks: quirks to apply 882 * 883 * An EDID detailed timing block contains enough info for us to create and 884 * return a new struct drm_display_mode. 885 */ 886static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev, 887 struct edid *edid, 888 struct detailed_timing *timing, 889 u32 quirks) 890{ 891 struct drm_display_mode *mode; 892 struct detailed_pixel_timing *pt = &timing->data.pixel_data; 893 unsigned hactive = (pt->hactive_hblank_hi & 0xf0) << 4 | pt->hactive_lo; 894 unsigned vactive = (pt->vactive_vblank_hi & 0xf0) << 4 | pt->vactive_lo; 895 unsigned hblank = (pt->hactive_hblank_hi & 0xf) << 8 | pt->hblank_lo; 896 unsigned vblank = (pt->vactive_vblank_hi & 0xf) << 8 | pt->vblank_lo; 897 unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) << 2 | pt->hsync_offset_lo; 898 unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) << 4 | pt->hsync_pulse_width_lo; 899 unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) >> 2 | pt->vsync_offset_pulse_width_lo >> 4; 900 unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 4 | (pt->vsync_offset_pulse_width_lo & 0xf); 901 902 /* ignore tiny modes */ 903 if (hactive < 64 || vactive < 64) 904 return NULL; 905 906 if (pt->misc & DRM_EDID_PT_STEREO) { 907 printf("stereo mode not supported\n"); 908 return NULL; 909 } 910 if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) { 911 printf("composite sync not supported\n"); 912 } 913 914 /* it is incorrect if hsync/vsync width is zero */ 915 if (!hsync_pulse_width || !vsync_pulse_width) { 916 DRM_DEBUG_KMS("Incorrect Detailed timing. " 917 "Wrong Hsync/Vsync pulse width\n"); 918 return NULL; 919 } 920 mode = drm_mode_create(dev); 921 if (!mode) 922 return NULL; 923 924 mode->type = DRM_MODE_TYPE_DRIVER; 925 926 if (quirks & EDID_QUIRK_135_CLOCK_TOO_HIGH) 927 timing->pixel_clock = htole16(1088); 928 929 mode->clock = le16toh(timing->pixel_clock) * 10; 930 931 mode->hdisplay = hactive; 932 mode->hsync_start = mode->hdisplay + hsync_offset; 933 mode->hsync_end = mode->hsync_start + hsync_pulse_width; 934 mode->htotal = mode->hdisplay + hblank; 935 936 mode->vdisplay = vactive; 937 mode->vsync_start = mode->vdisplay + vsync_offset; 938 mode->vsync_end = mode->vsync_start + vsync_pulse_width; 939 mode->vtotal = mode->vdisplay + vblank; 940 941 /* Some EDIDs have bogus h/vtotal values */ 942 if (mode->hsync_end > mode->htotal) 943 mode->htotal = mode->hsync_end + 1; 944 if (mode->vsync_end > mode->vtotal) 945 mode->vtotal = mode->vsync_end + 1; 946 947 drm_mode_do_interlace_quirk(mode, pt); 948 949 drm_mode_set_name(mode); 950 951 if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) { 952 pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE; 953 } 954 955 mode->flags |= (pt->misc & DRM_EDID_PT_HSYNC_POSITIVE) ? 956 DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC; 957 mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ? 958 DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC; 959 960 mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4; 961 mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8; 962 963 if (quirks & EDID_QUIRK_DETAILED_IN_CM) { 964 mode->width_mm *= 10; 965 mode->height_mm *= 10; 966 } 967 968 if (quirks & EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE) { 969 mode->width_mm = edid->width_cm * 10; 970 mode->height_mm = edid->height_cm * 10; 971 } 972 973 return mode; 974} 975 976static bool 977mode_in_hsync_range(struct drm_display_mode *mode, 978 struct edid *edid, u8 *t) 979{ 980 int hsync, hmin, hmax; 981 982 hmin = t[7]; 983 if (edid->revision >= 4) 984 hmin += ((t[4] & 0x04) ? 255 : 0); 985 hmax = t[8]; 986 if (edid->revision >= 4) 987 hmax += ((t[4] & 0x08) ? 255 : 0); 988 hsync = drm_mode_hsync(mode); 989 990 return (hsync <= hmax && hsync >= hmin); 991} 992 993static bool 994mode_in_vsync_range(struct drm_display_mode *mode, 995 struct edid *edid, u8 *t) 996{ 997 int vsync, vmin, vmax; 998 999 vmin = t[5]; 1000 if (edid->revision >= 4) 1001 vmin += ((t[4] & 0x01) ? 255 : 0); 1002 vmax = t[6]; 1003 if (edid->revision >= 4) 1004 vmax += ((t[4] & 0x02) ? 255 : 0); 1005 vsync = drm_mode_vrefresh(mode); 1006 1007 return (vsync <= vmax && vsync >= vmin); 1008} 1009 1010static u32 1011range_pixel_clock(struct edid *edid, u8 *t) 1012{ 1013 /* unspecified */ 1014 if (t[9] == 0 || t[9] == 255) 1015 return 0; 1016 1017 /* 1.4 with CVT support gives us real precision, yay */ 1018 if (edid->revision >= 4 && t[10] == 0x04) 1019 return (t[9] * 10000) - ((t[12] >> 2) * 250); 1020 1021 /* 1.3 is pathetic, so fuzz up a bit */ 1022 return t[9] * 10000 + 5001; 1023} 1024 1025static bool 1026mode_in_range(struct drm_display_mode *mode, struct edid *edid, 1027 struct detailed_timing *timing) 1028{ 1029 u32 max_clock; 1030 u8 *t = (u8 *)timing; 1031 1032 if (!mode_in_hsync_range(mode, edid, t)) 1033 return false; 1034 1035 if (!mode_in_vsync_range(mode, edid, t)) 1036 return false; 1037 1038 if ((max_clock = range_pixel_clock(edid, t))) 1039 if (mode->clock > max_clock) 1040 return false; 1041 1042 /* 1.4 max horizontal check */ 1043 if (edid->revision >= 4 && t[10] == 0x04) 1044 if (t[13] && mode->hdisplay > 8 * (t[13] + (256 * (t[12]&0x3)))) 1045 return false; 1046 1047 if (mode_is_rb(mode) && !drm_monitor_supports_rb(edid)) 1048 return false; 1049 1050 return true; 1051} 1052 1053static int 1054drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid, 1055 struct detailed_timing *timing) 1056{ 1057 int i, modes = 0; 1058 struct drm_display_mode *newmode; 1059 struct drm_device *dev = connector->dev; 1060 1061 for (i = 0; i < drm_num_dmt_modes; i++) { 1062 if (mode_in_range(drm_dmt_modes + i, edid, timing)) { 1063 newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]); 1064 if (newmode) { 1065 drm_mode_probed_add(connector, newmode); 1066 modes++; 1067 } 1068 } 1069 } 1070 1071 return modes; 1072} 1073 1074/* fix up 1366x768 mode from 1368x768; 1075 * GFT/CVT can't express 1366 width which isn't dividable by 8 1076 */ 1077static void fixup_mode_1366x768(struct drm_display_mode *mode) 1078{ 1079 if (mode->hdisplay == 1368 && mode->vdisplay == 768) { 1080 mode->hdisplay = 1366; 1081 mode->hsync_start--; 1082 mode->hsync_end--; 1083 drm_mode_set_name(mode); 1084 } 1085} 1086 1087static int 1088drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid, 1089 struct detailed_timing *timing) 1090{ 1091 int i, modes = 0; 1092 struct drm_display_mode *newmode; 1093 struct drm_device *dev = connector->dev; 1094 1095 for (i = 0; i < num_extra_modes; i++) { 1096 const struct minimode *m = &extra_modes[i]; 1097 newmode = drm_gtf_mode(dev, m->w, m->h, m->r, 0, 0); 1098 if (!newmode) 1099 return modes; 1100 1101 fixup_mode_1366x768(newmode); 1102 if (!mode_in_range(newmode, edid, timing)) { 1103 drm_mode_destroy(dev, newmode); 1104 continue; 1105 } 1106 1107 drm_mode_probed_add(connector, newmode); 1108 modes++; 1109 } 1110 1111 return modes; 1112} 1113 1114static int 1115drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid, 1116 struct detailed_timing *timing) 1117{ 1118 int i, modes = 0; 1119 struct drm_display_mode *newmode; 1120 struct drm_device *dev = connector->dev; 1121 bool rb = drm_monitor_supports_rb(edid); 1122 1123 for (i = 0; i < num_extra_modes; i++) { 1124 const struct minimode *m = &extra_modes[i]; 1125 newmode = drm_cvt_mode(dev, m->w, m->h, m->r, rb, 0, 0); 1126 if (!newmode) 1127 return modes; 1128 1129 fixup_mode_1366x768(newmode); 1130 if (!mode_in_range(newmode, edid, timing)) { 1131 drm_mode_destroy(dev, newmode); 1132 continue; 1133 } 1134 1135 drm_mode_probed_add(connector, newmode); 1136 modes++; 1137 } 1138 1139 return modes; 1140} 1141 1142static void 1143do_inferred_modes(struct detailed_timing *timing, void *c) 1144{ 1145 struct detailed_mode_closure *closure = c; 1146 struct detailed_non_pixel *data = &timing->data.other_data; 1147 struct detailed_data_monitor_range *range = &data->data.range; 1148 1149 if (data->type != EDID_DETAIL_MONITOR_RANGE) 1150 return; 1151 1152 closure->modes += drm_dmt_modes_for_range(closure->connector, 1153 closure->edid, 1154 timing); 1155 1156 if (!version_greater(closure->edid, 1, 1)) 1157 return; /* GTF not defined yet */ 1158 1159 switch (range->flags) { 1160 case 0x02: /* secondary gtf, XXX could do more */ 1161 case 0x00: /* default gtf */ 1162 closure->modes += drm_gtf_modes_for_range(closure->connector, 1163 closure->edid, 1164 timing); 1165 break; 1166 case 0x04: /* cvt, only in 1.4+ */ 1167 if (!version_greater(closure->edid, 1, 3)) 1168 break; 1169 1170 closure->modes += drm_cvt_modes_for_range(closure->connector, 1171 closure->edid, 1172 timing); 1173 break; 1174 case 0x01: /* just the ranges, no formula */ 1175 default: 1176 break; 1177 } 1178} 1179 1180static int 1181add_inferred_modes(struct drm_connector *connector, struct edid *edid) 1182{ 1183 struct detailed_mode_closure closure = { 1184 connector, edid, 0, 0, 0 1185 }; 1186 1187 if (version_greater(edid, 1, 0)) 1188 drm_for_each_detailed_block((u8 *)edid, do_inferred_modes, 1189 &closure); 1190 1191 return closure.modes; 1192} 1193 1194static int 1195drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing) 1196{ 1197 int i, j, m, modes = 0; 1198 struct drm_display_mode *mode; 1199 u8 *est = ((u8 *)timing) + 5; 1200 1201 for (i = 0; i < 6; i++) { 1202 for (j = 7; j > 0; j--) { 1203 m = (i * 8) + (7 - j); 1204 if (m >= DRM_ARRAY_SIZE(est3_modes)) 1205 break; 1206 if (est[i] & (1 << j)) { 1207 mode = drm_mode_find_dmt(connector->dev, 1208 est3_modes[m].w, 1209 est3_modes[m].h, 1210 est3_modes[m].r, 1211 est3_modes[m].rb); 1212 if (mode) { 1213 drm_mode_probed_add(connector, mode); 1214 modes++; 1215 } 1216 } 1217 } 1218 } 1219 1220 return modes; 1221} 1222 1223static void 1224do_established_modes(struct detailed_timing *timing, void *c) 1225{ 1226 struct detailed_mode_closure *closure = c; 1227 struct detailed_non_pixel *data = &timing->data.other_data; 1228 1229 if (data->type == EDID_DETAIL_EST_TIMINGS) 1230 closure->modes += drm_est3_modes(closure->connector, timing); 1231} 1232 1233/** 1234 * add_established_modes - get est. modes from EDID and add them 1235 * @edid: EDID block to scan 1236 * 1237 * Each EDID block contains a bitmap of the supported "established modes" list 1238 * (defined above). Tease them out and add them to the global modes list. 1239 */ 1240static int 1241add_established_modes(struct drm_connector *connector, struct edid *edid) 1242{ 1243 struct drm_device *dev = connector->dev; 1244 unsigned long est_bits = edid->established_timings.t1 | 1245 (edid->established_timings.t2 << 8) | 1246 ((edid->established_timings.mfg_rsvd & 0x80) << 9); 1247 int i, modes = 0; 1248 struct detailed_mode_closure closure = { 1249 connector, edid, 0, 0, 0 1250 }; 1251 1252 for (i = 0; i <= EDID_EST_TIMINGS; i++) { 1253 if (est_bits & (1<<i)) { 1254 struct drm_display_mode *newmode; 1255 newmode = drm_mode_duplicate(dev, &edid_est_modes[i]); 1256 if (newmode) { 1257 drm_mode_probed_add(connector, newmode); 1258 modes++; 1259 } 1260 } 1261 } 1262 1263 if (version_greater(edid, 1, 0)) 1264 drm_for_each_detailed_block((u8 *)edid, 1265 do_established_modes, &closure); 1266 1267 return modes + closure.modes; 1268} 1269 1270static void 1271do_standard_modes(struct detailed_timing *timing, void *c) 1272{ 1273 struct detailed_mode_closure *closure = c; 1274 struct detailed_non_pixel *data = &timing->data.other_data; 1275 struct drm_connector *connector = closure->connector; 1276 struct edid *edid = closure->edid; 1277 1278 if (data->type == EDID_DETAIL_STD_MODES) { 1279 int i; 1280 for (i = 0; i < 6; i++) { 1281 struct std_timing *std; 1282 struct drm_display_mode *newmode; 1283 1284 std = &data->data.timings[i]; 1285 newmode = drm_mode_std(connector, edid, std, 1286 edid->revision); 1287 if (newmode) { 1288 drm_mode_probed_add(connector, newmode); 1289 closure->modes++; 1290 } 1291 } 1292 } 1293} 1294 1295/** 1296 * add_standard_modes - get std. modes from EDID and add them 1297 * @edid: EDID block to scan 1298 * 1299 * Standard modes can be calculated using the appropriate standard (DMT, 1300 * GTF or CVT. Grab them from @edid and add them to the list. 1301 */ 1302static int 1303add_standard_modes(struct drm_connector *connector, struct edid *edid) 1304{ 1305 int i, modes = 0; 1306 struct detailed_mode_closure closure = { 1307 connector, edid, 0, 0, 0 1308 }; 1309 1310 for (i = 0; i < EDID_STD_TIMINGS; i++) { 1311 struct drm_display_mode *newmode; 1312 1313 newmode = drm_mode_std(connector, edid, 1314 &edid->standard_timings[i], 1315 edid->revision); 1316 if (newmode) { 1317 drm_mode_probed_add(connector, newmode); 1318 modes++; 1319 } 1320 } 1321 1322 if (version_greater(edid, 1, 0)) 1323 drm_for_each_detailed_block((u8 *)edid, do_standard_modes, 1324 &closure); 1325 1326 /* XXX should also look for standard codes in VTB blocks */ 1327 1328 return modes + closure.modes; 1329} 1330 1331static int drm_cvt_modes(struct drm_connector *connector, 1332 struct detailed_timing *timing) 1333{ 1334 int i, j, modes = 0; 1335 struct drm_display_mode *newmode; 1336 struct drm_device *dev = connector->dev; 1337 struct cvt_timing *cvt; 1338 const int rates[] = { 60, 85, 75, 60, 50 }; 1339 const u8 empty[3] = { 0, 0, 0 }; 1340 1341 for (i = 0; i < 4; i++) { 1342 int width = 0, height; 1343 cvt = &(timing->data.other_data.data.cvt[i]); 1344 1345 if (!memcmp(cvt->code, empty, 3)) 1346 continue; 1347 1348 height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 4) + 1) * 2; 1349 switch (cvt->code[1] & 0x0c) { 1350 case 0x00: 1351 width = height * 4 / 3; 1352 break; 1353 case 0x04: 1354 width = height * 16 / 9; 1355 break; 1356 case 0x08: 1357 width = height * 16 / 10; 1358 break; 1359 case 0x0c: 1360 width = height * 15 / 9; 1361 break; 1362 } 1363 1364 for (j = 1; j < 5; j++) { 1365 if (cvt->code[2] & (1 << j)) { 1366 newmode = drm_cvt_mode(dev, width, height, 1367 rates[j], j == 0, 1368 false, false); 1369 if (newmode) { 1370 drm_mode_probed_add(connector, newmode); 1371 modes++; 1372 } 1373 } 1374 } 1375 } 1376 1377 return modes; 1378} 1379 1380static void 1381do_cvt_mode(struct detailed_timing *timing, void *c) 1382{ 1383 struct detailed_mode_closure *closure = c; 1384 struct detailed_non_pixel *data = &timing->data.other_data; 1385 1386 if (data->type == EDID_DETAIL_CVT_3BYTE) 1387 closure->modes += drm_cvt_modes(closure->connector, timing); 1388} 1389 1390static int 1391add_cvt_modes(struct drm_connector *connector, struct edid *edid) 1392{ 1393 struct detailed_mode_closure closure = { 1394 connector, edid, 0, 0, 0 1395 }; 1396 1397 if (version_greater(edid, 1, 2)) 1398 drm_for_each_detailed_block((u8 *)edid, do_cvt_mode, &closure); 1399 1400 /* XXX should also look for CVT codes in VTB blocks */ 1401 1402 return closure.modes; 1403} 1404 1405static void 1406do_detailed_mode(struct detailed_timing *timing, void *c) 1407{ 1408 struct detailed_mode_closure *closure = c; 1409 struct drm_display_mode *newmode; 1410 1411 if (timing->pixel_clock) { 1412 newmode = drm_mode_detailed(closure->connector->dev, 1413 closure->edid, timing, 1414 closure->quirks); 1415 if (!newmode) 1416 return; 1417 1418 if (closure->preferred) 1419 newmode->type |= DRM_MODE_TYPE_PREFERRED; 1420 1421 drm_mode_probed_add(closure->connector, newmode); 1422 closure->modes++; 1423 closure->preferred = 0; 1424 } 1425} 1426 1427/* 1428 * add_detailed_modes - Add modes from detailed timings 1429 * @connector: attached connector 1430 * @edid: EDID block to scan 1431 * @quirks: quirks to apply 1432 */ 1433static int 1434add_detailed_modes(struct drm_connector *connector, struct edid *edid, 1435 u32 quirks) 1436{ 1437 struct detailed_mode_closure closure = { 1438 connector, 1439 edid, 1440 1, 1441 quirks, 1442 0 1443 }; 1444 1445 if (closure.preferred && !version_greater(edid, 1, 3)) 1446 closure.preferred = 1447 (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING); 1448 1449 drm_for_each_detailed_block((u8 *)edid, do_detailed_mode, &closure); 1450 1451 return closure.modes; 1452} 1453 1454#define HDMI_IDENTIFIER 0x000C03 1455#define AUDIO_BLOCK 0x01 1456#define VENDOR_BLOCK 0x03 1457#define SPEAKER_BLOCK 0x04 1458#define EDID_BASIC_AUDIO (1 << 6) 1459#define EDID_CEA_YCRCB444 (1 << 5) 1460#define EDID_CEA_YCRCB422 (1 << 4) 1461 1462/** 1463 * Search EDID for CEA extension block. 1464 */ 1465u8 *drm_find_cea_extension(struct edid *edid) 1466{ 1467 u8 *edid_ext = NULL; 1468 int i; 1469 1470 /* No EDID or EDID extensions */ 1471 if (edid == NULL || edid->extensions == 0) 1472 return NULL; 1473 1474 /* Find CEA extension */ 1475 for (i = 0; i < edid->extensions; i++) { 1476 edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1); 1477 if (edid_ext[0] == CEA_EXT) 1478 break; 1479 } 1480 1481 if (i == edid->extensions) 1482 return NULL; 1483 1484 return edid_ext; 1485} 1486 1487static void 1488parse_hdmi_vsdb(struct drm_connector *connector, uint8_t *db) 1489{ 1490 connector->eld[5] |= (db[6] >> 7) << 1; /* Supports_AI */ 1491 1492 connector->dvi_dual = db[6] & 1; 1493 connector->max_tmds_clock = db[7] * 5; 1494 1495 connector->latency_present[0] = db[8] >> 7; 1496 connector->latency_present[1] = (db[8] >> 6) & 1; 1497 connector->video_latency[0] = db[9]; 1498 connector->audio_latency[0] = db[10]; 1499 connector->video_latency[1] = db[11]; 1500 connector->audio_latency[1] = db[12]; 1501 1502 DRM_DEBUG_KMS("HDMI: DVI dual %d, " 1503 "max TMDS clock %d, " 1504 "latency present %d %d, " 1505 "video latency %d %d, " 1506 "audio latency %d %d\n", 1507 connector->dvi_dual, 1508 connector->max_tmds_clock, 1509 (int) connector->latency_present[0], 1510 (int) connector->latency_present[1], 1511 connector->video_latency[0], 1512 connector->video_latency[1], 1513 connector->audio_latency[0], 1514 connector->audio_latency[1]); 1515} 1516 1517static void 1518monitor_name(struct detailed_timing *t, void *data) 1519{ 1520 if (t->data.other_data.type == EDID_DETAIL_MONITOR_NAME) 1521 *(u8 **)data = t->data.other_data.data.str.str; 1522} 1523 1524/** 1525 * drm_edid_to_eld - build ELD from EDID 1526 * @connector: connector corresponding to the HDMI/DP sink 1527 * @edid: EDID to parse 1528 * 1529 * Fill the ELD (EDID-Like Data) buffer for passing to the audio driver. 1530 * Some ELD fields are left to the graphics driver caller: 1531 * - Conn_Type 1532 * - HDCP 1533 * - Port_ID 1534 */ 1535void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid) 1536{ 1537 uint8_t *eld = connector->eld; 1538 u8 *cea; 1539 u8 *name; 1540 u8 *db; 1541 int sad_count = 0; 1542 int mnl; 1543 int dbl; 1544 1545 memset(eld, 0, sizeof(connector->eld)); 1546 1547 cea = drm_find_cea_extension(edid); 1548 if (!cea) { 1549 DRM_DEBUG_KMS("ELD: no CEA Extension found\n"); 1550 return; 1551 } 1552 1553 name = NULL; 1554 drm_for_each_detailed_block((u8 *)edid, monitor_name, &name); 1555 for (mnl = 0; name && mnl < 13; mnl++) { 1556 if (name[mnl] == 0x0a) 1557 break; 1558 eld[20 + mnl] = name[mnl]; 1559 } 1560 eld[4] = (cea[1] << 5) | mnl; 1561 DRM_DEBUG_KMS("ELD monitor %s\n", eld + 20); 1562 1563 eld[0] = 2 << 3; /* ELD version: 2 */ 1564 1565 eld[16] = edid->mfg_id[0]; 1566 eld[17] = edid->mfg_id[1]; 1567 eld[18] = edid->prod_code[0]; 1568 eld[19] = edid->prod_code[1]; 1569 1570 for (db = cea + 4; db < cea + cea[2]; db += dbl + 1) { 1571 dbl = db[0] & 0x1f; 1572 1573 switch ((db[0] & 0xe0) >> 5) { 1574 case AUDIO_BLOCK: /* Audio Data Block, contains SADs */ 1575 sad_count = dbl / 3; 1576 memcpy(eld + 20 + mnl, &db[1], dbl); 1577 break; 1578 case SPEAKER_BLOCK: /* Speaker Allocation Data Block */ 1579 eld[7] = db[1]; 1580 break; 1581 case VENDOR_BLOCK: 1582 /* HDMI Vendor-Specific Data Block */ 1583 if (db[1] == 0x03 && db[2] == 0x0c && db[3] == 0) 1584 parse_hdmi_vsdb(connector, db); 1585 break; 1586 default: 1587 break; 1588 } 1589 } 1590 eld[5] |= sad_count << 4; 1591 eld[2] = (20 + mnl + sad_count * 3 + 3) / 4; 1592 1593 DRM_DEBUG_KMS("ELD size %d, SAD count %d\n", (int)eld[2], sad_count); 1594} 1595 1596/** 1597 * drm_av_sync_delay - HDMI/DP sink audio-video sync delay in millisecond 1598 * @connector: connector associated with the HDMI/DP sink 1599 * @mode: the display mode 1600 */ 1601int drm_av_sync_delay(struct drm_connector *connector, 1602 struct drm_display_mode *mode) 1603{ 1604 int i = !!(mode->flags & DRM_MODE_FLAG_INTERLACE); 1605 int a, v; 1606 1607 if (!connector->latency_present[0]) 1608 return 0; 1609 if (!connector->latency_present[1]) 1610 i = 0; 1611 1612 a = connector->audio_latency[i]; 1613 v = connector->video_latency[i]; 1614 1615 /* 1616 * HDMI/DP sink doesn't support audio or video? 1617 */ 1618 if (a == 255 || v == 255) 1619 return 0; 1620 1621 /* 1622 * Convert raw EDID values to millisecond. 1623 * Treat unknown latency as 0ms. 1624 */ 1625 if (a) 1626 a = min(2 * (a - 1), 500); 1627 if (v) 1628 v = min(2 * (v - 1), 500); 1629 1630 return max(v - a, 0); 1631} 1632 1633/** 1634 * drm_select_eld - select one ELD from multiple HDMI/DP sinks 1635 * @encoder: the encoder just changed display mode 1636 * @mode: the adjusted display mode 1637 * 1638 * It's possible for one encoder to be associated with multiple HDMI/DP sinks. 1639 * The policy is now hard coded to simply use the first HDMI/DP sink's ELD. 1640 */ 1641struct drm_connector *drm_select_eld(struct drm_encoder *encoder, 1642 struct drm_display_mode *mode) 1643{ 1644 struct drm_connector *connector; 1645 struct drm_device *dev = encoder->dev; 1646 1647 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 1648 if (connector->encoder == encoder && connector->eld[0]) 1649 return connector; 1650 1651 return NULL; 1652} 1653 1654/** 1655 * drm_detect_hdmi_monitor - detect whether monitor is hdmi. 1656 * @edid: monitor EDID information 1657 * 1658 * Parse the CEA extension according to CEA-861-B. 1659 * Return true if HDMI, false if not or unknown. 1660 */ 1661bool drm_detect_hdmi_monitor(struct edid *edid) 1662{ 1663 u8 *edid_ext; 1664 int i, hdmi_id; 1665 int start_offset, end_offset; 1666 bool is_hdmi = false; 1667 1668 edid_ext = drm_find_cea_extension(edid); 1669 if (!edid_ext) 1670 goto end; 1671 1672 /* Data block offset in CEA extension block */ 1673 start_offset = 4; 1674 end_offset = edid_ext[2]; 1675 1676 /* 1677 * Because HDMI identifier is in Vendor Specific Block, 1678 * search it from all data blocks of CEA extension. 1679 */ 1680 for (i = start_offset; i < end_offset; 1681 /* Increased by data block len */ 1682 i += ((edid_ext[i] & 0x1f) + 1)) { 1683 /* Find vendor specific block */ 1684 if ((edid_ext[i] >> 5) == VENDOR_BLOCK) { 1685 hdmi_id = edid_ext[i + 1] | (edid_ext[i + 2] << 8) | 1686 edid_ext[i + 3] << 16; 1687 /* Find HDMI identifier */ 1688 if (hdmi_id == HDMI_IDENTIFIER) 1689 is_hdmi = true; 1690 break; 1691 } 1692 } 1693 1694end: 1695 return is_hdmi; 1696} 1697 1698/** 1699 * drm_detect_monitor_audio - check monitor audio capability 1700 * 1701 * Monitor should have CEA extension block. 1702 * If monitor has 'basic audio', but no CEA audio blocks, it's 'basic 1703 * audio' only. If there is any audio extension block and supported 1704 * audio format, assume at least 'basic audio' support, even if 'basic 1705 * audio' is not defined in EDID. 1706 * 1707 */ 1708bool drm_detect_monitor_audio(struct edid *edid) 1709{ 1710 u8 *edid_ext; 1711 int i, j; 1712 bool has_audio = false; 1713 int start_offset, end_offset; 1714 1715 edid_ext = drm_find_cea_extension(edid); 1716 if (!edid_ext) 1717 goto end; 1718 1719 has_audio = ((edid_ext[3] & EDID_BASIC_AUDIO) != 0); 1720 1721 if (has_audio) { 1722 DRM_DEBUG_KMS("Monitor has basic audio support\n"); 1723 goto end; 1724 } 1725 1726 /* Data block offset in CEA extension block */ 1727 start_offset = 4; 1728 end_offset = edid_ext[2]; 1729 1730 for (i = start_offset; i < end_offset; 1731 i += ((edid_ext[i] & 0x1f) + 1)) { 1732 if ((edid_ext[i] >> 5) == AUDIO_BLOCK) { 1733 has_audio = true; 1734 for (j = 1; j < (edid_ext[i] & 0x1f); j += 3) 1735 DRM_DEBUG_KMS("CEA audio format %d\n", 1736 (edid_ext[i + j] >> 3) & 0xf); 1737 goto end; 1738 } 1739 } 1740end: 1741 return has_audio; 1742} 1743 1744/** 1745 * drm_add_display_info - pull display info out if present 1746 * @edid: EDID data 1747 * @info: display info (attached to connector) 1748 * 1749 * Grab any available display info and stuff it into the drm_display_info 1750 * structure that's part of the connector. Useful for tracking bpp and 1751 * color spaces. 1752 */ 1753static void drm_add_display_info(struct edid *edid, 1754 struct drm_display_info *info) 1755{ 1756 u8 *edid_ext; 1757 1758 info->width_mm = edid->width_cm * 10; 1759 info->height_mm = edid->height_cm * 10; 1760 1761 /* driver figures it out in this case */ 1762 info->bpc = 0; 1763 info->color_formats = 0; 1764 1765 if (edid->revision < 3) 1766 return; 1767 1768 if (!(edid->input & DRM_EDID_INPUT_DIGITAL)) 1769 return; 1770 1771 /* Get data from CEA blocks if present */ 1772 edid_ext = drm_find_cea_extension(edid); 1773 if (edid_ext) { 1774 info->cea_rev = edid_ext[1]; 1775 1776 /* The existence of a CEA block should imply RGB support */ 1777 info->color_formats = DRM_COLOR_FORMAT_RGB444; 1778 if (edid_ext[3] & EDID_CEA_YCRCB444) 1779 info->color_formats |= DRM_COLOR_FORMAT_YCRCB444; 1780 if (edid_ext[3] & EDID_CEA_YCRCB422) 1781 info->color_formats |= DRM_COLOR_FORMAT_YCRCB422; 1782 } 1783 1784 /* Only defined for 1.4 with digital displays */ 1785 if (edid->revision < 4) 1786 return; 1787 1788 switch (edid->input & DRM_EDID_DIGITAL_DEPTH_MASK) { 1789 case DRM_EDID_DIGITAL_DEPTH_6: 1790 info->bpc = 6; 1791 break; 1792 case DRM_EDID_DIGITAL_DEPTH_8: 1793 info->bpc = 8; 1794 break; 1795 case DRM_EDID_DIGITAL_DEPTH_10: 1796 info->bpc = 10; 1797 break; 1798 case DRM_EDID_DIGITAL_DEPTH_12: 1799 info->bpc = 12; 1800 break; 1801 case DRM_EDID_DIGITAL_DEPTH_14: 1802 info->bpc = 14; 1803 break; 1804 case DRM_EDID_DIGITAL_DEPTH_16: 1805 info->bpc = 16; 1806 break; 1807 case DRM_EDID_DIGITAL_DEPTH_UNDEF: 1808 default: 1809 info->bpc = 0; 1810 break; 1811 } 1812 1813 info->color_formats |= DRM_COLOR_FORMAT_RGB444; 1814 if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB444) 1815 info->color_formats |= DRM_COLOR_FORMAT_YCRCB444; 1816 if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB422) 1817 info->color_formats |= DRM_COLOR_FORMAT_YCRCB422; 1818} 1819 1820/** 1821 * drm_add_edid_modes - add modes from EDID data, if available 1822 * @connector: connector we're probing 1823 * @edid: edid data 1824 * 1825 * Add the specified modes to the connector's mode list. 1826 * 1827 * Return number of modes added or 0 if we couldn't find any. 1828 */ 1829int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid) 1830{ 1831 int num_modes = 0; 1832 u32 quirks; 1833 1834 if (edid == NULL) { 1835 return 0; 1836 } 1837 if (!drm_edid_is_valid(edid)) { 1838 device_printf(connector->dev->device, "%s: EDID invalid.\n", 1839 drm_get_connector_name(connector)); 1840 return 0; 1841 } 1842 1843 quirks = edid_get_quirks(edid); 1844 1845 /* 1846 * EDID spec says modes should be preferred in this order: 1847 * - preferred detailed mode 1848 * - other detailed modes from base block 1849 * - detailed modes from extension blocks 1850 * - CVT 3-byte code modes 1851 * - standard timing codes 1852 * - established timing codes 1853 * - modes inferred from GTF or CVT range information 1854 * 1855 * We get this pretty much right. 1856 * 1857 * XXX order for additional mode types in extension blocks? 1858 */ 1859 num_modes += add_detailed_modes(connector, edid, quirks); 1860 num_modes += add_cvt_modes(connector, edid); 1861 num_modes += add_standard_modes(connector, edid); 1862 num_modes += add_established_modes(connector, edid); 1863 num_modes += add_inferred_modes(connector, edid); 1864 1865 if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75)) 1866 edid_fixup_preferred(connector, quirks); 1867 1868 drm_add_display_info(edid, &connector->display_info); 1869 1870 return num_modes; 1871} 1872 1873/** 1874 * drm_add_modes_noedid - add modes for the connectors without EDID 1875 * @connector: connector we're probing 1876 * @hdisplay: the horizontal display limit 1877 * @vdisplay: the vertical display limit 1878 * 1879 * Add the specified modes to the connector's mode list. Only when the 1880 * hdisplay/vdisplay is not beyond the given limit, it will be added. 1881 * 1882 * Return number of modes added or 0 if we couldn't find any. 1883 */ 1884int drm_add_modes_noedid(struct drm_connector *connector, 1885 int hdisplay, int vdisplay) 1886{ 1887 int i, count, num_modes = 0; 1888 struct drm_display_mode *mode; 1889 struct drm_device *dev = connector->dev; 1890 1891 count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode); 1892 if (hdisplay < 0) 1893 hdisplay = 0; 1894 if (vdisplay < 0) 1895 vdisplay = 0; 1896 1897 for (i = 0; i < count; i++) { 1898 struct drm_display_mode *ptr = &drm_dmt_modes[i]; 1899 if (hdisplay && vdisplay) { 1900 /* 1901 * Only when two are valid, they will be used to check 1902 * whether the mode should be added to the mode list of 1903 * the connector. 1904 */ 1905 if (ptr->hdisplay > hdisplay || 1906 ptr->vdisplay > vdisplay) 1907 continue; 1908 } 1909 if (drm_mode_vrefresh(ptr) > 61) 1910 continue; 1911 mode = drm_mode_duplicate(dev, ptr); 1912 if (mode) { 1913 drm_mode_probed_add(connector, mode); 1914 num_modes++; 1915 } 1916 } 1917 return num_modes; 1918} 1919