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