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