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 #include <linux/kernel.h> 31 #include <linux/slab.h> 32 #include <linux/i2c.h> 33 #include <linux/module.h> 34 #include <drm/drmP.h> 35 #include <drm/drm_edid.h> 36 #include "drm_edid_modes.h" 37 38 #define version_greater(edid, maj, min) \ 39 (((edid)->version > (maj)) || \ 40 ((edid)->version == (maj) && (edid)->revision > (min))) 41 42 #define EDID_EST_TIMINGS 16 43 #define EDID_STD_TIMINGS 8 44 #define EDID_DETAILED_TIMINGS 4 45 46 /* 47 * EDID blocks out in the wild have a variety of bugs, try to collect 48 * them here (note that userspace may work around broken monitors first, 49 * but fixes should make their way here so that the kernel "just works" 50 * on as many displays as possible). 51 */ 52 53 /* First detailed mode wrong, use largest 60Hz mode */ 54 #define EDID_QUIRK_PREFER_LARGE_60 (1 << 0) 55 /* Reported 135MHz pixel clock is too high, needs adjustment */ 56 #define EDID_QUIRK_135_CLOCK_TOO_HIGH (1 << 1) 57 /* Prefer the largest mode at 75 Hz */ 58 #define EDID_QUIRK_PREFER_LARGE_75 (1 << 2) 59 /* Detail timing is in cm not mm */ 60 #define EDID_QUIRK_DETAILED_IN_CM (1 << 3) 61 /* Detailed timing descriptors have bogus size values, so just take the 62 * maximum size and use that. 63 */ 64 #define EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE (1 << 4) 65 /* Monitor forgot to set the first detailed is preferred bit. */ 66 #define EDID_QUIRK_FIRST_DETAILED_PREFERRED (1 << 5) 67 /* use +hsync +vsync for detailed mode */ 68 #define EDID_QUIRK_DETAILED_SYNC_PP (1 << 6) 69 /* Force reduced-blanking timings for detailed modes */ 70 #define EDID_QUIRK_FORCE_REDUCED_BLANKING (1 << 7) 71 72 struct detailed_mode_closure { 73 struct drm_connector *connector; 74 struct edid *edid; 75 bool preferred; 76 u32 quirks; 77 int modes; 78 }; 79 80 #define LEVEL_DMT 0 81 #define LEVEL_GTF 1 82 #define LEVEL_GTF2 2 83 #define LEVEL_CVT 3 84 85 static struct edid_quirk { 86 char vendor[4]; 87 int product_id; 88 u32 quirks; 89 } edid_quirk_list[] = { 90 /* ASUS VW222S */ 91 { "ACI", 0x22a2, EDID_QUIRK_FORCE_REDUCED_BLANKING }, 92 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 135 static 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 */ 143 int 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 } 153 EXPORT_SYMBOL(drm_edid_header_is_valid); 154 155 static int edid_fixup __read_mostly = 6; 156 module_param_named(edid_fixup, edid_fixup, int, 0400); 157 MODULE_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 */ 164 bool 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 214 bad: 215 if (raw_edid && print_bad_edid) { 216 printk(KERN_ERR "Raw EDID:\n"); 217 print_hex_dump(KERN_ERR, " \t", DUMP_PREFIX_NONE, 16, 1, 218 raw_edid, EDID_LENGTH, false); 219 } 220 return 0; 221 } 222 EXPORT_SYMBOL(drm_edid_block_valid); 223 224 /** 225 * drm_edid_is_valid - sanity check EDID data 226 * @edid: EDID data 227 * 228 * Sanity-check an entire EDID record (including extensions) 229 */ 230 bool drm_edid_is_valid(struct edid *edid) 231 { 232 int i; 233 u8 *raw = (u8 *)edid; 234 235 if (!edid) 236 return false; 237 238 for (i = 0; i <= edid->extensions; i++) 239 if (!drm_edid_block_valid(raw + i * EDID_LENGTH, i, true)) 240 return false; 241 242 return true; 243 } 244 EXPORT_SYMBOL(drm_edid_is_valid); 245 246 #define DDC_SEGMENT_ADDR 0x30 247 /** 248 * Get EDID information via I2C. 249 * 250 * \param adapter : i2c device adaptor 251 * \param buf : EDID data buffer to be filled 252 * \param len : EDID data buffer length 253 * \return 0 on success or -1 on failure. 254 * 255 * Try to fetch EDID information by calling i2c driver function. 256 */ 257 static int 258 drm_do_probe_ddc_edid(struct i2c_adapter *adapter, unsigned char *buf, 259 int block, int len) 260 { 261 unsigned char start = block * EDID_LENGTH; 262 unsigned char segment = block >> 1; 263 unsigned char xfers = segment ? 3 : 2; 264 int ret, retries = 5; 265 266 /* The core i2c driver will automatically retry the transfer if the 267 * adapter reports EAGAIN. However, we find that bit-banging transfers 268 * are susceptible to errors under a heavily loaded machine and 269 * generate spurious NAKs and timeouts. Retrying the transfer 270 * of the individual block a few times seems to overcome this. 271 */ 272 do { 273 struct i2c_msg msgs[] = { 274 { 275 .addr = DDC_SEGMENT_ADDR, 276 .flags = 0, 277 .len = 1, 278 .buf = &segment, 279 }, { 280 .addr = DDC_ADDR, 281 .flags = 0, 282 .len = 1, 283 .buf = &start, 284 }, { 285 .addr = DDC_ADDR, 286 .flags = I2C_M_RD, 287 .len = len, 288 .buf = buf, 289 } 290 }; 291 292 /* 293 * Avoid sending the segment addr to not upset non-compliant ddc 294 * monitors. 295 */ 296 ret = i2c_transfer(adapter, &msgs[3 - xfers], xfers); 297 298 if (ret == -ENXIO) { 299 DRM_DEBUG_KMS("drm: skipping non-existent adapter %s\n", 300 adapter->name); 301 break; 302 } 303 } while (ret != xfers && --retries); 304 305 return ret == xfers ? 0 : -1; 306 } 307 308 static bool drm_edid_is_zero(u8 *in_edid, int length) 309 { 310 int i; 311 u32 *raw_edid = (u32 *)in_edid; 312 313 for (i = 0; i < length / 4; i++) 314 if (*(raw_edid + i) != 0) 315 return false; 316 return true; 317 } 318 319 static u8 * 320 drm_do_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter) 321 { 322 int i, j = 0, valid_extensions = 0; 323 u8 *block, *new; 324 bool print_bad_edid = !connector->bad_edid_counter || (drm_debug & DRM_UT_KMS); 325 326 if ((block = kmalloc(EDID_LENGTH, GFP_KERNEL)) == NULL) 327 return NULL; 328 329 /* base block fetch */ 330 for (i = 0; i < 4; i++) { 331 if (drm_do_probe_ddc_edid(adapter, block, 0, EDID_LENGTH)) 332 goto out; 333 if (drm_edid_block_valid(block, 0, print_bad_edid)) 334 break; 335 if (i == 0 && drm_edid_is_zero(block, EDID_LENGTH)) { 336 connector->null_edid_counter++; 337 goto carp; 338 } 339 } 340 if (i == 4) 341 goto carp; 342 343 /* if there's no extensions, we're done */ 344 if (block[0x7e] == 0) 345 return block; 346 347 new = krealloc(block, (block[0x7e] + 1) * EDID_LENGTH, GFP_KERNEL); 348 if (!new) 349 goto out; 350 block = new; 351 352 for (j = 1; j <= block[0x7e]; j++) { 353 for (i = 0; i < 4; i++) { 354 if (drm_do_probe_ddc_edid(adapter, 355 block + (valid_extensions + 1) * EDID_LENGTH, 356 j, EDID_LENGTH)) 357 goto out; 358 if (drm_edid_block_valid(block + (valid_extensions + 1) * EDID_LENGTH, j, print_bad_edid)) { 359 valid_extensions++; 360 break; 361 } 362 } 363 if (i == 4) 364 dev_warn(connector->dev->dev, 365 "%s: Ignoring invalid EDID block %d.\n", 366 drm_get_connector_name(connector), j); 367 } 368 369 if (valid_extensions != block[0x7e]) { 370 block[EDID_LENGTH-1] += block[0x7e] - valid_extensions; 371 block[0x7e] = valid_extensions; 372 new = krealloc(block, (valid_extensions + 1) * EDID_LENGTH, GFP_KERNEL); 373 if (!new) 374 goto out; 375 block = new; 376 } 377 378 return block; 379 380 carp: 381 if (print_bad_edid) { 382 dev_warn(connector->dev->dev, "%s: EDID block %d invalid.\n", 383 drm_get_connector_name(connector), j); 384 } 385 connector->bad_edid_counter++; 386 387 out: 388 kfree(block); 389 return NULL; 390 } 391 392 /** 393 * Probe DDC presence. 394 * 395 * \param adapter : i2c device adaptor 396 * \return 1 on success 397 */ 398 bool 399 drm_probe_ddc(struct i2c_adapter *adapter) 400 { 401 unsigned char out; 402 403 return (drm_do_probe_ddc_edid(adapter, &out, 0, 1) == 0); 404 } 405 EXPORT_SYMBOL(drm_probe_ddc); 406 407 /** 408 * drm_get_edid - get EDID data, if available 409 * @connector: connector we're probing 410 * @adapter: i2c adapter to use for DDC 411 * 412 * Poke the given i2c channel to grab EDID data if possible. If found, 413 * attach it to the connector. 414 * 415 * Return edid data or NULL if we couldn't find any. 416 */ 417 struct edid *drm_get_edid(struct drm_connector *connector, 418 struct i2c_adapter *adapter) 419 { 420 struct edid *edid = NULL; 421 422 if (drm_probe_ddc(adapter)) 423 edid = (struct edid *)drm_do_get_edid(connector, adapter); 424 425 return edid; 426 } 427 EXPORT_SYMBOL(drm_get_edid); 428 429 /*** EDID parsing ***/ 430 431 /** 432 * edid_vendor - match a string against EDID's obfuscated vendor field 433 * @edid: EDID to match 434 * @vendor: vendor string 435 * 436 * Returns true if @vendor is in @edid, false otherwise 437 */ 438 static bool edid_vendor(struct edid *edid, char *vendor) 439 { 440 char edid_vendor[3]; 441 442 edid_vendor[0] = ((edid->mfg_id[0] & 0x7c) >> 2) + '@'; 443 edid_vendor[1] = (((edid->mfg_id[0] & 0x3) << 3) | 444 ((edid->mfg_id[1] & 0xe0) >> 5)) + '@'; 445 edid_vendor[2] = (edid->mfg_id[1] & 0x1f) + '@'; 446 447 return !strncmp(edid_vendor, vendor, 3); 448 } 449 450 /** 451 * edid_get_quirks - return quirk flags for a given EDID 452 * @edid: EDID to process 453 * 454 * This tells subsequent routines what fixes they need to apply. 455 */ 456 static u32 edid_get_quirks(struct edid *edid) 457 { 458 struct edid_quirk *quirk; 459 int i; 460 461 for (i = 0; i < ARRAY_SIZE(edid_quirk_list); i++) { 462 quirk = &edid_quirk_list[i]; 463 464 if (edid_vendor(edid, quirk->vendor) && 465 (EDID_PRODUCT_ID(edid) == quirk->product_id)) 466 return quirk->quirks; 467 } 468 469 return 0; 470 } 471 472 #define MODE_SIZE(m) ((m)->hdisplay * (m)->vdisplay) 473 #define MODE_REFRESH_DIFF(m,r) (abs((m)->vrefresh - target_refresh)) 474 475 /** 476 * edid_fixup_preferred - set preferred modes based on quirk list 477 * @connector: has mode list to fix up 478 * @quirks: quirks list 479 * 480 * Walk the mode list for @connector, clearing the preferred status 481 * on existing modes and setting it anew for the right mode ala @quirks. 482 */ 483 static void edid_fixup_preferred(struct drm_connector *connector, 484 u32 quirks) 485 { 486 struct drm_display_mode *t, *cur_mode, *preferred_mode; 487 int target_refresh = 0; 488 489 if (list_empty(&connector->probed_modes)) 490 return; 491 492 if (quirks & EDID_QUIRK_PREFER_LARGE_60) 493 target_refresh = 60; 494 if (quirks & EDID_QUIRK_PREFER_LARGE_75) 495 target_refresh = 75; 496 497 preferred_mode = list_first_entry(&connector->probed_modes, 498 struct drm_display_mode, head); 499 500 list_for_each_entry_safe(cur_mode, t, &connector->probed_modes, head) { 501 cur_mode->type &= ~DRM_MODE_TYPE_PREFERRED; 502 503 if (cur_mode == preferred_mode) 504 continue; 505 506 /* Largest mode is preferred */ 507 if (MODE_SIZE(cur_mode) > MODE_SIZE(preferred_mode)) 508 preferred_mode = cur_mode; 509 510 /* At a given size, try to get closest to target refresh */ 511 if ((MODE_SIZE(cur_mode) == MODE_SIZE(preferred_mode)) && 512 MODE_REFRESH_DIFF(cur_mode, target_refresh) < 513 MODE_REFRESH_DIFF(preferred_mode, target_refresh)) { 514 preferred_mode = cur_mode; 515 } 516 } 517 518 preferred_mode->type |= DRM_MODE_TYPE_PREFERRED; 519 } 520 521 static bool 522 mode_is_rb(const struct drm_display_mode *mode) 523 { 524 return (mode->htotal - mode->hdisplay == 160) && 525 (mode->hsync_end - mode->hdisplay == 80) && 526 (mode->hsync_end - mode->hsync_start == 32) && 527 (mode->vsync_start - mode->vdisplay == 3); 528 } 529 530 /* 531 * drm_mode_find_dmt - Create a copy of a mode if present in DMT 532 * @dev: Device to duplicate against 533 * @hsize: Mode width 534 * @vsize: Mode height 535 * @fresh: Mode refresh rate 536 * @rb: Mode reduced-blanking-ness 537 * 538 * Walk the DMT mode list looking for a match for the given parameters. 539 * Return a newly allocated copy of the mode, or NULL if not found. 540 */ 541 struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev, 542 int hsize, int vsize, int fresh, 543 bool rb) 544 { 545 int i; 546 547 for (i = 0; i < drm_num_dmt_modes; i++) { 548 const struct drm_display_mode *ptr = &drm_dmt_modes[i]; 549 if (hsize != ptr->hdisplay) 550 continue; 551 if (vsize != ptr->vdisplay) 552 continue; 553 if (fresh != drm_mode_vrefresh(ptr)) 554 continue; 555 if (rb != mode_is_rb(ptr)) 556 continue; 557 558 return drm_mode_duplicate(dev, ptr); 559 } 560 561 return NULL; 562 } 563 EXPORT_SYMBOL(drm_mode_find_dmt); 564 565 typedef void detailed_cb(struct detailed_timing *timing, void *closure); 566 567 static void 568 cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure) 569 { 570 int i, n = 0; 571 u8 d = ext[0x02]; 572 u8 *det_base = ext + d; 573 574 n = (127 - d) / 18; 575 for (i = 0; i < n; i++) 576 cb((struct detailed_timing *)(det_base + 18 * i), closure); 577 } 578 579 static void 580 vtb_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 592 static void 593 drm_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 619 static void 620 is_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. */ 629 static bool 630 drm_monitor_supports_rb(struct edid *edid) 631 { 632 if (edid->revision >= 4) { 633 bool ret = false; 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 641 static void 642 find_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 */ 650 static int 651 drm_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 658 static int 659 drm_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 666 static int 667 drm_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 674 static int 675 drm_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 682 static int 683 drm_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 */ 694 static 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 */ 710 static int 711 bad_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 */ 726 static struct drm_display_mode * 727 drm_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 drm_mode_destroy(dev, mode); 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 */ 842 static void 843 drm_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 < 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 */ 886 static 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 printk(KERN_WARNING "stereo mode not supported\n"); 908 return NULL; 909 } 910 if (!(pt->misc & DRM_EDID_PT_SEPARATE_SYNC)) { 911 printk(KERN_WARNING "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 921 if (quirks & EDID_QUIRK_FORCE_REDUCED_BLANKING) { 922 mode = drm_cvt_mode(dev, hactive, vactive, 60, true, false, false); 923 if (!mode) 924 return NULL; 925 926 goto set_size; 927 } 928 929 mode = drm_mode_create(dev); 930 if (!mode) 931 return NULL; 932 933 if (quirks & EDID_QUIRK_135_CLOCK_TOO_HIGH) 934 timing->pixel_clock = cpu_to_le16(1088); 935 936 mode->clock = le16_to_cpu(timing->pixel_clock) * 10; 937 938 mode->hdisplay = hactive; 939 mode->hsync_start = mode->hdisplay + hsync_offset; 940 mode->hsync_end = mode->hsync_start + hsync_pulse_width; 941 mode->htotal = mode->hdisplay + hblank; 942 943 mode->vdisplay = vactive; 944 mode->vsync_start = mode->vdisplay + vsync_offset; 945 mode->vsync_end = mode->vsync_start + vsync_pulse_width; 946 mode->vtotal = mode->vdisplay + vblank; 947 948 /* Some EDIDs have bogus h/vtotal values */ 949 if (mode->hsync_end > mode->htotal) 950 mode->htotal = mode->hsync_end + 1; 951 if (mode->vsync_end > mode->vtotal) 952 mode->vtotal = mode->vsync_end + 1; 953 954 drm_mode_do_interlace_quirk(mode, pt); 955 956 if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) { 957 pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE; 958 } 959 960 mode->flags |= (pt->misc & DRM_EDID_PT_HSYNC_POSITIVE) ? 961 DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC; 962 mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ? 963 DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC; 964 965 set_size: 966 mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4; 967 mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8; 968 969 if (quirks & EDID_QUIRK_DETAILED_IN_CM) { 970 mode->width_mm *= 10; 971 mode->height_mm *= 10; 972 } 973 974 if (quirks & EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE) { 975 mode->width_mm = edid->width_cm * 10; 976 mode->height_mm = edid->height_cm * 10; 977 } 978 979 mode->type = DRM_MODE_TYPE_DRIVER; 980 drm_mode_set_name(mode); 981 982 return mode; 983 } 984 985 static bool 986 mode_in_hsync_range(const struct drm_display_mode *mode, 987 struct edid *edid, u8 *t) 988 { 989 int hsync, hmin, hmax; 990 991 hmin = t[7]; 992 if (edid->revision >= 4) 993 hmin += ((t[4] & 0x04) ? 255 : 0); 994 hmax = t[8]; 995 if (edid->revision >= 4) 996 hmax += ((t[4] & 0x08) ? 255 : 0); 997 hsync = drm_mode_hsync(mode); 998 999 return (hsync <= hmax && hsync >= hmin); 1000 } 1001 1002 static bool 1003 mode_in_vsync_range(const struct drm_display_mode *mode, 1004 struct edid *edid, u8 *t) 1005 { 1006 int vsync, vmin, vmax; 1007 1008 vmin = t[5]; 1009 if (edid->revision >= 4) 1010 vmin += ((t[4] & 0x01) ? 255 : 0); 1011 vmax = t[6]; 1012 if (edid->revision >= 4) 1013 vmax += ((t[4] & 0x02) ? 255 : 0); 1014 vsync = drm_mode_vrefresh(mode); 1015 1016 return (vsync <= vmax && vsync >= vmin); 1017 } 1018 1019 static u32 1020 range_pixel_clock(struct edid *edid, u8 *t) 1021 { 1022 /* unspecified */ 1023 if (t[9] == 0 || t[9] == 255) 1024 return 0; 1025 1026 /* 1.4 with CVT support gives us real precision, yay */ 1027 if (edid->revision >= 4 && t[10] == 0x04) 1028 return (t[9] * 10000) - ((t[12] >> 2) * 250); 1029 1030 /* 1.3 is pathetic, so fuzz up a bit */ 1031 return t[9] * 10000 + 5001; 1032 } 1033 1034 static bool 1035 mode_in_range(const struct drm_display_mode *mode, struct edid *edid, 1036 struct detailed_timing *timing) 1037 { 1038 u32 max_clock; 1039 u8 *t = (u8 *)timing; 1040 1041 if (!mode_in_hsync_range(mode, edid, t)) 1042 return false; 1043 1044 if (!mode_in_vsync_range(mode, edid, t)) 1045 return false; 1046 1047 if ((max_clock = range_pixel_clock(edid, t))) 1048 if (mode->clock > max_clock) 1049 return false; 1050 1051 /* 1.4 max horizontal check */ 1052 if (edid->revision >= 4 && t[10] == 0x04) 1053 if (t[13] && mode->hdisplay > 8 * (t[13] + (256 * (t[12]&0x3)))) 1054 return false; 1055 1056 if (mode_is_rb(mode) && !drm_monitor_supports_rb(edid)) 1057 return false; 1058 1059 return true; 1060 } 1061 1062 static bool valid_inferred_mode(const struct drm_connector *connector, 1063 const struct drm_display_mode *mode) 1064 { 1065 struct drm_display_mode *m; 1066 bool ok = false; 1067 1068 list_for_each_entry(m, &connector->probed_modes, head) { 1069 if (mode->hdisplay == m->hdisplay && 1070 mode->vdisplay == m->vdisplay && 1071 drm_mode_vrefresh(mode) == drm_mode_vrefresh(m)) 1072 return false; /* duplicated */ 1073 if (mode->hdisplay <= m->hdisplay && 1074 mode->vdisplay <= m->vdisplay) 1075 ok = true; 1076 } 1077 return ok; 1078 } 1079 1080 static int 1081 drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid, 1082 struct detailed_timing *timing) 1083 { 1084 int i, modes = 0; 1085 struct drm_display_mode *newmode; 1086 struct drm_device *dev = connector->dev; 1087 1088 for (i = 0; i < drm_num_dmt_modes; i++) { 1089 if (mode_in_range(drm_dmt_modes + i, edid, timing) && 1090 valid_inferred_mode(connector, drm_dmt_modes + i)) { 1091 newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]); 1092 if (newmode) { 1093 drm_mode_probed_add(connector, newmode); 1094 modes++; 1095 } 1096 } 1097 } 1098 1099 return modes; 1100 } 1101 1102 /* fix up 1366x768 mode from 1368x768; 1103 * GFT/CVT can't express 1366 width which isn't dividable by 8 1104 */ 1105 static void fixup_mode_1366x768(struct drm_display_mode *mode) 1106 { 1107 if (mode->hdisplay == 1368 && mode->vdisplay == 768) { 1108 mode->hdisplay = 1366; 1109 mode->hsync_start--; 1110 mode->hsync_end--; 1111 drm_mode_set_name(mode); 1112 } 1113 } 1114 1115 static int 1116 drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid, 1117 struct detailed_timing *timing) 1118 { 1119 int i, modes = 0; 1120 struct drm_display_mode *newmode; 1121 struct drm_device *dev = connector->dev; 1122 1123 for (i = 0; i < num_extra_modes; i++) { 1124 const struct minimode *m = &extra_modes[i]; 1125 newmode = drm_gtf_mode(dev, m->w, m->h, m->r, 0, 0); 1126 if (!newmode) 1127 return modes; 1128 1129 fixup_mode_1366x768(newmode); 1130 if (!mode_in_range(newmode, edid, timing) || 1131 !valid_inferred_mode(connector, newmode)) { 1132 drm_mode_destroy(dev, newmode); 1133 continue; 1134 } 1135 1136 drm_mode_probed_add(connector, newmode); 1137 modes++; 1138 } 1139 1140 return modes; 1141 } 1142 1143 static int 1144 drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid, 1145 struct detailed_timing *timing) 1146 { 1147 int i, modes = 0; 1148 struct drm_display_mode *newmode; 1149 struct drm_device *dev = connector->dev; 1150 bool rb = drm_monitor_supports_rb(edid); 1151 1152 for (i = 0; i < num_extra_modes; i++) { 1153 const struct minimode *m = &extra_modes[i]; 1154 newmode = drm_cvt_mode(dev, m->w, m->h, m->r, rb, 0, 0); 1155 if (!newmode) 1156 return modes; 1157 1158 fixup_mode_1366x768(newmode); 1159 if (!mode_in_range(newmode, edid, timing) || 1160 !valid_inferred_mode(connector, newmode)) { 1161 drm_mode_destroy(dev, newmode); 1162 continue; 1163 } 1164 1165 drm_mode_probed_add(connector, newmode); 1166 modes++; 1167 } 1168 1169 return modes; 1170 } 1171 1172 static void 1173 do_inferred_modes(struct detailed_timing *timing, void *c) 1174 { 1175 struct detailed_mode_closure *closure = c; 1176 struct detailed_non_pixel *data = &timing->data.other_data; 1177 struct detailed_data_monitor_range *range = &data->data.range; 1178 1179 if (data->type != EDID_DETAIL_MONITOR_RANGE) 1180 return; 1181 1182 closure->modes += drm_dmt_modes_for_range(closure->connector, 1183 closure->edid, 1184 timing); 1185 1186 if (!version_greater(closure->edid, 1, 1)) 1187 return; /* GTF not defined yet */ 1188 1189 switch (range->flags) { 1190 case 0x02: /* secondary gtf, XXX could do more */ 1191 case 0x00: /* default gtf */ 1192 closure->modes += drm_gtf_modes_for_range(closure->connector, 1193 closure->edid, 1194 timing); 1195 break; 1196 case 0x04: /* cvt, only in 1.4+ */ 1197 if (!version_greater(closure->edid, 1, 3)) 1198 break; 1199 1200 closure->modes += drm_cvt_modes_for_range(closure->connector, 1201 closure->edid, 1202 timing); 1203 break; 1204 case 0x01: /* just the ranges, no formula */ 1205 default: 1206 break; 1207 } 1208 } 1209 1210 static int 1211 add_inferred_modes(struct drm_connector *connector, struct edid *edid) 1212 { 1213 struct detailed_mode_closure closure = { 1214 connector, edid, 0, 0, 0 1215 }; 1216 1217 if (version_greater(edid, 1, 0)) 1218 drm_for_each_detailed_block((u8 *)edid, do_inferred_modes, 1219 &closure); 1220 1221 return closure.modes; 1222 } 1223 1224 static int 1225 drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing) 1226 { 1227 int i, j, m, modes = 0; 1228 struct drm_display_mode *mode; 1229 u8 *est = ((u8 *)timing) + 5; 1230 1231 for (i = 0; i < 6; i++) { 1232 for (j = 7; j > 0; j--) { 1233 m = (i * 8) + (7 - j); 1234 if (m >= ARRAY_SIZE(est3_modes)) 1235 break; 1236 if (est[i] & (1 << j)) { 1237 mode = drm_mode_find_dmt(connector->dev, 1238 est3_modes[m].w, 1239 est3_modes[m].h, 1240 est3_modes[m].r, 1241 est3_modes[m].rb); 1242 if (mode) { 1243 drm_mode_probed_add(connector, mode); 1244 modes++; 1245 } 1246 } 1247 } 1248 } 1249 1250 return modes; 1251 } 1252 1253 static void 1254 do_established_modes(struct detailed_timing *timing, void *c) 1255 { 1256 struct detailed_mode_closure *closure = c; 1257 struct detailed_non_pixel *data = &timing->data.other_data; 1258 1259 if (data->type == EDID_DETAIL_EST_TIMINGS) 1260 closure->modes += drm_est3_modes(closure->connector, timing); 1261 } 1262 1263 /** 1264 * add_established_modes - get est. modes from EDID and add them 1265 * @edid: EDID block to scan 1266 * 1267 * Each EDID block contains a bitmap of the supported "established modes" list 1268 * (defined above). Tease them out and add them to the global modes list. 1269 */ 1270 static int 1271 add_established_modes(struct drm_connector *connector, struct edid *edid) 1272 { 1273 struct drm_device *dev = connector->dev; 1274 unsigned long est_bits = edid->established_timings.t1 | 1275 (edid->established_timings.t2 << 8) | 1276 ((edid->established_timings.mfg_rsvd & 0x80) << 9); 1277 int i, modes = 0; 1278 struct detailed_mode_closure closure = { 1279 connector, edid, 0, 0, 0 1280 }; 1281 1282 for (i = 0; i <= EDID_EST_TIMINGS; i++) { 1283 if (est_bits & (1<<i)) { 1284 struct drm_display_mode *newmode; 1285 newmode = drm_mode_duplicate(dev, &edid_est_modes[i]); 1286 if (newmode) { 1287 drm_mode_probed_add(connector, newmode); 1288 modes++; 1289 } 1290 } 1291 } 1292 1293 if (version_greater(edid, 1, 0)) 1294 drm_for_each_detailed_block((u8 *)edid, 1295 do_established_modes, &closure); 1296 1297 return modes + closure.modes; 1298 } 1299 1300 static void 1301 do_standard_modes(struct detailed_timing *timing, void *c) 1302 { 1303 struct detailed_mode_closure *closure = c; 1304 struct detailed_non_pixel *data = &timing->data.other_data; 1305 struct drm_connector *connector = closure->connector; 1306 struct edid *edid = closure->edid; 1307 1308 if (data->type == EDID_DETAIL_STD_MODES) { 1309 int i; 1310 for (i = 0; i < 6; i++) { 1311 struct std_timing *std; 1312 struct drm_display_mode *newmode; 1313 1314 std = &data->data.timings[i]; 1315 newmode = drm_mode_std(connector, edid, std, 1316 edid->revision); 1317 if (newmode) { 1318 drm_mode_probed_add(connector, newmode); 1319 closure->modes++; 1320 } 1321 } 1322 } 1323 } 1324 1325 /** 1326 * add_standard_modes - get std. modes from EDID and add them 1327 * @edid: EDID block to scan 1328 * 1329 * Standard modes can be calculated using the appropriate standard (DMT, 1330 * GTF or CVT. Grab them from @edid and add them to the list. 1331 */ 1332 static int 1333 add_standard_modes(struct drm_connector *connector, struct edid *edid) 1334 { 1335 int i, modes = 0; 1336 struct detailed_mode_closure closure = { 1337 connector, edid, 0, 0, 0 1338 }; 1339 1340 for (i = 0; i < EDID_STD_TIMINGS; i++) { 1341 struct drm_display_mode *newmode; 1342 1343 newmode = drm_mode_std(connector, edid, 1344 &edid->standard_timings[i], 1345 edid->revision); 1346 if (newmode) { 1347 drm_mode_probed_add(connector, newmode); 1348 modes++; 1349 } 1350 } 1351 1352 if (version_greater(edid, 1, 0)) 1353 drm_for_each_detailed_block((u8 *)edid, do_standard_modes, 1354 &closure); 1355 1356 /* XXX should also look for standard codes in VTB blocks */ 1357 1358 return modes + closure.modes; 1359 } 1360 1361 static int drm_cvt_modes(struct drm_connector *connector, 1362 struct detailed_timing *timing) 1363 { 1364 int i, j, modes = 0; 1365 struct drm_display_mode *newmode; 1366 struct drm_device *dev = connector->dev; 1367 struct cvt_timing *cvt; 1368 const int rates[] = { 60, 85, 75, 60, 50 }; 1369 const u8 empty[3] = { 0, 0, 0 }; 1370 1371 for (i = 0; i < 4; i++) { 1372 int uninitialized_var(width), height; 1373 cvt = &(timing->data.other_data.data.cvt[i]); 1374 1375 if (!memcmp(cvt->code, empty, 3)) 1376 continue; 1377 1378 height = (cvt->code[0] + ((cvt->code[1] & 0xf0) << 4) + 1) * 2; 1379 switch (cvt->code[1] & 0x0c) { 1380 case 0x00: 1381 width = height * 4 / 3; 1382 break; 1383 case 0x04: 1384 width = height * 16 / 9; 1385 break; 1386 case 0x08: 1387 width = height * 16 / 10; 1388 break; 1389 case 0x0c: 1390 width = height * 15 / 9; 1391 break; 1392 } 1393 1394 for (j = 1; j < 5; j++) { 1395 if (cvt->code[2] & (1 << j)) { 1396 newmode = drm_cvt_mode(dev, width, height, 1397 rates[j], j == 0, 1398 false, false); 1399 if (newmode) { 1400 drm_mode_probed_add(connector, newmode); 1401 modes++; 1402 } 1403 } 1404 } 1405 } 1406 1407 return modes; 1408 } 1409 1410 static void 1411 do_cvt_mode(struct detailed_timing *timing, void *c) 1412 { 1413 struct detailed_mode_closure *closure = c; 1414 struct detailed_non_pixel *data = &timing->data.other_data; 1415 1416 if (data->type == EDID_DETAIL_CVT_3BYTE) 1417 closure->modes += drm_cvt_modes(closure->connector, timing); 1418 } 1419 1420 static int 1421 add_cvt_modes(struct drm_connector *connector, struct edid *edid) 1422 { 1423 struct detailed_mode_closure closure = { 1424 connector, edid, 0, 0, 0 1425 }; 1426 1427 if (version_greater(edid, 1, 2)) 1428 drm_for_each_detailed_block((u8 *)edid, do_cvt_mode, &closure); 1429 1430 /* XXX should also look for CVT codes in VTB blocks */ 1431 1432 return closure.modes; 1433 } 1434 1435 static void 1436 do_detailed_mode(struct detailed_timing *timing, void *c) 1437 { 1438 struct detailed_mode_closure *closure = c; 1439 struct drm_display_mode *newmode; 1440 1441 if (timing->pixel_clock) { 1442 newmode = drm_mode_detailed(closure->connector->dev, 1443 closure->edid, timing, 1444 closure->quirks); 1445 if (!newmode) 1446 return; 1447 1448 if (closure->preferred) 1449 newmode->type |= DRM_MODE_TYPE_PREFERRED; 1450 1451 drm_mode_probed_add(closure->connector, newmode); 1452 closure->modes++; 1453 closure->preferred = 0; 1454 } 1455 } 1456 1457 /* 1458 * add_detailed_modes - Add modes from detailed timings 1459 * @connector: attached connector 1460 * @edid: EDID block to scan 1461 * @quirks: quirks to apply 1462 */ 1463 static int 1464 add_detailed_modes(struct drm_connector *connector, struct edid *edid, 1465 u32 quirks) 1466 { 1467 struct detailed_mode_closure closure = { 1468 connector, 1469 edid, 1470 1, 1471 quirks, 1472 0 1473 }; 1474 1475 if (closure.preferred && !version_greater(edid, 1, 3)) 1476 closure.preferred = 1477 (edid->features & DRM_EDID_FEATURE_PREFERRED_TIMING); 1478 1479 drm_for_each_detailed_block((u8 *)edid, do_detailed_mode, &closure); 1480 1481 return closure.modes; 1482 } 1483 1484 #define HDMI_IDENTIFIER 0x000C03 1485 #define AUDIO_BLOCK 0x01 1486 #define VIDEO_BLOCK 0x02 1487 #define VENDOR_BLOCK 0x03 1488 #define SPEAKER_BLOCK 0x04 1489 #define EDID_BASIC_AUDIO (1 << 6) 1490 #define EDID_CEA_YCRCB444 (1 << 5) 1491 #define EDID_CEA_YCRCB422 (1 << 4) 1492 1493 /** 1494 * Search EDID for CEA extension block. 1495 */ 1496 u8 *drm_find_cea_extension(struct edid *edid) 1497 { 1498 u8 *edid_ext = NULL; 1499 int i; 1500 1501 /* No EDID or EDID extensions */ 1502 if (edid == NULL || edid->extensions == 0) 1503 return NULL; 1504 1505 /* Find CEA extension */ 1506 for (i = 0; i < edid->extensions; i++) { 1507 edid_ext = (u8 *)edid + EDID_LENGTH * (i + 1); 1508 if (edid_ext[0] == CEA_EXT) 1509 break; 1510 } 1511 1512 if (i == edid->extensions) 1513 return NULL; 1514 1515 return edid_ext; 1516 } 1517 EXPORT_SYMBOL(drm_find_cea_extension); 1518 1519 static int 1520 do_cea_modes (struct drm_connector *connector, u8 *db, u8 len) 1521 { 1522 struct drm_device *dev = connector->dev; 1523 u8 * mode, cea_mode; 1524 int modes = 0; 1525 1526 for (mode = db; mode < db + len; mode++) { 1527 cea_mode = (*mode & 127) - 1; /* CEA modes are numbered 1..127 */ 1528 if (cea_mode < drm_num_cea_modes) { 1529 struct drm_display_mode *newmode; 1530 newmode = drm_mode_duplicate(dev, 1531 &edid_cea_modes[cea_mode]); 1532 if (newmode) { 1533 drm_mode_probed_add(connector, newmode); 1534 modes++; 1535 } 1536 } 1537 } 1538 1539 return modes; 1540 } 1541 1542 static int 1543 cea_db_payload_len(const u8 *db) 1544 { 1545 return db[0] & 0x1f; 1546 } 1547 1548 static int 1549 cea_db_tag(const u8 *db) 1550 { 1551 return db[0] >> 5; 1552 } 1553 1554 static int 1555 cea_revision(const u8 *cea) 1556 { 1557 return cea[1]; 1558 } 1559 1560 static int 1561 cea_db_offsets(const u8 *cea, int *start, int *end) 1562 { 1563 /* Data block offset in CEA extension block */ 1564 *start = 4; 1565 *end = cea[2]; 1566 if (*end == 0) 1567 *end = 127; 1568 if (*end < 4 || *end > 127) 1569 return -ERANGE; 1570 return 0; 1571 } 1572 1573 #define for_each_cea_db(cea, i, start, end) \ 1574 for ((i) = (start); (i) < (end) && (i) + cea_db_payload_len(&(cea)[(i)]) < (end); (i) += cea_db_payload_len(&(cea)[(i)]) + 1) 1575 1576 static int 1577 add_cea_modes(struct drm_connector *connector, struct edid *edid) 1578 { 1579 u8 * cea = drm_find_cea_extension(edid); 1580 u8 * db, dbl; 1581 int modes = 0; 1582 1583 if (cea && cea_revision(cea) >= 3) { 1584 int i, start, end; 1585 1586 if (cea_db_offsets(cea, &start, &end)) 1587 return 0; 1588 1589 for_each_cea_db(cea, i, start, end) { 1590 db = &cea[i]; 1591 dbl = cea_db_payload_len(db); 1592 1593 if (cea_db_tag(db) == VIDEO_BLOCK) 1594 modes += do_cea_modes (connector, db+1, dbl); 1595 } 1596 } 1597 1598 return modes; 1599 } 1600 1601 static void 1602 parse_hdmi_vsdb(struct drm_connector *connector, const u8 *db) 1603 { 1604 u8 len = cea_db_payload_len(db); 1605 1606 if (len >= 6) { 1607 connector->eld[5] |= (db[6] >> 7) << 1; /* Supports_AI */ 1608 connector->dvi_dual = db[6] & 1; 1609 } 1610 if (len >= 7) 1611 connector->max_tmds_clock = db[7] * 5; 1612 if (len >= 8) { 1613 connector->latency_present[0] = db[8] >> 7; 1614 connector->latency_present[1] = (db[8] >> 6) & 1; 1615 } 1616 if (len >= 9) 1617 connector->video_latency[0] = db[9]; 1618 if (len >= 10) 1619 connector->audio_latency[0] = db[10]; 1620 if (len >= 11) 1621 connector->video_latency[1] = db[11]; 1622 if (len >= 12) 1623 connector->audio_latency[1] = db[12]; 1624 1625 DRM_LOG_KMS("HDMI: DVI dual %d, " 1626 "max TMDS clock %d, " 1627 "latency present %d %d, " 1628 "video latency %d %d, " 1629 "audio latency %d %d\n", 1630 connector->dvi_dual, 1631 connector->max_tmds_clock, 1632 (int) connector->latency_present[0], 1633 (int) connector->latency_present[1], 1634 connector->video_latency[0], 1635 connector->video_latency[1], 1636 connector->audio_latency[0], 1637 connector->audio_latency[1]); 1638 } 1639 1640 static void 1641 monitor_name(struct detailed_timing *t, void *data) 1642 { 1643 if (t->data.other_data.type == EDID_DETAIL_MONITOR_NAME) 1644 *(u8 **)data = t->data.other_data.data.str.str; 1645 } 1646 1647 static bool cea_db_is_hdmi_vsdb(const u8 *db) 1648 { 1649 int hdmi_id; 1650 1651 if (cea_db_tag(db) != VENDOR_BLOCK) 1652 return false; 1653 1654 if (cea_db_payload_len(db) < 5) 1655 return false; 1656 1657 hdmi_id = db[1] | (db[2] << 8) | (db[3] << 16); 1658 1659 return hdmi_id == HDMI_IDENTIFIER; 1660 } 1661 1662 /** 1663 * drm_edid_to_eld - build ELD from EDID 1664 * @connector: connector corresponding to the HDMI/DP sink 1665 * @edid: EDID to parse 1666 * 1667 * Fill the ELD (EDID-Like Data) buffer for passing to the audio driver. 1668 * Some ELD fields are left to the graphics driver caller: 1669 * - Conn_Type 1670 * - HDCP 1671 * - Port_ID 1672 */ 1673 void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid) 1674 { 1675 uint8_t *eld = connector->eld; 1676 u8 *cea; 1677 u8 *name; 1678 u8 *db; 1679 int sad_count = 0; 1680 int mnl; 1681 int dbl; 1682 1683 memset(eld, 0, sizeof(connector->eld)); 1684 1685 cea = drm_find_cea_extension(edid); 1686 if (!cea) { 1687 DRM_DEBUG_KMS("ELD: no CEA Extension found\n"); 1688 return; 1689 } 1690 1691 name = NULL; 1692 drm_for_each_detailed_block((u8 *)edid, monitor_name, &name); 1693 for (mnl = 0; name && mnl < 13; mnl++) { 1694 if (name[mnl] == 0x0a) 1695 break; 1696 eld[20 + mnl] = name[mnl]; 1697 } 1698 eld[4] = (cea[1] << 5) | mnl; 1699 DRM_DEBUG_KMS("ELD monitor %s\n", eld + 20); 1700 1701 eld[0] = 2 << 3; /* ELD version: 2 */ 1702 1703 eld[16] = edid->mfg_id[0]; 1704 eld[17] = edid->mfg_id[1]; 1705 eld[18] = edid->prod_code[0]; 1706 eld[19] = edid->prod_code[1]; 1707 1708 if (cea_revision(cea) >= 3) { 1709 int i, start, end; 1710 1711 if (cea_db_offsets(cea, &start, &end)) { 1712 start = 0; 1713 end = 0; 1714 } 1715 1716 for_each_cea_db(cea, i, start, end) { 1717 db = &cea[i]; 1718 dbl = cea_db_payload_len(db); 1719 1720 switch (cea_db_tag(db)) { 1721 case AUDIO_BLOCK: 1722 /* Audio Data Block, contains SADs */ 1723 sad_count = dbl / 3; 1724 if (dbl >= 1) 1725 memcpy(eld + 20 + mnl, &db[1], dbl); 1726 break; 1727 case SPEAKER_BLOCK: 1728 /* Speaker Allocation Data Block */ 1729 if (dbl >= 1) 1730 eld[7] = db[1]; 1731 break; 1732 case VENDOR_BLOCK: 1733 /* HDMI Vendor-Specific Data Block */ 1734 if (cea_db_is_hdmi_vsdb(db)) 1735 parse_hdmi_vsdb(connector, db); 1736 break; 1737 default: 1738 break; 1739 } 1740 } 1741 } 1742 eld[5] |= sad_count << 4; 1743 eld[2] = (20 + mnl + sad_count * 3 + 3) / 4; 1744 1745 DRM_DEBUG_KMS("ELD size %d, SAD count %d\n", (int)eld[2], sad_count); 1746 } 1747 EXPORT_SYMBOL(drm_edid_to_eld); 1748 1749 /** 1750 * drm_av_sync_delay - HDMI/DP sink audio-video sync delay in millisecond 1751 * @connector: connector associated with the HDMI/DP sink 1752 * @mode: the display mode 1753 */ 1754 int drm_av_sync_delay(struct drm_connector *connector, 1755 struct drm_display_mode *mode) 1756 { 1757 int i = !!(mode->flags & DRM_MODE_FLAG_INTERLACE); 1758 int a, v; 1759 1760 if (!connector->latency_present[0]) 1761 return 0; 1762 if (!connector->latency_present[1]) 1763 i = 0; 1764 1765 a = connector->audio_latency[i]; 1766 v = connector->video_latency[i]; 1767 1768 /* 1769 * HDMI/DP sink doesn't support audio or video? 1770 */ 1771 if (a == 255 || v == 255) 1772 return 0; 1773 1774 /* 1775 * Convert raw EDID values to millisecond. 1776 * Treat unknown latency as 0ms. 1777 */ 1778 if (a) 1779 a = min(2 * (a - 1), 500); 1780 if (v) 1781 v = min(2 * (v - 1), 500); 1782 1783 return max(v - a, 0); 1784 } 1785 EXPORT_SYMBOL(drm_av_sync_delay); 1786 1787 /** 1788 * drm_select_eld - select one ELD from multiple HDMI/DP sinks 1789 * @encoder: the encoder just changed display mode 1790 * @mode: the adjusted display mode 1791 * 1792 * It's possible for one encoder to be associated with multiple HDMI/DP sinks. 1793 * The policy is now hard coded to simply use the first HDMI/DP sink's ELD. 1794 */ 1795 struct drm_connector *drm_select_eld(struct drm_encoder *encoder, 1796 struct drm_display_mode *mode) 1797 { 1798 struct drm_connector *connector; 1799 struct drm_device *dev = encoder->dev; 1800 1801 list_for_each_entry(connector, &dev->mode_config.connector_list, head) 1802 if (connector->encoder == encoder && connector->eld[0]) 1803 return connector; 1804 1805 return NULL; 1806 } 1807 EXPORT_SYMBOL(drm_select_eld); 1808 1809 /** 1810 * drm_detect_hdmi_monitor - detect whether monitor is hdmi. 1811 * @edid: monitor EDID information 1812 * 1813 * Parse the CEA extension according to CEA-861-B. 1814 * Return true if HDMI, false if not or unknown. 1815 */ 1816 bool drm_detect_hdmi_monitor(struct edid *edid) 1817 { 1818 u8 *edid_ext; 1819 int i; 1820 int start_offset, end_offset; 1821 1822 edid_ext = drm_find_cea_extension(edid); 1823 if (!edid_ext) 1824 return false; 1825 1826 if (cea_db_offsets(edid_ext, &start_offset, &end_offset)) 1827 return false; 1828 1829 /* 1830 * Because HDMI identifier is in Vendor Specific Block, 1831 * search it from all data blocks of CEA extension. 1832 */ 1833 for_each_cea_db(edid_ext, i, start_offset, end_offset) { 1834 if (cea_db_is_hdmi_vsdb(&edid_ext[i])) 1835 return true; 1836 } 1837 1838 return false; 1839 } 1840 EXPORT_SYMBOL(drm_detect_hdmi_monitor); 1841 1842 /** 1843 * drm_detect_monitor_audio - check monitor audio capability 1844 * 1845 * Monitor should have CEA extension block. 1846 * If monitor has 'basic audio', but no CEA audio blocks, it's 'basic 1847 * audio' only. If there is any audio extension block and supported 1848 * audio format, assume at least 'basic audio' support, even if 'basic 1849 * audio' is not defined in EDID. 1850 * 1851 */ 1852 bool drm_detect_monitor_audio(struct edid *edid) 1853 { 1854 u8 *edid_ext; 1855 int i, j; 1856 bool has_audio = false; 1857 int start_offset, end_offset; 1858 1859 edid_ext = drm_find_cea_extension(edid); 1860 if (!edid_ext) 1861 goto end; 1862 1863 has_audio = ((edid_ext[3] & EDID_BASIC_AUDIO) != 0); 1864 1865 if (has_audio) { 1866 DRM_DEBUG_KMS("Monitor has basic audio support\n"); 1867 goto end; 1868 } 1869 1870 if (cea_db_offsets(edid_ext, &start_offset, &end_offset)) 1871 goto end; 1872 1873 for_each_cea_db(edid_ext, i, start_offset, end_offset) { 1874 if (cea_db_tag(&edid_ext[i]) == AUDIO_BLOCK) { 1875 has_audio = true; 1876 for (j = 1; j < cea_db_payload_len(&edid_ext[i]) + 1; j += 3) 1877 DRM_DEBUG_KMS("CEA audio format %d\n", 1878 (edid_ext[i + j] >> 3) & 0xf); 1879 goto end; 1880 } 1881 } 1882 end: 1883 return has_audio; 1884 } 1885 EXPORT_SYMBOL(drm_detect_monitor_audio); 1886 1887 /** 1888 * drm_add_display_info - pull display info out if present 1889 * @edid: EDID data 1890 * @info: display info (attached to connector) 1891 * 1892 * Grab any available display info and stuff it into the drm_display_info 1893 * structure that's part of the connector. Useful for tracking bpp and 1894 * color spaces. 1895 */ 1896 static void drm_add_display_info(struct edid *edid, 1897 struct drm_display_info *info) 1898 { 1899 u8 *edid_ext; 1900 1901 info->width_mm = edid->width_cm * 10; 1902 info->height_mm = edid->height_cm * 10; 1903 1904 /* driver figures it out in this case */ 1905 info->bpc = 0; 1906 info->color_formats = 0; 1907 1908 if (edid->revision < 3) 1909 return; 1910 1911 if (!(edid->input & DRM_EDID_INPUT_DIGITAL)) 1912 return; 1913 1914 /* Get data from CEA blocks if present */ 1915 edid_ext = drm_find_cea_extension(edid); 1916 if (edid_ext) { 1917 info->cea_rev = edid_ext[1]; 1918 1919 /* The existence of a CEA block should imply RGB support */ 1920 info->color_formats = DRM_COLOR_FORMAT_RGB444; 1921 if (edid_ext[3] & EDID_CEA_YCRCB444) 1922 info->color_formats |= DRM_COLOR_FORMAT_YCRCB444; 1923 if (edid_ext[3] & EDID_CEA_YCRCB422) 1924 info->color_formats |= DRM_COLOR_FORMAT_YCRCB422; 1925 } 1926 1927 /* Only defined for 1.4 with digital displays */ 1928 if (edid->revision < 4) 1929 return; 1930 1931 switch (edid->input & DRM_EDID_DIGITAL_DEPTH_MASK) { 1932 case DRM_EDID_DIGITAL_DEPTH_6: 1933 info->bpc = 6; 1934 break; 1935 case DRM_EDID_DIGITAL_DEPTH_8: 1936 info->bpc = 8; 1937 break; 1938 case DRM_EDID_DIGITAL_DEPTH_10: 1939 info->bpc = 10; 1940 break; 1941 case DRM_EDID_DIGITAL_DEPTH_12: 1942 info->bpc = 12; 1943 break; 1944 case DRM_EDID_DIGITAL_DEPTH_14: 1945 info->bpc = 14; 1946 break; 1947 case DRM_EDID_DIGITAL_DEPTH_16: 1948 info->bpc = 16; 1949 break; 1950 case DRM_EDID_DIGITAL_DEPTH_UNDEF: 1951 default: 1952 info->bpc = 0; 1953 break; 1954 } 1955 1956 info->color_formats |= DRM_COLOR_FORMAT_RGB444; 1957 if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB444) 1958 info->color_formats |= DRM_COLOR_FORMAT_YCRCB444; 1959 if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB422) 1960 info->color_formats |= DRM_COLOR_FORMAT_YCRCB422; 1961 } 1962 1963 /** 1964 * drm_add_edid_modes - add modes from EDID data, if available 1965 * @connector: connector we're probing 1966 * @edid: edid data 1967 * 1968 * Add the specified modes to the connector's mode list. 1969 * 1970 * Return number of modes added or 0 if we couldn't find any. 1971 */ 1972 int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid) 1973 { 1974 int num_modes = 0; 1975 u32 quirks; 1976 1977 if (edid == NULL) { 1978 return 0; 1979 } 1980 if (!drm_edid_is_valid(edid)) { 1981 dev_warn(connector->dev->dev, "%s: EDID invalid.\n", 1982 drm_get_connector_name(connector)); 1983 return 0; 1984 } 1985 1986 quirks = edid_get_quirks(edid); 1987 1988 /* 1989 * EDID spec says modes should be preferred in this order: 1990 * - preferred detailed mode 1991 * - other detailed modes from base block 1992 * - detailed modes from extension blocks 1993 * - CVT 3-byte code modes 1994 * - standard timing codes 1995 * - established timing codes 1996 * - modes inferred from GTF or CVT range information 1997 * 1998 * We get this pretty much right. 1999 * 2000 * XXX order for additional mode types in extension blocks? 2001 */ 2002 num_modes += add_detailed_modes(connector, edid, quirks); 2003 num_modes += add_cvt_modes(connector, edid); 2004 num_modes += add_standard_modes(connector, edid); 2005 num_modes += add_established_modes(connector, edid); 2006 num_modes += add_inferred_modes(connector, edid); 2007 num_modes += add_cea_modes(connector, edid); 2008 2009 if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75)) 2010 edid_fixup_preferred(connector, quirks); 2011 2012 drm_add_display_info(edid, &connector->display_info); 2013 2014 return num_modes; 2015 } 2016 EXPORT_SYMBOL(drm_add_edid_modes); 2017 2018 /** 2019 * drm_add_modes_noedid - add modes for the connectors without EDID 2020 * @connector: connector we're probing 2021 * @hdisplay: the horizontal display limit 2022 * @vdisplay: the vertical display limit 2023 * 2024 * Add the specified modes to the connector's mode list. Only when the 2025 * hdisplay/vdisplay is not beyond the given limit, it will be added. 2026 * 2027 * Return number of modes added or 0 if we couldn't find any. 2028 */ 2029 int drm_add_modes_noedid(struct drm_connector *connector, 2030 int hdisplay, int vdisplay) 2031 { 2032 int i, count, num_modes = 0; 2033 struct drm_display_mode *mode; 2034 struct drm_device *dev = connector->dev; 2035 2036 count = sizeof(drm_dmt_modes) / sizeof(struct drm_display_mode); 2037 if (hdisplay < 0) 2038 hdisplay = 0; 2039 if (vdisplay < 0) 2040 vdisplay = 0; 2041 2042 for (i = 0; i < count; i++) { 2043 const struct drm_display_mode *ptr = &drm_dmt_modes[i]; 2044 if (hdisplay && vdisplay) { 2045 /* 2046 * Only when two are valid, they will be used to check 2047 * whether the mode should be added to the mode list of 2048 * the connector. 2049 */ 2050 if (ptr->hdisplay > hdisplay || 2051 ptr->vdisplay > vdisplay) 2052 continue; 2053 } 2054 if (drm_mode_vrefresh(ptr) > 61) 2055 continue; 2056 mode = drm_mode_duplicate(dev, ptr); 2057 if (mode) { 2058 drm_mode_probed_add(connector, mode); 2059 num_modes++; 2060 } 2061 } 2062 return num_modes; 2063 } 2064 EXPORT_SYMBOL(drm_add_modes_noedid); 2065