sys/dev/drm/drm_edid.c

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