drm_edid.c

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

FreeBSD/Linux Kernel Cross Reference
sys/dev/drm2/drm_edid.c
